chore(deps): update all non-major dependencies

[renovate-bot]

ℹ️ Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package	Change	Age	Confidence
cloud.google.com/go/secretmanager	v1.16.0 → v1.21.0
cloud.google.com/go/storage	v1.61.3 → v1.67.0
github.com/firebase/genkit/go	v1.10.0 → v1.13.1
github.com/stretchr/testify	v1.11.1 → v1.12.1
google.golang.org/adk/v2	v2.0.0 → v2.3.0
google.golang.org/api	v0.272.0 → v0.297.0
google.golang.org/api	v0.279.0 → v0.297.0
google.golang.org/genai	v1.57.0 → v1.71.0

---

Release Notes

googleapis/google-cloud-go (cloud.google.com/go/secretmanager)

v1.21.0: datastore: v1.21.0

Features

• datastore: Support field transforms (#​12400) (7defdd0)

Bug Fixes

• datastore: Resolve data race on transaction state (#​12912) (011b148), refs #​11038
• datastore: Upgrade gRPC service registration func (8fffca2)

v1.20.0: datastore: v1.20.0

Features

• datastore: Add FindNearest API to the stable branch (#​10980) (f0b05e2)
• datastore: Support for field update operators in the Datastore API and resolution strategies when there is a conflict at write time (78d8513)

Bug Fixes

• datastore: Bump dependencies (2ddeb15)
• datastore: Do not delay on final transaction attempt (#​10824) (0d732cc)
• datastore: Remove namespace from Key.String() (40229e6)
• datastore: Remove namespace from Key.String() (#​10684) (#​10823) (40229e6)
• datastore: Update google.golang.org/api to v0.203.0 (8bb87d5)
• datastore: Use local retryer in transactions (#​11050) (3ef61a2)
• datastore: WARNING: On approximately Dec 1, 2024, an update to Protobuf will change service registration function signatures to use an interface instead of a concrete type in generated .pb.go files. This change is expected to affect very few if any users of this client library. For more information, see https://redirect.github.com/googleapis/google-cloud-go/issues/11020. (8bb87d5)

v1.19.0: datastore: v1.19.0

Features

• datastore: Reference new protos (#​10724) (d8887df)

v1.18.0: datastore: v1.18.0

Features

• datastore: Add support for Go 1.23 iterators (84461c0)
• datastore: Start generating datastorepb protos (946a5fc)

Bug Fixes

• datastore: Bump google.golang.org/api@​v0.187.0 (8fa9e39)
• datastore: Bump google.golang.org/grpc@​v1.64.1 (8ecc4e9)
• datastore: Ignore field mismatch errors (#​8694) (6625d12)
• datastore: Update dependencies (257c40b)
• datastore: Update google.golang.org/api to v0.191.0 (5b32644)

v1.17.0: datastore: v1.17.0

Features

• datastore: Add query profiling (#​9200) (b0235bb)

firebase/genkit (github.com/firebase/genkit/go)

v1.13.1: Genkit Go v1.13.1

v1.13.0 is retracted. It ships the A2UI preview at github.com/firebase/genkit/go/plugins/a2ui, while its release notes describe github.com/firebase/genkit/go/plugins/a2ui/exp. This release moves the package to the documented path and records the retraction in go.mod, so go get github.com/firebase/genkit/go@latest resolves here and version listings hide v1.13.0. Everything else in the v1.13.0 notes applies unchanged.

import a2uix "github.com/firebase/genkit/go/plugins/a2ui/exp"

What's Changed

• refactor(go/plugins/a2ui): move the plugin to a2ui/exp while it is in preview by @​apascal07 in genkit-ai#6275
• chore(go): retract v1.13.0 by @​apascal07 in genkit-ai#6276

Full Changelog: genkit-ai/genkit@go/v1.13.0...go/v1.13.1

v1.13.0: Genkit Go v1.13.0

[!WARNING]
Retracted. This version ships the A2UI preview at github.com/firebase/genkit/go/plugins/a2ui, not at the plugins/a2ui/exp path the notes below describe. Use v1.13.1: it moves the package to the documented path and retracts this version in go.mod. Everything else below applies to v1.13.1 unchanged.

Progress survives failure. A generate call that fails or is stopped returns the conversation up to its last completed tool round, beside the classified error. An agent commits that conversation as a failed or aborted snapshot, and both resume. Sub-agents run in the background, get waited on or aborted, and pick up where they left off from any process holding the task ID. Beyond that, the experimental A2UI plugin lets an agent stream interactive UI to a browser.

go get github.com/firebase/genkit/go@v1.13.0

Generate returns what it finished, even on failure

Once the request has resolved, Generate returns the partial response beside its error:

resp, err := genkit.Generate(ctx, g,
	ai.WithModelName("googleai/gemini-flash-latest"),
	ai.WithPrompt("Plan the trip."),
	ai.WithTools(searchFlights, bookHotel),
	ai.WithMaxTurns(3),
)
if err != nil && resp != nil {
	resp.History()     // The completed rounds. Send them back to retry the failed step.
	resp.FinishReason  // Failed if something broke, Aborted if the caller stopped it.
	resp.FinishMessage // The cause, e.g. "exceeded maximum tool call iterations (3)".
	resp.Error         // The same cause, classified: Status, Message, Details.
}

ai.FinishReasonFailed means something broke: a model call or a tool. ai.FinishReasonAborted means the caller stopped it: a cancelled context, an expired deadline, or a limit such as WithMaxTurns. resp.Error is the classified form of FinishMessage, so a response read back from a trace or a persisted turn still says why it stopped.

History() ends at a turn seam: the completed rounds of model message plus every tool response, and nothing from the turn that failed. No provider accepts a conversation ending in an unanswered tool request, so a failed tool drops its whole round, including the model message that opened it. Send the history back to retry the failed step without repeating the tool calls that succeeded. Text streamed before the failure already reached your callback.

GenerateStream and GenerateDataStream yield the same partial beside their error, Done and carrying Response.

Values survive the action boundary

Action.Run zeroed its output on any error, the JSON surface marshaled nothing, and the trace recorded output only on success. All three now carry whatever the function returned: a flow that returns a value beside an error hands it to its caller, an output that failed schema validation comes back with its error, and a failed generate's conversation shows up in the Dev UI trace.

A blocked response is an error, not a schema mismatch

GenerateData, GenerateDataStream, DataPrompt.Execute, and DataPrompt.ExecuteStream parsed a safety-blocked response and reported Expected: object, given: null. They now return ai.ErrGenerationBlocked, a FAILED_PRECONDITION subtype, with the response alongside:

out, resp, err := genkit.GenerateData[Itinerary](ctx, g,
	ai.WithModelName("googleai/gemini-flash-latest"),
	ai.WithPrompt("Plan a week in Kyoto."),
)
if errors.Is(err, ai.ErrGenerationBlocked) {
	log.Printf("refused: %s", resp.FinishMessage)
}

Interrupts, tool requests, and empty responses keep a nil output and a nil error. Streamed chunks parse before any finish reason exists, so the terminal value settles the call. Generate still hands a blocked response back as a value.

Resume any turn, whether it succeeded, failed, or was aborted

Agents in ai/exp build on the partial. A failed turn commits the tool rounds it completed as a failed snapshot carrying the error, and resume accepts it:

out, _ := agent.RunText(ctx, "Book the full itinerary.")
if out.FinishReason == aix.AgentFinishReasonFailed {
	snap, _ := agent.GetSnapshot(ctx, out.SnapshotID)
	snap.Status         // aix.SnapshotStatusFailed, no longer a dead end
	snap.Error          // the classified failure, same as out.Error
	snap.State.Messages // the tool rounds the turn completed
}

Re-attempt with an input that has no payload. The turn runs again on the committed messages, so the tool calls that succeeded are not repeated:

retried, err := agent.Run(ctx, &aix.AgentInput{}, aix.WithSessionID[any](out.SessionID))

A new message works on that snapshot too, and rewinding past the failure is a resume from the previous snapshot ID. Whether to retry is your call: the runtime records the status and never judges it.

Every failure past the model call commits. A turn rejected before it reached the model rolls back, and the resume point stays the turn before. AgentOutput.SnapshotID names the latest resumable state either way. Custom agents opt in by returning a TurnResult beside the error; a bare error still discards the turn. Without a store, the failed output's State carries the same resume point inline.

The turn-end snapshot now writes on a context that outlives the turn's own, so a turn cancelled from outside still lands its snapshot.

aborted means the caller stopped it

aborted now covers every way a caller ends a run, and failed every way one breaks. A cancelled context, a closed transport, an expired deadline, a limit such as ai.WithMaxTurns, or Abort on a detached run: each lands an aborted snapshot holding the turns that finished, and each resumes like a failed one. Run returns that snapshot's output beside the error instead of nil:

ctx, cancel := context.WithCancel(ctx)
out, err := chatAgent.Run(ctx, &aix.AgentInput{Message: msg}) // cancel() elsewhere

// err is what stopped the run; out names where it stopped.
if out.FinishReason == aix.AgentFinishReasonAborted {
	resumed, _ := chatAgent.Run(context.Background(), &aix.AgentInput{},
		aix.WithSnapshotID[any](out.SnapshotID))
}

The turn in flight is discarded whole. A tool that ran inside it runs again on resume.

Wind-down has its own status: aborting

A detached run reaches aborted in two writes: the flip that stops the work, and the finalize that stamps the state on. The row between them was aborted with no state, shaped as pending. It is now aborting, a shared wire status. The worker keeps heartbeating through its wind-down for up to five minutes, so a wedged drain reads as expired instead of hanging forever. WaitForSnapshot waits through the window, and the abort companion answers aborting where it answered aborted.

The basic-agents CLI shows all of it: a broken or stopped turn is offered like any other, and an empty line re-runs the turn it left unanswered.

Sub-agents run in the background and pick up where they left off

Reach any agent by name with AgentHandle

AgentHandle is the caller-side view of an agent for code that knows it only by name (orchestrators, middleware, tools), with custom state as json.RawMessage. One lookup replaces the action lookup, the BidiAction assertion, and the JSON marshaling:

h := genkitx.LookupAgent(g, "researcher") // nil on a miss; or agent.Handle()
out, err := h.RunText(ctx, task,
	aix.WithState(&aix.SessionState[json.RawMessage]{Messages: history}))

RunDetached is the one-shot counterpart of AgentConnection.Detach. A DetachedTask is a snapshot ID plus the agent that minted it, so any process can rehydrate it:

task, err := agent.RunDetached(ctx, &aix.AgentInput{Message: msg})
id := task.SnapshotID() // record it

task = agent.Task(id)          // any process, any time later
snap, err := task.Poll(ctx)    // one read
snap, err = task.Wait(ctx)     // blocks until it settles
status, err := task.Abort(ctx)

POST /agents/{name}/waitForSnapshot is the blocking counterpart of getSnapshot: one request follows a detached run to completion, and a trace carries one span per wait instead of one per tick. Handle calls are shaped like a remote client's: the state transform applies, a stale pending row reads as expired, and errors match by status name, so an HTTP-backed handle is a second implementation rather than a second surface.

GetSnapshot, GetLatestSnapshot, and Poll take aix.WithMetadataOnly(), which returns status, finish reason, parent, and timestamps without the conversation. Stores that implement the optional SnapshotMetadataReader (the bundled local stores and Firestore) skip loading the history; Firestore answers with one document read. Other stores keep compiling and are read in full.

Delegate without waiting

With Async set on the Agents middleware, every delegation tool takes a background flag that returns a task ID at once, and three shared tools control what was launched:

researcher := genkitx.DefineAgent(g, "researcher",
	aix.InlinePrompt{
		ai.WithModelName("googleai/gemini-flash-latest"),
		ai.WithSystem("You are a thorough research assistant."),
	},
	aix.WithDescription[any]("Researches a topic and summarizes well-sourced findings."),
	// A background delegation is tracked by a snapshot, so the sub-agent needs a store.
	aix.WithSessionStore(localstore.NewInMemorySessionStore[any]()),
)

ai.WithUse(&middlewarex.Agents{
	Agents: []aix.AgentRef{researcher.Ref()},
	Async:  true,
})

delegate_to_researcher    {task, name?, background: true}
                          -> {response, taskId: "researcher:<snapshotId>", status: "pending"}
check_background_tasks    {taskIds}
                          -> {tasks: [{taskId, agent, status, response?, artifacts?, error?}]}
wait_for_background_tasks {taskIds, timeoutSeconds?, waitFor?: "all" | "first"}
                          -> the same, plus timedOut
abort_background_tasks    {taskIds}
                          -> the same, each task reported where the stop left it

The middleware keeps no task registry. The task ID rides in the tool result, so the orchestrator's history is the registry, and an orchestrator rebuilt from that history can still collect. wait_for_background_tasks follows tasks through waitForSnapshot, so each is reported the moment it settles; timeoutSeconds turns a slow task into an interim answer, and waitFor: "first" turns the join into a race. Abort never loses an answer: a finished task reports its result, and a live one reports aborting while it saves its progress. The optional name on a delegation is a label echoed beside the taskId.

The basic-agents sample gained an incident commander built on this: two investigators launched in the background, a status update posted while they run, and results collected with a short timeout first.

Continue a delegation instead of restarting it

Every settled server-managed delegation returns a taskId naming its last committed snapshot, and continue_task spends it:

continue_task {taskId, instructions?, background?}
              -> a delegation result, or a fresh pending handle when background

A failed or aborted task continues from its last saved progress: empty instructions re-attempt the committed turn, non-empty ones steer the retry. A completed task takes follow-up instructions inside the sub-agent's own session. An expired task is abort-fenced, then continued from its parent snapshot. An interrupted task is refused, since continuing it would mean answering the interrupt. The tool registers only when a configured sub-agent can leave a handle behind.

Stream interactive UI with A2UI

The new preview a2ui plugin adds A2UI support: an agent streams interactive surfaces that a client renders incrementally. The integration is one middleware:

import a2uix "github.com/firebase/genkit/go/plugins/a2ui/exp"

resp, err := genkit.Generate(ctx, g,
	ai.WithModelName("googleai/gemini-flash-latest"),
	ai.WithSystem("You help users. Render UI when it is clearer than prose."),
	ai.WithPrompt("show me the weather in Tokyo"),
	ai.WithUse(&a2uix.Surfaces{}), // defaults to the bundled 'basic' catalog
)

// A2UI envelopes ride as data parts on the response message.
envelopes := a2uix.EnvelopesFromParts(resp.Message.Content)

Surfaces injects the catalog's capabilities into the system prompt, extracts a2ui fenced blocks from streamed chunks and the final message, validates them against the catalog, and rewrites them into data parts with mime type application/a2ui+json. The envelopes are byte-compatible with the JS and Dart plugins and the @a2ui/* renderers. Register your own components with LoadCatalog or LoadCatalogFile and reference them by CatalogID. Validate (warn, strict, off) checks structure and component names, not prop values: treat rendered surfaces as untrusted model output.

Register &a2ui.A2UI{} as a plugin to reference the middleware by name from .prompt files and the Dev UI. go/samples/basic-middleware/a2ui serves the endpoint the browser frontend in js/testapps/a2ui/web expects, so the existing web UI works unchanged against Go.

Smaller things worth knowing

• The OpenAI-compatible family no longer forwards OpenAI's identity. The SDK reads OPENAI_API_KEY, OPENAI_ORG_ID, and OPENAI_PROJECT_ID for every client it builds, so requests to DeepSeek or xAI carried OpenAI-Organization and OpenAI-Project, and the Anthropic compat plugin sent the OpenAI key as its bearer token when ANTHROPIC_API_KEY was unset. Init now clears all three; the openai plugin sets them itself.
• Gemini explicit context caching no longer pays twice. The cached prefix was also sent inline, every request created a new cache, the content hash could not tell two caches apart, and WithCacheTTL and WithCacheName cancelled each other. The prefix now leaves the wire once cached, a matching cache is reused, and the markers compose: ai.NewUserTextMessage(doc).WithCacheTTL(3600).WithCacheName(known). Gemini 2.5 and newer cache repeated prefixes implicitly at no storage charge, so the explicit path earns its cost only when the hit must be guaranteed.
• Background-action companions register as {name}/check and {name}/cancel, the form JS, Python, and the Dev UI use, so the Dev UI's background-task panel works against Go background models.
• Each JSON-dispatched middleware call gets its own config. Pointer prototypes were decoded into in place, so one call's field leaked into the next, two .prompt files sharing a middleware leaked into each other, and concurrent dispatch raced. Prototypes now register by value; *Retry still satisfies ai.Middleware.
• Every built-in middleware config field carries a description the Dev UI shows as a tooltip, and the Statuses fields of Retry and Fallback offer the status names as an enum. status.Names() returns them in gRPC code order.
• Tool descriptions no longer truncate at the first comma: description=If true, descend into subdirectories. reached the model as If true. Descriptions moved to jsonschema_description, and a schema test rejects description= inside a jsonschema tag.
• Bidi connections prefer completion over cancellation. Send no longer reports CANCELLED for a teardown that was the action finishing, and a committed result is no longer replaced by the caller's deadline, which is what keeps a detached agent handoff from reading as a failed launch.
• A middleware New failure keeps its classification instead of collapsing to INVALID_ARGUMENT.
• Resumed tool messages are ordered by their requests' positions, as first-run ones already were, and an interrupt replay restores a resolved sibling's full multipart response, Content and Metadata included.
• Each tool-loop turn's generate span records the messages that turn sent, built after the WrapGenerate hooks. The duplicate turn-zero generate span is gone, each turn gets its own *ModelRequest, a resume keeps WithStepName, and util actions keep t:action in their trace paths.
• Reasoning parts survive the wire. A signature-less part no longer carries an empty metadata map, so the Dev UI shows one Reasoning box per thought, and an empty reasoning part no longer round-trips as text.
• googlegenai defaults to a plain HTTP client, like every other plugin and runtime, which removes the extra HTTP spans from the Dev UI. Set HTTPClient with an otelhttp transport to opt back in.
• The agent conformance spec gains a requires capability gate. Go declares resumable-failures and resumable-aborts and runs every case; JS and Python skip those eight until they adopt the behavior.
• The Go README covers re-attempting failed turns, stopping and continuing a run, background delegation, and continue_task. The godoc examples for genkit.Handler, genkit.HandlerFunc, DefineStreamingFlow, and the telemetry plugins compile when pasted.

Before you upgrade

No signatures change. Each of these is a value or a status that now arrives where it used to be absent.

• Any action, flow, or tool that returns a value beside an error now hands that value to its caller. Code that branches on the value without checking the error will notice. GenerateText returns the partial's text beside a post-processing error where it returned "".
• The typed helpers return ai.ErrGenerationBlocked for a blocked response where they returned a schema error, and a string Out for a response with nothing to extract leaves the text on resp.Text().
• In ai/exp: resume accepts failed and aborted snapshots; AgentInput{} runs a turn on a session that has messages; a turn ended by a cancelled context, an expired deadline, or a caller-set limit writes aborted where it wrote failed; the abort companion answers aborting for a live detached row; and a custom agent returning a non-nil TurnResult beside an error now commits that turn.
• Hand-built /check-operation/{model} keys no longer resolve. Operation.Action still carries the start key.
• googlegenai no longer installs an OpenTelemetry HTTP transport by default.
• A generate span carries the same messages as the model span inside it, so tool-loop trace payload roughly doubles; dropping the duplicate turn-zero span offsets part of that.

v1.12.0: Genkit Go v1.12.0

xAI, DeepSeek, DashScope, Kimi, Z.ai, and OpenRouter join the OpenAI-compatible family, all of it rebuilt on typed per-provider configs that the framework validates before a request is billed. Failures now carry a status from the line that raised them through the retry middleware to the HTTP response, and provider SDK errors arrive already classified. Logs attach to the span that produced them. Prompt content functions are typed against the prompt's own input. Options that used to reject a repeat now merge.

go get github.com/firebase/genkit/go@v1.12.0

Six providers join the OpenAI-compatible core

Genkit Go ships plugins for xAI, DeepSeek, DashScope (Qwen), Kimi, Z.ai (GLM), and OpenRouter. They sit beside openai and the OpenAI-compatible anthropic plugin on a rebuilt compat_oai core.

Each of the six declares a ChatConfig covering exactly the fields its provider documents: Kimi's K-series takes no temperature, Z.ai caps it at 1, DeepSeek carries a user_id that partitions its context cache. The plugin advertises the JSON schema inferred from that struct and the framework enforces it at the action boundary, so an out-of-range value fails before the request is billed, and the Dev UI renders the same schema as a form.

g := genkit.Init(ctx, genkit.WithPlugins(&deepseek.DeepSeek{})) // DEEPSEEK_API_KEY

model := deepseek.ModelRef("deepseek-v4-pro", &deepseek.ChatConfig{
	ReasoningEffort: deepseek.ReasoningEffortMax,
})

g := genkit.Init(ctx, genkit.WithPlugins(&kimi.Kimi{})) // KIMI_API_KEY

model := kimi.ModelRef("kimi-k3", &kimi.ChatConfig{
	Thinking: &kimi.ThinkingConfig{Type: kimi.ThinkingTypeEnabled},
})

g := genkit.Init(ctx, genkit.WithPlugins(&xai.XAI{})) // XAI_API_KEY

model := xai.ModelRef("grok-4.6", &xai.ChatConfig{
	ReasoningEffort: xai.ReasoningEffortXHigh,
})

g := genkit.Init(ctx, genkit.WithPlugins(&zai.ZAI{})) // ZAI_API_KEY

model := zai.ModelRef("glm-5.1", &zai.ChatConfig{
	Thinking: &zai.ThinkingConfig{Type: zai.ThinkingTypeEnabled},
})

g := genkit.Init(ctx, genkit.WithPlugins(&dashscope.DashScope{})) // DASHSCOPE_API_KEY

// openai.Ptr is the openai-go SDK helper for optional fields.
model := dashscope.ModelRef("qwen-plus", &dashscope.ChatConfig{
	EnableThinking: openai.Ptr(true),
	ThinkingBudget: openai.Ptr(2048),
})

OpenRouter reaches the rest

OpenRouter fronts hundreds of models from dozens of vendors. The plugin curates nothing: you name a model, and the ID keeps its upstream vendor prefix, which puts two slashes in an action name such as openrouter/openai/gpt-5. The gateway controls are typed at the call site. Choose which providers may serve the request, chain fallback models, set reasoning effort.

g := genkit.Init(ctx, genkit.WithPlugins(&openrouter.OpenRouter{})) // OPENROUTER_API_KEY

resp, err := genkit.Generate(ctx, g,
	ai.WithModel(openrouter.ModelRef("openai/gpt-5", &openrouter.ChatConfig{
		// Try these in order if gpt-5 is unavailable.
		Models: []string{"anthropic/claude-sonnet-4.5", "deepseek/deepseek-v4-pro"},
		Provider: &openrouter.ProviderRouting{
			Sort:           openrouter.ProviderSortThroughput,
			DataCollection: openrouter.DataCollectionDeny,
		},
		Reasoning: &openrouter.ReasoningConfig{Effort: openrouter.ReasoningEffortHigh},
	})),
	ai.WithPrompt("Work through this step by step."),
)

The family reads a provider's non-standard reasoning field, reasoning_content first and reasoning second, back as a Genkit reasoning part, so resp.Reasoning() covers DeepSeek, Kimi, and OpenRouter alike. A gateway that reports what it charged puts the figure under the cost key of Usage.Custom. Test for the key rather than a nonzero value: a free-tier request is priced at an explicit zero.

fmt.Println(resp.Reasoning())
if cost, ok := resp.Usage.Custom["cost"]; ok {
	fmt.Printf("this answer cost %.5f\n", cost)
}

Google and Claude, closer to the metal

Vertex AI Express Mode authenticates with an API key alone: no project, no location, no ADC. Both Google backends take BaseURL, Headers, and HTTPClient, so a proxy or a custom transport is a struct field, and GoogleAI takes APIVersion as well. Client() hands back the genai SDK client for Files, Caches, Batches, and Tunings. When a 429 names its own backoff, RetryDelay reads it.

gemini := &googlegenai.GoogleAI{
	APIVersion: "v1alpha",
	Headers:    http.Header{"X-Team": {"platform"}},
}
// Express Mode: a Vertex AI key, no project, no location, no ADC.
vertex := &googlegenai.VertexAI{APIKey: "YOUR_VERTEX_API_KEY"}

g := genkit.Init(ctx, genkit.WithPlugins(gemini, vertex))

client, err := gemini.Client()
if err != nil {
	return err
}
file, err := client.Files.UploadFromPath(ctx, "photo.jpg", &genai.UploadFileConfig{
	MIMEType: "image/jpeg",
})

_, err = genkit.Generate(ctx, g,
	ai.WithModelName("googleai/gemini-flash-latest"),
	ai.WithPrompt("Explain how neural networks learn."),
)
if err != nil {
	if delay, ok := googlegenai.RetryDelay(err); ok {
		time.Sleep(delay) // the service named its own backoff
	}
	return err
}

On the native Claude plugin, Opts carries anthropic-sdk-go request options into the client: retries, timeouts, middleware, and the SDK's Bedrock and Vertex routing helpers. ModelRef binds a *anthropic.MessageNewParams to a model ID, so thinking, effort, and server-side tools are typed at the call site.

g := genkit.Init(ctx, genkit.WithPlugins(&anthropic.Anthropic{
	Opts: []option.RequestOption{option.WithMaxRetries(5)},
}))

resp, err := genkit.Generate(ctx, g,
	ai.WithModel(anthropic.ModelRef("claude-sonnet-5", &sdk.MessageNewParams{
		MaxTokens: 4000,
		Thinking: sdk.ThinkingConfigParamUnion{
			OfAdaptive: &sdk.ThinkingConfigAdaptiveParam{},
		},
		OutputConfig: sdk.OutputConfigParam{Effort: sdk.OutputConfigEffortHigh},
	})),
	ai.WithPrompt("Plan the migration."),
)

Every model plugin, Google and Claude included, takes a Models map keyed by model ID that overrides the capabilities the plugin resolves. Fields left at zero keep what the plugin already knows, so one entry describes a model released after the plugin without forking it.

Classify a failure once, and it stays classified

Genkit has one error type and one status vocabulary: InvalidArgument, NotFound, PermissionDenied, Unauthenticated, ResourceExhausted, Unavailable, DeadlineExceeded, Internal, and nine more. The names follow the Google API error model and mean the same thing in the JS and Python runtimes. Classify a failure at the point where you know what it is.

// Keeps NOT_FOUND from its parent, and matches both itself and status.ErrNotFound.
var ErrRecipeNotFound = status.ErrNotFound.Subtype("recipe not found")

func lookupRecipe(dish string) (string, error) {
	recipe, ok := cookbook[dish]
	if !ok {
		return "", status.PublicErrorf(ErrRecipeNotFound, "no recipe for %q", dish)
	}
	return recipe, nil
}

func plateUp(dish string) (string, error) {
	recipe, err := lookupRecipe(dish)
	if err != nil {
		return "", fmt.Errorf("plating %q: %w", dish, err)
	}
	return recipe, nil
}

Subtype derives a sentinel that keeps its parent status. Errorf builds a message for your logs, PublicErrorf marks one safe to hand a caller. Adding context with %w changes nothing else: the sentinel, the status, and the public message all survive the trip up the stack. No re-wrapping, no matching on message text.

switch {
case errors.Is(err, ErrRecipeNotFound):        // this exact failure
case errors.Is(err, status.ErrNotFound):       // anything missing
case errors.Is(err, status.ErrResourceExhausted): // rate limited or out of quota
}

status.Of(err)            // status.NotFound
status.Of(err).HTTPCode() // 404
msg, public := status.PublicMessage(err) // `no recipe for "lasagna"`, true

Code you did not write reads the classification

Serve the flow with genkit.Handler and the response code comes from the classification. The message only leaves the process when you built it with PublicErrorf.

genkit.DefineFlow(g, "recipe", func(ctx context.Context, dish string) (string, error) {
	if dish == "" {
		// 400, body: dish must not be empty
		return "", status.PublicErrorf(status.ErrInvalidArgument, "dish must not be empty")
	}
	if dish == "escargot" {
		// 400, body: invalid argument
		return "", status.Errorf(status.ErrInvalidArgument, "supplier for %q is offline", dish)
	}
	// 500, body: internal
	return "", errors.New("db at 10.0.0.3: password rejected")
})

Everything else is redacted to the generic label for its status, and the full text goes to the server log. Set GENKIT_ENV=dev and the real message comes back instead; the code is the same either way.

The reach of that classification is what changed. Every plugin now classifies what its provider SDK returns, so a 401 from Anthropic or a 429 from Gemini arrives already carrying Unauthenticated or ResourceExhausted. Retry and Fallback have always read a classification and disagreed on purpose: Retry reissues a ResourceExhausted or Unavailable call, leaves an InvalidArgument alone, and retries an unclassified error because a dial timeout deserves another attempt, while Fallback propagates an unclassified error rather than spending a second billed model on it. What is different is that provider failures now reach them classified instead of opaque.

resp, err := genkit.Generate(ctx, g,
	ai.WithModelName("googleai/gemini-flash-latest"),
	ai.WithPrompt("Draft the menu."),
	ai.WithUse(
		&middleware.Retry{MaxRetries: 3},
		&middleware.Fallback{Models: []ai.ModelRef{
			ai.NewModelRef("googleai/gemini-3.5-flash", nil),
		}},
	),
)

Logs that land on the trace

Every core/logger call takes a context first and carries the active span, so a line written inside a flow attaches to that run instead of scrolling past in stdout. Attributes are structured, and a status classification is just one more attribute.

genkit.DefineFlow(g, "summarize", func(ctx context.Context, doc string) (string, error) {
	logger.Info(ctx, "summarizing", "chars", len(doc))

	resp, err := genkit.Generate(ctx, g,
		ai.WithModelName("googleai/gemini-flash-latest"),
		ai.WithPrompt("Summarize: %s", doc))
	if err != nil {
		logger.Warn(ctx, "generate failed", "status", status.Of(err), "err", err)
		return "", err
	}

	logger.Debug(ctx, "summarized", "chars", len(resp.Text()))
	return resp.Text(), nil
})

Genkit logs through that same path, so the stream is full before you write a line of your own: span start and finish with state and duration, resolved generate requests, each model turn with its finish reason and token counts, tool batches, and middleware hooks with their duration and whether they short-circuited.

Console verbosity and span correlation are separate knobs. Quiet the terminal and the debug narrative still reaches the trace. Attributes bound to a context flow downstream with no extra plumbing.

// The terminal stays at warn; the trace keeps every debug record.
logger.SetLevel(slog.LevelWarn)

ctx = logger.WithContext(ctx, logger.FromContext(ctx).With("requestId", requestID))
logger.Debug(ctx, "request accepted")

Strings, ints, and bools travel natively; other values render to text. Per-span log inspection arrives in the Developer UI shortly, listing these records beside the trace they belong to.

Fill a prompt's slots from one typed input

A prompt's content functions are generic over its input type. WithSystemFn, WithMessagesFn, and WithPromptFn take func(context.Context, In) (...), so the compiler checks each one against the type WithInputType declares, whether the call arrives from Go, from the Dev UI, or over HTTP. The system and user prompt slots also take []*ai.Part, static through WithSystemParts and WithPromptParts or computed through WithSystemPartsFn and WithPromptPartsFn. WithDocsFn resolves context documents from that same input, so retrieval lives in the prompt definition instead of at each call site.

support := genkit.DefinePrompt(g, "support",
    ai.WithModelName("googleai/gemini-flash-latest"),
    ai.WithInputType(SupportRequest{Tier: "free"}),

    ai.WithSystemFn(func(ctx context.Context, in SupportRequest) (string, error) {
        if in.Tier == "enterprise" {
            return "You are a support agent. Be thorough, and offer to escalate.", nil
        }
        return "You are a support agent. Answer from the reference material.", nil
    }),

    ai.WithMessagesFn(func(ctx context.Context, in SupportRequest) ([]*ai.Message, error) {
        turns := ai.HistoryFromContext(ctx)
        if len(turns) > 6 {
            turns = turns[len(turns)-6:]
        }
        return turns, nil
    }),

    ai.WithPromptPartsFn(func(ctx context.Context, in SupportRequest) ([]*ai.Part, error) {
        parts := []*ai.Part{ai.NewTextPart(in.Question)}
        if in.Screenshot != "" {
            parts = append(parts, ai.NewMediaPart("image/png", in.Screenshot))
        }
        return parts, nil
    }),

    ai.WithDocsFn(func(ctx context.Context, in SupportRequest) ([]*ai.Document, error) {
        return retrieve(ctx, in.Area)
    }),
)

resp, err := support.Execute(ctx,
    ai.WithInput(SupportRequest{Area: "billing", Tier: "pro", Question: "Why {{two}} charges?"}),
    ai.WithMessages(history...),
)

Whatever a function returns is sent verbatim. Only WithSystem, WithPrompt, and WithMessagesTemplate compile as templates, so a customer question carrying {{#if}} reaches the model as written.

Where the conversation lands

The prompt places the messages passed to Execute, by one of three rules:

• The prompt declares no conversation: they sit between the system message and the user prompt.
• The prompt declares WithMessages or WithMessagesFn: the prompt owns them, and reads them with ai.HistoryFromContext to trim, summarize, or reorder before returning them. A prompt that carries few-shot examples this way receives the caller's history only when it asks for it.
• The prompt declares WithMessagesTemplate: they land at {{history}}, or, with no marker, just before the template's final user turn.

triage := genkit.DefineDataPrompt[SupportRequest, Triage](g, "triage",
    ai.WithModelName("googleai/gemini-flash-latest"),
    ai.WithSystem("Classify the {{area}} question from this {{tier}} customer."),
    ai.WithMessagesTemplate(`{{role "user"}}Deploys fail with a 401 after I rotated keys.
{{role "model"}}{"category": "bug", "urgency": "high"}
{{history}}`),
    ai.WithPrompt("{{question}}"),
)

ai.NewHistoryContext is the writing half of that pair, for code that drives Prompt.Render and GenerateWithRequest by hand. Scope it to the render call, never the generate call.

Documents follow a related rule: documents passed to Execute replace the prompt's own and suppress WithDocsFn, so the retriever is never called for a result that would be discarded.

Options that compose instead of collide

Passing an option twice used to fail the call with INVALID_ARGUMENT. Options merge instead, left to right, each by what it means, and applying them cannot fail.

Collections accumulate across repeats: tools, middleware, messages, documents, resources. Single-value slots take the last value set: model, config, system, prompt, output schema.

That is what makes a helper worth writing. Hand back a slice of options and let the caller build on it.

func supportOptions(tools ...ai.ToolRef) []ai.GenerateOption {
	return []ai.GenerateOption{
		ai.WithModelName("googleai/gemini-flash-latest"),
		ai.WithSystem("You are a support agent."),
		ai.WithTools(tools...),
		ai.WithMiddleware(logging),
	}
}

The caller extends what should stack and overrides what should not, without knowing which options the helper already set.

opts := append(supportOptions(searchTool),
	ai.WithTools(refundTool), // accumulates: the model sees both tools
	ai.WithMiddleware(retry), // accumulates, in call order
	ai.WithSystem("You are a support agent. Answer in one sentence."), // one slot: last wins
)

resp, err := genkit.Generate(ctx, g, append(opts, ai.WithPrompt("Where is my order?"))...)

Two of those slots are shared by four options each. WithSystem, WithSystemParts, WithSystemFn, and WithSystemPartsFn all fill the system message, so the last one set replaces the others rather than adding to them. WithPrompt, WithPromptParts, WithPromptFn, and WithPromptPartsFn work the same way on the user message. The Parts variants build those messages from multimodal parts instead of a string.

One combination is refused instead of merged. ai.WithMessagesTemplate lays out the whole conversation as a template, down to where {{history}} puts the caller's, so messages passed beside it have no position relative to it. Handing DefinePrompt both panics at the call site.

Rows arrive once in a JSONL stream

The JSONL handler hands over the rows that completed since the previous chunk, including a row that finished before its trailing newline arrived. Append every chunk and each completed row lands once, with no dedupe on the caller's side. A trailing row that is still half written is the exception: it arrives as a partial and fills in over later chunks.

for val, err := range genkit.GenerateDataStream[[]Character](ctx, g,
	ai.WithModelName("googleai/gemini-flash-latest"),
	ai.WithOutputFormat(ai.OutputFormatJSONL),
	ai.WithPrompt("Invent four characters for a story about a lighthouse keeper."),
) {
	if err != nil {
		return err
	}
	if val.Done {
		return nil
	}
	// Rows that finished since the last chunk. The trailing row, if it is
	// still half written, arrives again as it fills in.
	for _, c := range val.Chunk {
		render(c)
	}
}

Config arrives typed and already validated

Build a model, embedder, retriever, or evaluator with a constructor that carries a Config type parameter. Genkit derives the config's JSON schema from the Go type, validates every request against it, and hands your function a deserialized value. A struct from an application, a pointer to it, and JSON from the Dev UI all land as the same typed value.

type MyConfig struct {
	Temperature float32 `json:"temperature,omitempty"`
	MaxTokens   int     `json:"maxTokens,omitempty"`
}

// ResolveAction builds the model a request names, so the plugin registers
// nothing up front.
func (p *MyPlugin) ResolveAction(atype api.ActionType, id string) api.Action {
	if atype != api.ActionTypeModel {
		return nil
	}
	return p.newModel(id)
}

func (p *MyPlugin) newModel(id string) *ai.ModelAction {
	return ai.NewModelAction(api.NewName(p.Name(), id), &ai.ModelOptions{
		Label:    "My Model " + id,
		Supports: &ai.ModelSupports{Multiturn: true, Tools: true},
	}, func(ctx context.Context, req *ai.ModelRequest, cfg MyConfig, cb ai.ModelStreamCallback) (*ai.ModelResponse, error) {
		return callMyAPI(ctx, id, req, cfg, cb)
	})
}

*ai.ModelAction satisfies api.Action, so a plugin hands it back from ResolveAction, ListActions, or Init with no assertion. A request carrying a key the schema does not declare fails at the action boundary with config: Additional property bogus is not allowed, before the provider is billed. A plugin whose wire contract differs from the reflected one sets ModelOptions.ConfigSchema and keeps the typed parameter.

Applications reach the same constructors through genkit, defined and registered in one call:

genkit.DefineRetrieverAction(g, "local/menuDocs",
	&ai.RetrieverOptions{Label: "Menu Docs"},
	func(ctx context.Context, req *ai.RetrieverRequest, cfg SearchConfig) (*ai.RetrieverResponse, error) {
		return search(ctx, req.Query, cfg.K)
	})

docs, err := genkit.Retrieve(ctx, g,
	ai.WithRetrieverName("local/menuDocs"),
	ai.WithTextDocs("what soup is on today?"),
	ai.WithConfig(&SearchConfig{K: 3}))

Two audiences, two shapes. A constructor takes identity positionally, one options struct for every descriptor slot, and the implementation function last, so an optional hook lands as a field instead of a signature break. A caller composes variadic With* options. The same shape runs one level down: core.NewActionOf, NewStreamingActionOf, NewBidiActionOf, and NewBackgroundActionOf take the action type first and a single core.ActionOptions covering input, output, and stream schemas.

DefineSchemasFor registers a batch of Go types under their type names, which prompt frontmatter and generate calls then reference by name:

genkit.DefineSchemasFor(g, MenuQuestion{}, MenuAnswer{})

resp, err := genkit.Generate(ctx, g,
	ai.WithModelName("googleai/gemini-flash-latest"),
	ai.WithOutputSchemaName("MenuAnswer"),
	ai.WithPrompt("What is the soup of the day?"))

Each name belongs to one type, so run this at startup.

Seventeen samples, one standard

go/samples/basic* is seventeen programs written to one standard. Each opens with a package comment that teaches the concept, names every flow, and gives three ways to run it: go run ., genkit start -- go run . for the Developer UI, and a working curl per flow. Inputs are structs whose jsonschema tags carry a description and a default, so the Developer UI renders a pre-filled form and any flow runs from a browser.

// jsonschema tags give the Developer UI a form to pre-fill.
type JokeRequest struct {
	Topic string `json:"topic" jsonschema:"description=What the joke should be about,default=airplane food"`
}

genkit.DefineStreamingFlow(g, "streamingJokesFlow",
	func(ctx context.Context, input JokeRequest, sendChunk ai.ModelStreamCallback) (string, error) {
		resp, err := genkit.Generate(ctx, g,
			ai.WithModelName("googleai/gemini-flash-latest"),
			ai.WithPrompt("Share a joke about %s.", input.Topic),
			ai.WithStreaming(sendChunk),
		)
		if err != nil {
			return "", fmt.Errorf("could not generate joke: %w", err)
		}
		return resp.Text(), nil
	})

Where to look for what:

• basic: the two flow shapes, one returning its answer whole and one forwarding the model's chunks.
• basic-structured and basic-formats: typed output through GenerateData and GenerateDataStream, then the formats underneath it. json streams a growing value, jsonl hands over each finished row once, enum constrains the answer to one label.
• basic-prompts: every prompt defined twice, inline with DefinePrompt and as a .prompt file looked up by name, so the pair shows what moves out of code. basic-prompt-content fills all four content slots from one typed input.
• basic-media: describe a picture, edit one, generate one, and animate one through a polling background model.
• basic-tools: a multipart tool that answers with a *Rollout and an attached latency chart, which reaches the model and the Developer UI both.
• basic-tool-interrupts: human in the loop. A tool pauses a transfer for approval, and a second turn restarts it with the answer attached.
• basic-middleware: Retry wrapped around Fallback over a deliberately broken model id; Filesystem, whose four file tools are confined to RootDir by os.Root; and Skills, where the model loads a SKILL.md body on demand.
• basic-agents: six agents in six styles behind one CLI, snapshotting to disk. basic-agents-server serves agents over plain HTTP, one holding session state on the server and one handing it back to the client.
• basic-errors: classify once with status.Errorf, add context with %w, branch with errors.Is, and watch the HTTP boundary redact the one failure nobody classified.
• basic-durable-streaming-exp: drop the connection mid-run, reconnect with the stream ID, and read the buffered chunks before live ones resume.

Tools and interrupts ship twice, once against the stable API and once against the in-preview API in genkit/exp. Same rollout, same approval, so diff between the pair is the lesson.

Smaller things worth knowing

• Custom output formats resolve correctly, so a format registered with genkit.DefineFormats is found when ai.WithOutputFormat names it.
• Partial JSON completion closes structures by nesting order rather than by counting braces, so a truncated stream of an array of objects parses into a growing value.
• A blocked or truncated response reaches the caller with its finish reason intact instead of failing as a schema mismatch.
• Ollama reads each local model's capabilities from the server and caches them by digest.
• Anthropic message conversion and tool choice are corrected, and multipart tool responses map to tool_result blocks.
• Streaming through the OpenAI-compatible family returns the complete conversation from resp.History().
• A gateway whose upstream fails part-way through a stream now ends it with a classified error rather than handing back a short answer that reads as complete.
• A tool short-circuited by middleware is attributed to that tool in traces.
• Mistral serves from Vertex AI Model Garden through modelgarden.Mistral.

The documentation caught up

Every Go page on genkit.dev was read against this release rather than patched around it. Snippets compile. Deprecated helpers no longer appear as the primary way to do anything. Output formats, multipart tools, typed prompt content, and the status vocabulary are documented where a reader looks for them instead of only in godoc, and every provider in the OpenAI-compatible family has a page, including the four that never had one.

The sample suite is linked from the sections that teach each concept, so the path from reading about a feature to running it is one click.

v1.11.0: Genkit Go v1.11.0

What's Changed

• feat(go): implement telemetry label propagation via context by @​MichaelDoyle in genkit-ai#5666
• feat(go/plugins/googlegenai): add Vertex AI multi-region and apiVersion support by @​adesinah in genkit-ai#5772
• feat(go/plugins/anthropic): register latest Claude models by @​adesinah in genkit-ai#5519
• fix(go/ai): allow media URLs in prompts without a content type by @​apascal07 in genkit-ai#5793
• fix(go/googlegenai): map tool role to user for Gemini content API by @​pavelgj in genkit-ai#5782
• fix(go/plugins/ollama): register embedders by model name, not server address by @​IzaakGough in genkit-ai#5648
• fix(agents): reject empty prompt-agent turns by @​adesinah in genkit-ai#5744
• docs(go): add experimental tools example and refresh README by @​apascal07 in genkit-ai#5640

New Contributors

• @​IzaakGough made their first contribution in genkit-ai#5648

Full Changelog: genkit-ai/genkit@go/v1.10.0...go/v1.11.0

stretchr/testify (github.com/stretchr/testify)

v1.12.1

Compare Source

This is the first release which has the minimum dependencies practical in testify v1. The last remaining dependencies are github.com/stretchr/objx which itself has no dependencies, and go.yaml.in/yaml/v3. Removing objx would require v2, it cann

✂ Note

PR body was truncated to here.

---

Configuration

📅 Schedule: (UTC)

• Branch creation
  • At any time (no schedule defined)
• Automerge
  • At any time (no schedule defined)

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

👻 Immortal: This PR will be recreated if closed unmerged. Get config help if that's undesired.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[forking-renovate]

ℹ️ Artifact update notice

File name: core/go.mod

In order to perform the update(s) described in the table above, Renovate ran the go get command, which resulted in the following additional change(s):

• 28 additional dependencies were updated
• The go directive was updated for compatibility reasons

Due to Go's usage of Minimal Version Selection (MVS), these packages have been updated to the minimum version available, so will still abide by minimumReleaseAge=3

Details:

Package	Change
go	1.25.0 -> 1.26.0
cel.dev/expr	v0.25.1 -> v0.25.2
cloud.google.com/go/auth	v0.18.2 -> v0.23.2
cloud.google.com/go/iam	v1.5.3 -> v1.12.0
cloud.google.com/go/monitoring	v1.24.3 -> v1.30.0
github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp	v1.32.0 -> v1.33.0
github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric	v0.55.0 -> v0.57.0
github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping	v0.55.0 -> v0.57.0
github.com/googleapis/enterprise-certificate-proxy	v0.3.14 -> v0.3.20
github.com/googleapis/gax-go/v2	v2.18.0 -> v2.24.0
github.com/spiffe/go-spiffe/v2	v2.6.0 -> v2.7.0
go.opentelemetry.io/contrib/detectors/gcp	v1.43.0 -> v1.44.0
go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc	v0.63.0 -> v0.68.0
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp	v0.61.0 -> v0.67.0
go.opentelemetry.io/otel	v1.43.0 -> v1.44.0
go.opentelemetry.io/otel/metric	v1.43.0 -> v1.44.0
go.opentelemetry.io/otel/sdk	v1.43.0 -> v1.44.0
go.opentelemetry.io/otel/sdk/metric	v1.43.0 -> v1.44.0
go.opentelemetry.io/otel/trace	v1.43.0 -> v1.44.0
golang.org/x/crypto	v0.52.0 -> v0.55.0
golang.org/x/net	v0.55.0 -> v0.58.0
golang.org/x/sync	v0.20.0 -> v0.22.0
golang.org/x/sys	v0.45.0 -> v0.47.0
golang.org/x/text	v0.37.0 -> v0.41.0
google.golang.org/genproto	v0.0.0-20260217215200-42d3e9bedb6d -> v0.0.0-20260715232425-e75dac1f907d
google.golang.org/genproto/googleapis/api	v0.0.0-20260414002931-afd174a4e478 -> v0.0.0-20260715232425-e75dac1f907d
google.golang.org/genproto/googleapis/rpc	v0.0.0-20260414002931-afd174a4e478 -> v0.0.0-20260819154853-08b0e4226688
google.golang.org/grpc	v1.82.1 -> v1.83.2
google.golang.org/protobuf	v1.36.11 -> v1.36.12

File name: tbadk/go.mod

In order to perform the update(s) described in the table above, Renovate ran the go get command, which resulted in the following additional change(s):

• 30 additional dependencies were updated
• The go directive was updated for compatibility reasons

Due to Go's usage of Minimal Version Selection (MVS), these packages have been updated to the minimum version available, so will still abide by minimumReleaseAge=3

Details:

Package	Change
go	1.25.0 -> 1.26.6
cel.dev/expr	v0.25.1 -> v0.25.2
cloud.google.com/go/auth	v0.20.0 -> v0.23.2
cloud.google.com/go/iam	v1.5.3 -> v1.12.0
cloud.google.com/go/monitoring	v1.24.3 -> v1.30.0
github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp	v1.32.0 -> v1.35.0
github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric	v0.55.0 -> v0.57.0
github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping	v0.55.0 -> v0.57.0
github.com/go-logr/logr	v1.4.3 -> v1.4.4
github.com/google/jsonschema-go	v0.4.2 -> v0.4.3
github.com/googleapis/enterprise-certificate-proxy	v0.3.15 -> v0.3.20
github.com/googleapis/gax-go/v2	v2.22.0 -> v2.24.0
github.com/spiffe/go-spiffe/v2	v2.6.0 -> v2.7.0
go.opentelemetry.io/contrib/detectors/gcp	v1.43.0 -> v1.45.0
go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc	v0.67.0 -> v0.68.0
go.opentelemetry.io/otel	v1.43.0 -> v1.45.0
go.opentelemetry.io/otel/log	v0.19.0 -> v0.21.0
go.opentelemetry.io/otel/metric	v1.43.0 -> v1.45.0
go.opentelemetry.io/otel/sdk	v1.43.0 -> v1.45.0
go.opentelemetry.io/otel/sdk/metric	v1.43.0 -> v1.45.0
go.opentelemetry.io/otel/trace	v1.43.0 -> v1.45.0
golang.org/x/crypto	v0.52.0 -> v0.55.0
golang.org/x/net	v0.55.0 -> v0.58.0
golang.org/x/sync	v0.20.0 -> v0.22.0
golang.org/x/sys	v0.45.0 -> v0.47.0
golang.org/x/text	v0.37.0 -> v0.41.0
google.golang.org/genproto	v0.0.0-20260319201613-d00831a3d3e7 -> v0.0.0-20260715232425-e75dac1f907d
google.golang.org/genproto/googleapis/api	v0.0.0-20260427160629-7cedc36a6bc4 -> v0.0.0-20260803160001-6ac0973c030d
google.golang.org/genproto/googleapis/rpc	v0.0.0-20260511170946-3700d4141b60 -> v0.0.0-20260819154853-08b0e4226688
google.golang.org/grpc	v1.82.1 -> v1.83.2
google.golang.org/protobuf	v1.36.11 -> v1.36.12

File name: tbgenkit/go.mod

In order to perform the update(s) described in the table above, Renovate ran the go get command, which resulted in the following additional change(s):

• 31 additional dependencies were updated
• The go directive was updated for compatibility reasons

Due to Go's usage of Minimal Version Selection (MVS), these packages have been updated to the minimum version available, so will still abide by minimumReleaseAge=3

Details:

Package	Change
go	1.25.0 -> 1.26.0
cel.dev/expr	v0.25.1 -> v0.25.2
cloud.google.com/go/auth	v0.18.2 -> v0.23.2
cloud.google.com/go/iam	v1.5.3 -> v1.12.0
cloud.google.com/go/monitoring	v1.24.3 -> v1.30.0
github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp	v1.32.0 -> v1.33.0
github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric	v0.55.0 -> v0.57.0
github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping	v0.55.0 -> v0.57.0
github.com/goccy/go-yaml	v1.17.1 -> v1.19.2
github.com/google/dotprompt/go	v0.0.0-20251014011017-8d056e027254 -> v0.0.0-20260708220100-73beb993ac95
github.com/googleapis/enterprise-certificate-proxy	v0.3.14 -> v0.3.20
github.com/googleapis/gax-go/v2	v2.18.0 -> v2.24.0
github.com/invopop/jsonschema	v0.13.0 -> v0.14.0
go.opentelemetry.io/contrib/detectors/gcp	v1.43.0 -> v1.44.0
go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc	v0.63.0 -> v0.68.0
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp	v0.63.0 -> v0.67.0
go.opentelemetry.io/otel	v1.43.0 -> v1.44.0
go.opentelemetry.io/otel/metric	v1.43.0 -> v1.44.0
go.opentelemetry.io/otel/sdk	v1.43.0 -> v1.44.0
go.opentelemetry.io/otel/sdk/metric	v1.43.0 -> v1.44.0
go.opentelemetry.io/otel/trace	v1.43.0 -> v1.44.0
golang.org/x/crypto	v0.52.0 -> v0.55.0
golang.org/x/net	v0.55.0 -> v0.58.0
golang.org/x/sync	v0.20.0 -> v0.22.0
golang.org/x/sys	v0.45.0 -> v0.47.0
golang.org/x/text	v0.37.0 -> v0.41.0
golang.org/x/time	v0.15.0 -> v0.15.0
google.golang.org/genproto	v0.0.0-20260217215200-42d3e9bedb6d -> v0.0.0-20260715232425-e75dac1f907d
google.golang.org/genproto/googleapis/api	v0.0.0-20260414002931-afd174a4e478 -> v0.0.0-20260715232425-e75dac1f907d
google.golang.org/genproto/googleapis/rpc	v0.0.0-20260414002931-afd174a4e478 -> v0.0.0-20260819154853-08b0e4226688
google.golang.org/grpc	v1.82.1 -> v1.83.2
google.golang.org/protobuf	v1.36.11 -> v1.36.12

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun

[dpebot]

/gcbrun