refactor(go/plugins/googlegenai): migrate to the typed-config constructors

[apascal07]

Migrates the googlegenai plugin (Google AI and Vertex AI) to the typed-config constructors from #5849, the third PR of the train. Every primitive the plugin defines now declares its config type and receives it deserialized, so the four hand-rolled config mappers are gone: configFromRequest, imagenConfigFromRequest, toVeoParameters, and the embedder's pointer type assertion.

Before: each modality re-implements the same type switch.

func configFromRequest(input *ai.ModelRequest) (*genai.GenerateContentConfig, error) {
    switch config := input.Config.(type) {
    case genai.GenerateContentConfig:  return &config, nil
    case *genai.GenerateContentConfig: return config, nil
    case map[string]any:               return base.MapToStruct[genai.GenerateContentConfig](config)
    case nil:                          return &genai.GenerateContentConfig{}, nil
    default:                           return nil, core.NewPublicError(...)
    }
}
ai.NewModel(name, meta, fn)

After: the type parameter is inferred from the function and the framework fills it.

ai.NewTypedModel(name, &opts,
    func(ctx context.Context, input *ai.ModelRequest, config genai.GenerateContentConfig, cb ai.ModelStreamCallback) (*ai.ModelResponse, error) {
        return generate(ctx, client, name, input, config, cb)
    })

• The config type follows the modality: image models take a genai.GenerateImagesConfig, Veo takes a genai.GenerateVideosConfig, the embedder takes a genai.EmbedContentConfig, and everything else (Gemini, Gemma, TTS, tuned endpoints, unrecognized names) speaks generateContent and takes a genai.GenerateContentConfig.
• The config travels by value from the model function down, so toGeminiRequest amends the request's own copy. The old pointer path let a Veo request write its NumberOfVideos default into the caller's config struct.
• The media-download middleware wraps a closure over that copy, leaving the built-in chain order unchanged.
• newModel, newVeoModel, and newEmbedder return the concrete *ai.ModelAction, *ai.BackgroundModelAction, and *ai.EmbedderAction, so listActions and ResolveAction no longer assert their way back to api.Action. The exported DefineModel/DefineEmbedder methods keep their interface returns.
• The Veo start/check helper actions move from the deprecated core.NewAction to core.NewActionOf, which turns the check action's description into a field instead of a metadata entry.

Config schemas are now enforced

The plugin supplies ConfigSchema explicitly (the SDK structs need a custom reflector to avoid recursion panics, plus curated descriptions for the dev UI), and the typed constructors wire that schema into the request input schema, which is validated on every call. Two consequences:

The curated schema hides fields the plugin manages, and hiding is a presentation choice, not a narrowing of what callers may send. Left alone, candidateCount: 1 would start failing even though the plugin pins it to 1 itself, and systemInstruction, cachedContent, responseSchema, responseMimeType, responseJsonSchema, and tools[].functionDeclarations would be rejected as unknown properties instead of reaching the plugin's own check, which names the primitive to use instead (ai.WithSystemPrompt, ai.WithCacheTTL, ai.WithOutputType, ai.WithTools). So an object that loses a property is reopened with additionalProperties: true. Objects that kept every field stay strict, and the Imagen and Veo schemas, which hide nothing, are untouched.

The three modality schemas are now built once at package level instead of being reflected per model. GetModelOptions was doing that work on every call, which listActions makes once per model.

Fixes

Embedder options were read with a *genai.EmbedContentConfig type assertion, so a map[string]any (what the dev UI and every other JSON caller sends) was silently dropped and the embed call went out with no config at all. The framework now deserializes it.

Verification

Go 1.26.3, go test ./plugins/googlegenai/...: passes, 56 top-level tests and 222 including subtests, 2 skipped (they need live credentials), no failures.

New coverage: the config schema each action advertises is pinned per modality, every field the curated schemas hide still reaches the plugin's own error naming the Genkit primitive to use, and a map[string]any config reaches the embedder deserialized.

[gemini-code-assist]

Code Review

This pull request refactors the googlegenai plugin to leverage Genkit's typed models, embedders, and background models, delegating request configuration validation and deserialization to the framework. This simplifies model initialization and removes redundant manual configuration conversion logic. The review feedback focuses on performance optimization, recommending that large configuration structs (such as genai.GenerateImagesConfig and genai.GenerateContentConfig) be passed by pointer rather than by value to avoid unnecessary copying.

[gemini-code-assist]

Pass config by pointer to generateImage to avoid copying the large genai.GenerateImagesConfig struct.

Suggested change

	return generateImage(ctx, client, name, input, config, cb)
	return generateImage(ctx, client, name, input, &config, cb)

[gemini-code-assist]

Pass config by pointer to toGeminiRequest to avoid copying the large genai.GenerateContentConfig struct.

Suggested change

	gcc, err := toGeminiRequest(input, config, cache, model)
	gcc, err := toGeminiRequest(input, &config, cache, model)

[gemini-code-assist]

Change the signature of toGeminiRequest to accept config as a pointer *genai.GenerateContentConfig instead of a value. This avoids copying the large configuration struct on every request.

Suggested change

	func toGeminiRequest(input *ai.ModelRequest, config genai.GenerateContentConfig, cache *genai.CachedContent, modelName ...string) (*genai.GenerateContentConfig, error) {
	gcc := &config
	func toGeminiRequest(input *ai.ModelRequest, config *genai.GenerateContentConfig, cache *genai.CachedContent, modelName ...string) (*genai.GenerateContentConfig, error) {
	gcc := config

[gemini-code-assist]

Pass config by pointer to toGeminiRequest to match the updated signature.

Suggested change

	return toGeminiRequest(input, config, cache, modelName...)
	return toGeminiRequest(input, &config, cache, modelName...)

[gemini-code-assist]

Change the signature of generateImage to accept gic as a pointer *genai.GenerateImagesConfig instead of a value to avoid copying the large struct.

Suggested change

	gic genai.GenerateImagesConfig,
	gic *genai.GenerateImagesConfig,

[gemini-code-assist]

Pass gic directly instead of &gic since it is now a pointer.

Suggested change

	resp, err := client.Models.GenerateImages(ctx, model, userPrompt, &gic)
	resp, err := client.Models.GenerateImages(ctx, model, userPrompt, gic)