@effect-uai/google 0.9.0 → 0.11.0

package/dist/geminiSpeechCodec.test.mjs

@@ -1,4 +1,4 @@
-import { i as it, n as globalExpect, r as describe } from "./dist-DMsg8YLb.mjs";
+import { i as it, n as globalExpect, r as describe } from "./dist-CWoAuwS9.mjs";
 import { audioSourceToInlineData, wrapPcmAsWav } from "./geminiSpeechCodec.mjs";
 import { Effect, Encoding } from "effect";
 //#region src/geminiSpeechCodec.test.ts

package/dist/geminiTools.test.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/geminiTools.test.mjs

@@ -0,0 +1,80 @@
+import { codeExecutionTool, googleSearchTool, renderProviderTools } from "./GeminiTools.mjs";
+import { WireChunk, buildRequestBody } from "./codec.mjs";
+import { i as it, n as globalExpect, r as describe } from "./dist-CWoAuwS9.mjs";
+import { Effect, Option, Result, Schema } from "effect";
+import * as Tool from "@effect-uai/core/Tool";
+import { descriptorsOf, providerToolsOf } from "@effect-uai/core/Tool";
+//#region src/geminiTools.test.ts
+const localTool = Tool.make({
+	name: "get_weather",
+	description: "Look up the weather.",
+	inputSchema: Tool.fromEffectSchema(Schema.Struct({ city: Schema.String })),
+	run: ({ city }) => Effect.succeed(`sunny in ${city}`)
+});
+const build = (toolkit) => {
+	const entries = Result.getOrThrow(renderProviderTools(providerToolsOf(toolkit)));
+	return buildRequestBody([], Option.none(), descriptorsOf(toolkit), entries);
+};
+describe("Gemini provider tools", () => {
+	it("renders google_search to the native googleSearch entry", () => {
+		globalExpect(build({ google_search: googleSearchTool }).tools).toEqual([{ googleSearch: {} }]);
+	});
+	it("renders a mixed toolkit to both a functionDeclarations entry and the native entry", () => {
+		globalExpect(build({
+			get_weather: localTool,
+			code_execution: codeExecutionTool
+		}).tools).toEqual([{ functionDeclarations: [globalExpect.objectContaining({
+			name: "get_weather",
+			description: "Look up the weather."
+		})] }, { codeExecution: {} }]);
+	});
+	it("omits toolConfig for a grounding-only request (no forced function-calling mode)", () => {
+		globalExpect(build({ google_search: googleSearchTool }).toolConfig).toBeUndefined();
+	});
+	it("sets toolConfig when a function declaration is present", () => {
+		globalExpect(build({
+			get_weather: localTool,
+			google_search: googleSearchTool
+		}).toolConfig).toEqual({ functionCallingConfig: { mode: "AUTO" } });
+	});
+	it("fails on a foreign provider tool", () => {
+		const result = renderProviderTools(providerToolsOf({ web_search: Tool.provider({
+			name: "web_search",
+			description: "Anthropic web search.",
+			inputSchema: Tool.noInput,
+			provider: "anthropic",
+			config: { type: "web_search_20250305" }
+		}) }));
+		globalExpect(Result.isFailure(result)).toBe(true);
+	});
+	it("fails on an unrecognized config kind", () => {
+		const result = renderProviderTools(providerToolsOf({ mystery: Tool.provider({
+			name: "mystery",
+			description: "Unknown Gemini tool.",
+			inputSchema: Tool.noInput,
+			provider: "gemini",
+			config: { kind: "telepathy" }
+		}) }));
+		globalExpect(Result.isFailure(result)).toBe(true);
+	});
+	it("decodes a grounded chunk without throwing (groundingMetadata is dropped)", () => {
+		globalExpect(Schema.decodeUnknownSync(WireChunk)({ candidates: [{
+			content: {
+				role: "model",
+				parts: [{ text: "Grounded answer." }]
+			},
+			groundingMetadata: {
+				webSearchQueries: ["effect ts"],
+				groundingChunks: [{ web: {
+					uri: "https://example.com",
+					title: "Example"
+				} }]
+			},
+			finishReason: "STOP"
+		}] }).candidates?.[0]?.content?.parts?.[0]).toEqual({ text: "Grounded answer." });
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=geminiTools.test.mjs.map

package/dist/geminiTools.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"geminiTools.test.mjs","names":["expect"],"sources":["../src/geminiTools.test.ts"],"sourcesContent":["import { Effect, Option, Result, Schema } from \"effect\"\nimport * as Tool from \"@effect-uai/core/Tool\"\nimport { descriptorsOf, providerToolsOf } from \"@effect-uai/core/Tool\"\nimport { describe, expect, it } from \"vitest\"\nimport { WireChunk, buildRequestBody } from \"./codec.js\"\nimport { codeExecutionTool, googleSearchTool, renderProviderTools } from \"./GeminiTools.js\"\n\nconst localTool = Tool.make({\n  name: \"get_weather\",\n  description: \"Look up the weather.\",\n  inputSchema: Tool.fromEffectSchema(Schema.Struct({ city: Schema.String })),\n  run: ({ city }) => Effect.succeed(`sunny in ${city}`),\n})\n\nconst build = (toolkit: Record<string, Tool.AnyTool>) => {\n  const entries = Result.getOrThrow(renderProviderTools(providerToolsOf(toolkit)))\n  return buildRequestBody([], Option.none(), descriptorsOf(toolkit), entries)\n}\n\ndescribe(\"Gemini provider tools\", () => {\n  it(\"renders google_search to the native googleSearch entry\", () => {\n    const body = build({ google_search: googleSearchTool })\n    expect(body.tools).toEqual([{ googleSearch: {} }])\n  })\n\n  it(\"renders a mixed toolkit to both a functionDeclarations entry and the native entry\", () => {\n    const body = build({ get_weather: localTool, code_execution: codeExecutionTool })\n    expect(body.tools).toEqual([\n      {\n        functionDeclarations: [\n          expect.objectContaining({ name: \"get_weather\", description: \"Look up the weather.\" }),\n        ],\n      },\n      { codeExecution: {} },\n    ])\n  })\n\n  it(\"omits toolConfig for a grounding-only request (no forced function-calling mode)\", () => {\n    const body = build({ google_search: googleSearchTool })\n    expect(body.toolConfig).toBeUndefined()\n  })\n\n  it(\"sets toolConfig when a function declaration is present\", () => {\n    const body = build({ get_weather: localTool, google_search: googleSearchTool })\n    expect(body.toolConfig).toEqual({ functionCallingConfig: { mode: \"AUTO\" } })\n  })\n\n  it(\"fails on a foreign provider tool\", () => {\n    const foreign = Tool.provider({\n      name: \"web_search\",\n      description: \"Anthropic web search.\",\n      inputSchema: Tool.noInput,\n      provider: \"anthropic\",\n      config: { type: \"web_search_20250305\" },\n    })\n    const result = renderProviderTools(providerToolsOf({ web_search: foreign }))\n    expect(Result.isFailure(result)).toBe(true)\n  })\n\n  it(\"fails on an unrecognized config kind\", () => {\n    const bogus = Tool.provider({\n      name: \"mystery\",\n      description: \"Unknown Gemini tool.\",\n      inputSchema: Tool.noInput,\n      provider: \"gemini\",\n      config: { kind: \"telepathy\" },\n    })\n    const result = renderProviderTools(providerToolsOf({ mystery: bogus }))\n    expect(Result.isFailure(result)).toBe(true)\n  })\n\n  it(\"decodes a grounded chunk without throwing (groundingMetadata is dropped)\", () => {\n    const grounded = {\n      candidates: [\n        {\n          content: { role: \"model\", parts: [{ text: \"Grounded answer.\" }] },\n          groundingMetadata: {\n            webSearchQueries: [\"effect ts\"],\n            groundingChunks: [{ web: { uri: \"https://example.com\", title: \"Example\" } }],\n          },\n          finishReason: \"STOP\",\n        },\n      ],\n    }\n    const chunk = Schema.decodeUnknownSync(WireChunk)(grounded)\n    expect(chunk.candidates?.[0]?.content?.parts?.[0]).toEqual({ text: \"Grounded answer.\" })\n  })\n})\n"],"mappings":";;;;;;;AAOA,MAAM,YAAY,KAAK,KAAK;CAC1B,MAAM;CACN,aAAa;CACb,aAAa,KAAK,iBAAiB,OAAO,OAAO,EAAE,MAAM,OAAO,QAAQ,CAAC,CAAC;CAC1E,MAAM,EAAE,WAAW,OAAO,QAAQ,YAAY,OAAO;CACtD,CAAC;AAEF,MAAM,SAAS,YAA0C;CACvD,MAAM,UAAU,OAAO,WAAW,oBAAoB,gBAAgB,QAAQ,CAAC,CAAC;AAChF,QAAO,iBAAiB,EAAE,EAAE,OAAO,MAAM,EAAE,cAAc,QAAQ,EAAE,QAAQ;;AAG7E,SAAS,+BAA+B;AACtC,IAAG,gEAAgE;AAEjE,eADa,MAAM,EAAE,eAAe,kBAAkB,CAC3C,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,cAAc,EAAE,EAAE,CAAC,CAAC;GAClD;AAEF,IAAG,2FAA2F;AAE5F,eADa,MAAM;GAAE,aAAa;GAAW,gBAAgB;GAAmB,CACrE,CAAC,MAAM,CAAC,QAAQ,CACzB,EACE,sBAAsB,CACpBA,aAAO,iBAAiB;GAAE,MAAM;GAAe,aAAa;GAAwB,CAAC,CACtF,EACF,EACD,EAAE,eAAe,EAAE,EAAE,CACtB,CAAC;GACF;AAEF,IAAG,yFAAyF;AAE1F,eADa,MAAM,EAAE,eAAe,kBAAkB,CAC3C,CAAC,WAAW,CAAC,eAAe;GACvC;AAEF,IAAG,gEAAgE;AAEjE,eADa,MAAM;GAAE,aAAa;GAAW,eAAe;GAAkB,CACnE,CAAC,WAAW,CAAC,QAAQ,EAAE,uBAAuB,EAAE,MAAM,QAAQ,EAAE,CAAC;GAC5E;AAEF,IAAG,0CAA0C;EAQ3C,MAAM,SAAS,oBAAoB,gBAAgB,EAAE,YAPrC,KAAK,SAAS;GAC5B,MAAM;GACN,aAAa;GACb,aAAa,KAAK;GAClB,UAAU;GACV,QAAQ,EAAE,MAAM,uBAAuB;GACxC,CACuE,EAAE,CAAC,CAAC;AAC5E,eAAO,OAAO,UAAU,OAAO,CAAC,CAAC,KAAK,KAAK;GAC3C;AAEF,IAAG,8CAA8C;EAQ/C,MAAM,SAAS,oBAAoB,gBAAgB,EAAE,SAPvC,KAAK,SAAS;GAC1B,MAAM;GACN,aAAa;GACb,aAAa,KAAK;GAClB,UAAU;GACV,QAAQ,EAAE,MAAM,aAAa;GAC9B,CACkE,EAAE,CAAC,CAAC;AACvE,eAAO,OAAO,UAAU,OAAO,CAAC,CAAC,KAAK,KAAK;GAC3C;AAEF,IAAG,kFAAkF;AAcnF,eADc,OAAO,kBAAkB,UAAU,CAAC,EAXhD,YAAY,CACV;GACE,SAAS;IAAE,MAAM;IAAS,OAAO,CAAC,EAAE,MAAM,oBAAoB,CAAC;IAAE;GACjE,mBAAmB;IACjB,kBAAkB,CAAC,YAAY;IAC/B,iBAAiB,CAAC,EAAE,KAAK;KAAE,KAAK;KAAuB,OAAO;KAAW,EAAE,CAAC;IAC7E;GACD,cAAc;GACf,CACF,EAEuD,CAC9C,CAAC,aAAa,IAAI,SAAS,QAAQ,GAAG,CAAC,QAAQ,EAAE,MAAM,oBAAoB,CAAC;GACxF;EACF"}

package/dist/index.d.mts

@@ -1,7 +1,9 @@
 import { t as codec_d_exports } from "./codec.mjs";
-import { GeminiTtsModel, GeminiVoiceName, GoogleEmbeddingModel, GoogleModel, LyriaModel } from "./models.mjs";
+import { t as GeminiTools_d_exports } from "./GeminiTools.mjs";
+import { GeminiTtsModel, GeminiVoiceName, GoogleDeepResearchModel, GoogleEmbeddingModel, GoogleModel, LyriaModel } from "./models.mjs";
 import { t as Gemini_d_exports } from "./Gemini.mjs";
 import { t as GeminiEmbedding_d_exports } from "./GeminiEmbedding.mjs";
 import { t as GeminiSynthesizer_d_exports } from "./GeminiSynthesizer.mjs";
+import { t as GoogleDeepResearch_d_exports } from "./GoogleDeepResearch.mjs";
 import { t as LyriaGenerator_d_exports } from "./LyriaGenerator.mjs";
-export { Gemini_d_exports as Gemini, GeminiEmbedding_d_exports as GeminiEmbedding, GeminiSynthesizer_d_exports as GeminiSynthesizer, GeminiTtsModel, GeminiVoiceName, GoogleEmbeddingModel, GoogleModel, LyriaGenerator_d_exports as LyriaGenerator, LyriaModel, codec_d_exports as codec };
+export { Gemini_d_exports as Gemini, GeminiEmbedding_d_exports as GeminiEmbedding, GeminiSynthesizer_d_exports as GeminiSynthesizer, GeminiTools_d_exports as GeminiTools, GeminiTtsModel, GeminiVoiceName, GoogleDeepResearch_d_exports as GoogleDeepResearch, GoogleDeepResearchModel, GoogleEmbeddingModel, GoogleModel, LyriaGenerator_d_exports as LyriaGenerator, LyriaModel, codec_d_exports as codec };

package/dist/index.mjs

@@ -1,7 +1,9 @@
+import { t as GeminiTools_exports } from "./GeminiTools.mjs";
 import { t as codec_exports } from "./codec.mjs";
 import { t as Gemini_exports } from "./Gemini.mjs";
 import { t as GeminiEmbedding_exports } from "./GeminiEmbedding.mjs";
 import { t as GeminiSynthesizer_exports } from "./GeminiSynthesizer.mjs";
+import { t as GoogleDeepResearch_exports } from "./GoogleDeepResearch.mjs";
 import { t as LyriaGenerator_exports } from "./LyriaGenerator.mjs";
 import "./models.mjs";
-export { Gemini_exports as Gemini, GeminiEmbedding_exports as GeminiEmbedding, GeminiSynthesizer_exports as GeminiSynthesizer, LyriaGenerator_exports as LyriaGenerator, codec_exports as codec };
+export { Gemini_exports as Gemini, GeminiEmbedding_exports as GeminiEmbedding, GeminiSynthesizer_exports as GeminiSynthesizer, GeminiTools_exports as GeminiTools, GoogleDeepResearch_exports as GoogleDeepResearch, LyriaGenerator_exports as LyriaGenerator, codec_exports as codec };

package/dist/models.d.mts

@@ -7,6 +7,16 @@
  * Reference: https://ai.google.dev/gemini-api/docs/models
  */
 type GoogleModel = "gemini-3.1-pro-preview" | "gemini-3-flash-preview" | "gemini-3.1-flash-lite-preview" | "gemini-3.1-flash-live-preview" | "gemini-3.1-flash-tts-preview" | "gemini-2.5-pro" | "gemini-2.5-flash" | "gemini-2.5-flash-lite" | (string & {});
+/**
+ * Deep-research agent identifiers for the Interactions API (`POST
+ * /v1beta/interactions`). `-preview` is the fast tier, `-max-` the
+ * comprehensive one. Preview surface: verify against live docs before relying on
+ * exact ids. The `(string & {})` tail accepts any string so a renamed agent
+ * works without an SDK update.
+ *
+ * Reference: https://ai.google.dev/gemini-api/docs/interactions/deep-research
+ */
+type GoogleDeepResearchModel = "deep-research-preview-04-2026" | "deep-research-max-preview-04-2026" | (string & {});
 /**
  * Known Gemini embedding model identifiers.
  *
@@ -48,5 +58,5 @@ type GeminiVoiceName = "Zephyr" | "Puck" | "Charon" | "Kore" | "Fenrir" | "Leda"
 type LyriaModel = "lyria-3-clip-preview" | "lyria-3-pro-preview" | (string & {});
 type GoogleEmbeddingModel = "gemini-embedding-2" | "gemini-embedding-001" | (string & {});
 //#endregion
-export { GeminiTtsModel, GeminiVoiceName, GoogleEmbeddingModel, GoogleModel, LyriaModel };
+export { GeminiTtsModel, GeminiVoiceName, GoogleDeepResearchModel, GoogleEmbeddingModel, GoogleModel, LyriaModel };
 //# sourceMappingURL=models.d.mts.map

package/dist/models.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"models.d.mts","names":[],"sources":["../src/models.ts"],"mappings":";;AAOA;;;;;AAgCA;KAhCY,WAAA;;;;AA8CZ;;;;;AAyCA;;;;;AAMA;;;;;;;KA7DY,cAAA;;;;;;;;KAcA,eAAA;;;;;;;;;;KAyCA,UAAA;AAAA,KAMA,oBAAA"}
+{"version":3,"file":"models.d.mts","names":[],"sources":["../src/models.ts"],"mappings":";;AAOA;;;;;AAqBA;KArBY,WAAA;;;;AA+CZ;;;;;AAcA;KAxCY,uBAAA;;;;AAiFZ;;;;;AAMA;;;;;;;;;;;;KA7DY,cAAA;;;;;;;;KAcA,eAAA;;;;;;;;;;KAyCA,UAAA;AAAA,KAMA,oBAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/google",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Google Gemini provider for @effect-uai/core.",
   "keywords": [
     "ai",
@@ -46,6 +46,10 @@
       "types": "./dist/GeminiSynthesizer.d.mts",
       "import": "./dist/GeminiSynthesizer.mjs"
     },
+    "./GoogleDeepResearch": {
+      "types": "./dist/GoogleDeepResearch.d.mts",
+      "import": "./dist/GoogleDeepResearch.mjs"
+    },
     "./LyriaGenerator": {
       "types": "./dist/LyriaGenerator.d.mts",
       "import": "./dist/LyriaGenerator.mjs"
@@ -55,13 +59,13 @@
     "access": "public"
   },
   "devDependencies": {
-    "effect": "4.0.0-beta.57",
+    "effect": "4.0.0-beta.94",
     "typescript": "^6.0.3",
-    "@effect-uai/core": "0.9.0"
+    "@effect-uai/core": "0.11.0"
   },
   "peerDependencies": {
     "@effect-uai/core": ">=0.2.0 <1",
-    "effect": "4.0.0-beta.57"
+    "effect": ">=4.0.0-beta.94 <5.0.0"
   },
   "scripts": {
     "build": "tsdown",

package/src/Gemini.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, Layer, Option, Redacted, Schema, Stream } from "effect"
+import { Context, Effect, Layer, Option, Redacted, Result, Schema, Stream } from "effect"
 import { HttpClient, HttpClientRequest } from "effect/unstable/http"
 import * as AiError from "@effect-uai/core/AiError"
 import {
@@ -9,8 +9,11 @@ import {
 } from "@effect-uai/core/LanguageModel"
 import { JsonParseError } from "@effect-uai/core/JSONL"
 import * as SSE from "@effect-uai/core/SSE"
-import { descriptorsOf } from "@effect-uai/core/Tool"
+import { descriptorsOf, providerToolsOf } from "@effect-uai/core/Tool"
 import { type Turn, TurnEvent } from "@effect-uai/core/Turn"
+import { renderProviderTools } from "./GeminiTools.js"
+
+export { codeExecutionTool, googleSearchTool, urlContextTool } from "./GeminiTools.js"
 import {
   type ChunkPart,
   type GenerationConfig,
@@ -174,10 +177,25 @@ const buildNativeStream = (cfg: Config) => {
         }
         const url = `${baseUrl}/models/${request.model}:streamGenerateContent?alt=sse`
         const generationConfig = buildGenerationConfig(request)
+        const providerToolEntries = yield* Result.match(
+          renderProviderTools(providerToolsOf(request.tools)),
+          {
+            onFailure: (e) =>
+              Effect.fail(
+                new AiError.Unsupported({
+                  provider: "gemini",
+                  capability: e.capability,
+                  reason: e.reason,
+                }),
+              ),
+            onSuccess: (entries) => Effect.succeed(entries),
+          },
+        )
         const body = buildRequestBody(
           request.history,
           generationConfig,
           descriptorsOf(request.tools),
+          providerToolEntries,
           request.toolChoice,
         )
         const httpRequest = HttpClientRequest.post(url).pipe(
@@ -287,7 +305,7 @@ export const toCanonical = <E, R>(
  * Build a `GeminiService` value. For Layer-based setup, prefer `layer`.
  */
 export const make = (cfg: Config): Effect.Effect<GeminiService, never, HttpClient.HttpClient> =>
-  Effect.map(HttpClient.HttpClient.asEffect(), (client) => {
+  Effect.map(HttpClient.HttpClient, (client) => {
     const streamNative: GeminiService["streamNative"] = (request) =>
       buildNativeStream(cfg)(request).pipe(Stream.provideService(HttpClient.HttpClient, client))
     const streamTurn: GeminiService["streamTurn"] = (request) => toCanonical(streamNative(request))

package/src/GeminiEmbedding.ts

@@ -328,7 +328,7 @@ const embedManyImpl =
 export const make = (
   cfg: Config,
 ): Effect.Effect<GeminiEmbeddingService, never, HttpClient.HttpClient> =>
-  Effect.map(HttpClient.HttpClient.asEffect(), (client) => ({
+  Effect.map(HttpClient.HttpClient, (client) => ({
     embed: (request) =>
       embedImpl(cfg)(request).pipe(Effect.provideService(HttpClient.HttpClient, client)),
     embedMany: (request) =>

package/src/GeminiSynthesizer.ts

@@ -150,7 +150,9 @@ const synthesizeImpl = (cfg: Config) => (request: GeminiSynthesizeRequest) =>
       reason: "Gemini `:generateContent` TTS has no language parameter.",
     })
     const client = yield* HttpClient.HttpClient
-    const [format, wrap] = yield* realizeOutput(request.outputFormat?.container ?? "raw")
+    const [format, wrap] = yield* Effect.fromResult(
+      realizeOutput(request.outputFormat?.container ?? "raw"),
+    )
     const httpRequest = HttpClientRequest.post(
       `${baseUrl(cfg)}/models/${request.model}:generateContent`,
     ).pipe(
@@ -221,7 +223,7 @@ const unsupportedStreamDialogue: SpeechSynthesizerService["streamSynthesizeDialo
 
 export const make = (cfg: Config) =>
   Effect.map(
-    HttpClient.HttpClient.asEffect(),
+    HttpClient.HttpClient,
     (client): GeminiSynthesizerService => ({
       synthesize: (r) =>
         synthesizeImpl(cfg)(r).pipe(Effect.provideService(HttpClient.HttpClient, client)),

package/src/GeminiTools.ts

@@ -0,0 +1,95 @@
+import { Match, Result, Schema } from "effect"
+import * as Tool from "@effect-uai/core/Tool"
+import type { RequestTool } from "./codec.js"
+
+// ---------------------------------------------------------------------------
+// Gemini provider-hosted tools. Each is a `Tool.provider` whose `config`
+// carries the discriminant the renderer maps to a native `tools[]` entry
+// (`googleSearch`, `urlContext`, `codeExecution`). The `inputSchema` is never
+// sent — provider tools are partitioned out of the function declarations — so
+// `Tool.noInput` suffices.
+// Reference: https://ai.google.dev/api/caching#Tool
+// ---------------------------------------------------------------------------
+
+/** Discriminated config for a Gemini hosted tool. */
+export const GeminiToolConfig = Schema.Union([
+  Schema.Struct({ kind: Schema.Literal("google_search") }),
+  Schema.Struct({ kind: Schema.Literal("url_context") }),
+  Schema.Struct({ kind: Schema.Literal("code_execution") }),
+])
+export type GeminiToolConfig = typeof GeminiToolConfig.Type
+
+/** Google Search grounding, executed by Gemini. */
+export const googleSearchTool = Tool.provider({
+  name: "google_search",
+  description: "Ground the answer with Google Search, executed by Gemini.",
+  inputSchema: Tool.noInput,
+  provider: "gemini",
+  config: { kind: "google_search" } as const,
+})
+
+/** URL context: Gemini fetches and reads URLs referenced in the prompt. */
+export const urlContextTool = Tool.provider({
+  name: "url_context",
+  description: "Let Gemini fetch and read URLs referenced in the prompt.",
+  inputSchema: Tool.noInput,
+  provider: "gemini",
+  config: { kind: "url_context" } as const,
+})
+
+/** Code execution: Gemini runs generated Python in a sandbox. */
+export const codeExecutionTool = Tool.provider({
+  name: "code_execution",
+  description: "Let Gemini write and run Python in a sandbox.",
+  inputSchema: Tool.noInput,
+  provider: "gemini",
+  config: { kind: "code_execution" } as const,
+})
+
+/**
+ * A provider tool this adapter cannot render — a foreign `provider` or an
+ * unrecognized `config`. Carried as data so `Gemini.ts` can lift it into a
+ * typed `AiError.Unsupported`, mirroring how `hasUrlImageSource` surfaces a
+ * request-shaping failure.
+ */
+export type ToolRenderError = {
+  readonly capability: string
+  readonly reason: string
+}
+
+const decodeConfig = Schema.decodeUnknownResult(GeminiToolConfig)
+
+const configToWire = Match.type<GeminiToolConfig>().pipe(
+  Match.discriminatorsExhaustive("kind")({
+    google_search: (): RequestTool => ({ googleSearch: {} }),
+    url_context: (): RequestTool => ({ urlContext: {} }),
+    code_execution: (): RequestTool => ({ codeExecution: {} }),
+  }),
+)
+
+const renderOne = (
+  tool: Tool.ProviderTool<string, any, string, any>,
+): Result.Result<RequestTool, ToolRenderError> =>
+  tool.provider !== "gemini"
+    ? Result.fail({
+        capability: `providerTool:${tool.provider}`,
+        reason: `tool "${tool.name}" is hosted by "${tool.provider}", not gemini`,
+      })
+    : decodeConfig(tool.config).pipe(
+        Result.map(configToWire),
+        Result.mapError(
+          (): ToolRenderError => ({
+            capability: "providerTool",
+            reason: `unrecognized Gemini provider tool config on "${tool.name}"`,
+          }),
+        ),
+      )
+
+/**
+ * Render a toolkit's Gemini provider tools to native `tools[]` entries. Fails
+ * with a `ToolRenderError` on the first foreign or unrecognized tool rather
+ * than dropping it.
+ */
+export const renderProviderTools = (
+  tools: ReadonlyArray<Tool.ProviderTool<string, any, string, any>>,
+): Result.Result<ReadonlyArray<RequestTool>, ToolRenderError> => Result.all(tools.map(renderOne))