@effect-uai/google 0.17.0 → 0.19.0-dev-20261109183959

package/src/GeminiEmbedding.ts

@@ -1,5 +1,6 @@
-import { Context, Effect, Encoding, Layer, Match, Redacted, Schema } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { Context, Effect, Layer, Match, Redacted, Schema } from "effect"
+import { Base64 } from "effect/encoding"
+import { HttpClient, HttpClientRequest } from "effect/http"
 import * as AiError from "@effect-uai/core/AiError"
 import type {
   EmbedContentPart,
@@ -126,7 +127,7 @@ const imageSourceToPart = (param: string) =>
     ),
     Match.tag("bytes", (s): Effect.Effect<WirePart, AiError.AiError> =>
       Effect.succeed({
-        inlineData: { mimeType: s.mimeType, data: Encoding.encodeBase64(s.bytes) },
+        inlineData: { mimeType: s.mimeType, data: Base64.encode(s.bytes) },
       }),
     ),
     Match.tag("url", (): Effect.Effect<WirePart, AiError.AiError> =>

package/src/GeminiImageGenerator.ts

@@ -1,5 +1,6 @@
-import { Context, Effect, Encoding, Layer, Match, Redacted, Schema, Stream } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { Context, Effect, Layer, Match, Redacted, Schema, Stream } from "effect"
+import { Base64 } from "effect/encoding"
+import { HttpClient, HttpClientRequest } from "effect/http"
 import * as AiError from "@effect-uai/core/AiError"
 import * as Capabilities from "@effect-uai/core/Capabilities"
 import type {
@@ -129,7 +130,7 @@ const referencePart: (image: ImageSource) => Effect.Effect<RequestPart, AiError.
     ),
     Match.tag("bytes", (i) =>
       Effect.succeed<RequestPart>({
-        inlineData: { mimeType: i.mimeType, data: Encoding.encodeBase64(i.bytes) },
+        inlineData: { mimeType: i.mimeType, data: Base64.encode(i.bytes) },
       }),
     ),
     Match.tag("url", () => Effect.fail(urlRefNotSupported)),

package/src/GeminiSynthesizer.ts

@@ -1,5 +1,5 @@
 import { Context, Effect, Layer, Match, Redacted, Result, Schema, Stream } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { HttpClient, HttpClientRequest } from "effect/http"
 import * as AiError from "@effect-uai/core/AiError"
 import type { AudioBlob, AudioChunk, AudioFormat } from "@effect-uai/core/Audio"
 import * as Capabilities from "@effect-uai/core/Capabilities"

package/src/GoogleDeepResearch.ts

@@ -12,7 +12,7 @@ import {
   Stream,
   pipe,
 } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { HttpClient, HttpClientRequest } from "effect/http"
 import * as AiError from "@effect-uai/core/AiError"
 import type { Source } from "@effect-uai/core/Citation"
 import {

package/src/LyriaGenerator.test.ts

@@ -1,5 +1,5 @@
 import { Duration, Effect, Layer, Redacted, Stream } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
+import { FetchHttpClient } from "effect/http"
 import { describe, expect, expectTypeOf, it } from "vitest"
 import type * as AiError from "@effect-uai/core/AiError"
 import type { GenerateResult } from "@effect-uai/core/Music"

package/src/LyriaGenerator.ts

@@ -1,16 +1,6 @@
-import {
-  Context,
-  Duration,
-  Effect,
-  Encoding,
-  Layer,
-  Match,
-  Redacted,
-  Result,
-  Schema,
-  Stream,
-} from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { Context, Duration, Effect, Layer, Match, Redacted, Result, Schema, Stream } from "effect"
+import { Base64 } from "effect/encoding"
+import { HttpClient, HttpClientRequest } from "effect/http"
 import * as AiError from "@effect-uai/core/AiError"
 import type { AudioChunk, AudioFormat } from "@effect-uai/core/Audio"
 import { warnDroppedWhen } from "@effect-uai/core/Capabilities"
@@ -207,7 +197,7 @@ const transportFailure = sharedTransportFailure("lyria")
 const httpStatusError = sharedHttpStatusError("lyria")
 
 const decodeBase64ToBytes = (b64: string): Effect.Effect<Uint8Array, AiError.AiError> =>
-  Result.match(Encoding.decodeBase64(b64), {
+  Result.match(Base64.decode(b64), {
     onSuccess: Effect.succeed,
     onFailure: (cause) =>
       Effect.fail(new AiError.InvalidRequest({ provider: "lyria", param: "audio", raw: cause })),

package/src/codec.test.ts

@@ -0,0 +1,54 @@
+import { fileUrl } from "@effect-uai/core/File"
+import { imageBytes } from "@effect-uai/core/Image"
+import * as Items from "@effect-uai/core/Items"
+import { describe, expect, it } from "vitest"
+import { functionResponseBody } from "./codec.js"
+
+const body = (output: Items.ToolCallOutput["output"], isError?: boolean) =>
+  functionResponseBody({
+    type: "function_call_output",
+    call_id: "c1",
+    output,
+    ...(isError !== undefined && { isError }),
+  })
+
+describe("functionResponseBody", () => {
+  it("puts one JSON value under output as an object, never a string", () => {
+    expect(body([Items.json({ city: "Lisbon", temp: 18 })])).toEqual({
+      response: { output: { city: "Lisbon", temp: 18 } },
+    })
+  })
+
+  it("puts a failure under error", () => {
+    expect(body([Items.json({ _tag: "CityNotFound", city: "Atlantis" })], true)).toEqual({
+      response: { error: { _tag: "CityNotFound", city: "Atlantis" } },
+    })
+  })
+
+  it("keeps several values as an array and moves media to parts", () => {
+    expect(
+      body([
+        Items.text("Home"),
+        Items.json({ hits: 2 }),
+        Items.image(imageBytes(new Uint8Array([1, 2, 3]), "image/png")),
+        Items.file(fileUrl("gs://bucket/a.pdf", "application/pdf"), "a.pdf"),
+      ]),
+    ).toEqual({
+      response: { output: ["Home", { hits: 2 }] },
+      parts: [
+        { inlineData: { mimeType: "image/png", data: "AQID" } },
+        {
+          fileData: {
+            fileUri: "gs://bucket/a.pdf",
+            mimeType: "application/pdf",
+            displayName: "a.pdf",
+          },
+        },
+      ],
+    })
+  })
+
+  it("sends an empty response for media-only output", () => {
+    expect(body([Items.image(imageBytes(new Uint8Array([1]), "image/png"))]).response).toEqual({})
+  })
+})

package/src/codec.ts

@@ -1,10 +1,14 @@
-import { Array as Arr, Encoding, Match, Option, Result, Schema, pipe } from "effect"
+import { Array as Arr, Match, Option, Result, Schema, pipe } from "effect"
+import { Base64 } from "effect/encoding"
 import * as AiError from "@effect-uai/core/AiError"
 import type { ImageSource } from "@effect-uai/core/Image"
 import { imageBase64 } from "@effect-uai/core/Image"
+import type { FileSource } from "@effect-uai/core/File"
 import type {
   ContentBlock,
   ToolCall,
+  ToolCallOutput,
+  ToolOutputContent,
   InputImage,
   HistoryItem,
   Message,
@@ -152,10 +156,9 @@ type RequestPart =
       readonly thoughtSignature?: string
     }
   | {
-      readonly functionResponse: {
+      readonly functionResponse: FunctionResponseBody & {
         readonly id?: string
         readonly name: string
-        readonly response: Record<string, unknown>
       }
     }
 
@@ -249,7 +252,7 @@ const imageSourceToParts = Match.type<InputImage["source"]>().pipe(
     { inlineData: { mimeType: s.mimeType, data: s.base64 } },
   ]),
   Match.tag("bytes", (s): ReadonlyArray<RequestPart> => [
-    { inlineData: { mimeType: s.mimeType, data: Encoding.encodeBase64(s.bytes) } },
+    { inlineData: { mimeType: s.mimeType, data: Base64.encode(s.bytes) } },
   ]),
   Match.exhaustive,
 )
@@ -294,31 +297,98 @@ const allMessages = (history: ReadonlyArray<HistoryItem>): ReadonlyArray<Message
 // ---------------------------------------------------------------------------
 // Function-call round-trip
 //
-// `ToolCall.arguments` and `ToolCallOutput.output` are JSON-encoded
-// strings; Gemini's `functionCall.args` and `functionResponse.response`
-// expect parsed JSON *objects*. Decode via Schema:
-//   - object payload → use as-is
-//   - scalar / array / malformed → wrap as `{ output: <raw string> }` so the
-//     model still sees *some* response without crashing the request.
+// `ToolCall.arguments` is a JSON string; Gemini's `functionCall.args` wants
+// an object (malformed or non-object arguments become `{}`).
 // ---------------------------------------------------------------------------
 
 const JsonObject = Schema.Record(Schema.String, Schema.Unknown)
 const decodeJsonObject = Schema.decodeResult(Schema.fromJsonString(JsonObject))
 
-const parsedJsonObject =
-  (fallback: (raw: string) => Record<string, unknown>) =>
-  (encoded: string): Record<string, unknown> =>
-    pipe(
-      decodeJsonObject(encoded),
-      Result.match({
-        onSuccess: (v) => v,
-        onFailure: () => fallback(encoded),
+const parsedArgs = (encoded: string): Record<string, unknown> =>
+  pipe(
+    decodeJsonObject(encoded),
+    Result.getOrElse(() => ({})),
+  )
+
+type MediaPart =
+  | {
+      readonly inlineData: {
+        readonly mimeType: string
+        readonly data: string
+        readonly displayName?: string
+      }
+    }
+  | {
+      readonly fileData: {
+        readonly fileUri: string
+        readonly mimeType?: string
+        readonly displayName?: string
+      }
+    }
+
+const mediaPart = (
+  source: ImageSource | FileSource,
+  displayName: string | undefined,
+): MediaPart => {
+  const named = displayName === undefined ? {} : { displayName }
+  return Match.value(source).pipe(
+    Match.tagsExhaustive({
+      url: (s) => ({
+        fileData: {
+          fileUri: s.url,
+          ...(s.mimeType !== undefined && { mimeType: s.mimeType }),
+          ...named,
+        },
       }),
-    )
+      base64: (s) => ({ inlineData: { mimeType: s.mimeType, data: s.base64, ...named } }),
+      bytes: (s) => ({
+        inlineData: { mimeType: s.mimeType, data: Base64.encode(s.bytes), ...named },
+      }),
+    }),
+  )
+}
+
+/** Gemini's `functionResponse` body for a tool output, without `id` / `name`. */
+export type FunctionResponseBody = {
+  readonly response: Record<string, unknown>
+  readonly parts?: ReadonlyArray<MediaPart>
+}
 
-const parsedArgs = parsedJsonObject(() => ({}))
-/** A `ToolCallOutput.output` string as the object `functionResponse` wants. */
-export const parsedResponse = parsedJsonObject((raw) => ({ output: raw }))
+/**
+ * Text and JSON go into `response.output` (or `response.error` when the call
+ * failed) as values, never stringified: one value as itself, several as an
+ * array. Media goes into `parts`.
+ */
+export const functionResponseBody = (output: ToolCallOutput): FunctionResponseBody => {
+  const values = Arr.filterMap(
+    output.output,
+    Match.type<ToolOutputContent>().pipe(
+      Match.discriminatorsExhaustive("type")({
+        input_text: (p) => Result.succeed<unknown>(p.text),
+        input_json: (p) => Result.succeed<unknown>(p.value),
+        input_image: () => Result.failVoid,
+        input_file: () => Result.failVoid,
+      }),
+    ),
+  )
+  const media = Arr.filterMap(
+    output.output,
+    Match.type<ToolOutputContent>().pipe(
+      Match.discriminatorsExhaustive("type")({
+        input_text: () => Result.failVoid,
+        input_json: () => Result.failVoid,
+        input_image: (p) => Result.succeed(mediaPart(p.source, undefined)),
+        input_file: (p) => Result.succeed(mediaPart(p.source, p.filename)),
+      }),
+    ),
+  )
+  const key = output.isError === true ? "error" : "output"
+  const response = Arr.match(values, {
+    onEmpty: () => ({}),
+    onNonEmpty: (all) => ({ [key]: all.length === 1 ? Arr.headNonEmpty(all) : all }),
+  })
+  return media.length === 0 ? { response } : { response, parts: media }
+}
 
 /**
  * `ToolCallOutput` only carries `call_id`; Gemini's `functionResponse`
@@ -422,7 +492,7 @@ const itemToContent =
                     onNone: () => ({}),
                   }),
                   name: Option.getOrElse(nameForCallId(history, o.call_id), () => o.call_id),
-                  response: parsedResponse(o.output),
+                  ...functionResponseBody(o),
                 },
               },
             ],

package/src/geminiSpeechCodec.test.ts

@@ -1,4 +1,5 @@
-import { Effect, Encoding } from "effect"
+import { Effect } from "effect"
+import { Base64 } from "effect/encoding"
 import { describe, expect, it } from "vitest"
 import type { AudioSource } from "@effect-uai/core/Audio"
 import { audioSourceToInlineData, wrapPcmAsWav } from "./geminiSpeechCodec.js"
@@ -9,11 +10,11 @@ describe("audioSourceToInlineData", () => {
     const source: AudioSource = { _tag: "bytes", bytes: original, mimeType: "audio/wav" }
     const inline = await Effect.runPromise(audioSourceToInlineData(source))
     expect(inline.mimeType).toBe("audio/wav")
-    expect(inline.data).toBe(Encoding.encodeBase64(original))
+    expect(inline.data).toBe(Base64.encode(original))
   })
 
   it("passes a `base64` source through unchanged", async () => {
-    const b64 = Encoding.encodeBase64(new Uint8Array([1, 2, 3]))
+    const b64 = Base64.encode(new Uint8Array([1, 2, 3]))
     const source: AudioSource = { _tag: "base64", base64: b64, mimeType: "audio/mp3" }
     const inline = await Effect.runPromise(audioSourceToInlineData(source))
     expect(inline.mimeType).toBe("audio/mp3")

package/src/geminiSpeechCodec.ts

@@ -1,4 +1,5 @@
-import { Effect, Encoding, Match, Result } from "effect"
+import { Effect, Match, Result } from "effect"
+import { Base64 } from "effect/encoding"
 import * as AiError from "@effect-uai/core/AiError"
 import type { AudioSource } from "@effect-uai/core/Audio"
 
@@ -34,7 +35,7 @@ export const audioSourceToInlineData: (
   Match.tag("bytes", (a) =>
     Effect.succeed<InlineAudioData>({
       mimeType: a.mimeType,
-      data: Encoding.encodeBase64(a.bytes),
+      data: Base64.encode(a.bytes),
     }),
   ),
   Match.tag("base64", (a) =>
@@ -46,7 +47,7 @@ export const audioSourceToInlineData: (
 
 /** Decode a base64-encoded audio payload into bytes. */
 export const decodeBase64Audio = (b64: string): Effect.Effect<Uint8Array, AiError.AiError> =>
-  Result.match(Encoding.decodeBase64(b64), {
+  Result.match(Base64.decode(b64), {
     onSuccess: Effect.succeed,
     onFailure: (cause) =>
       Effect.fail(new AiError.InvalidRequest({ provider: "gemini", param: "audio", raw: cause })),

package/src/geminiTools.test.ts

@@ -16,6 +16,7 @@ const localTool = Tool.make({
   name: "get_weather",
   description: "Look up the weather.",
   inputSchema: Tool.fromEffectSchema(Schema.Struct({ city: Schema.String })),
+  outputSchema: Schema.String,
   run: ({ city }) => Effect.succeed(`sunny in ${city}`),
 })
 

package/src/realtimeSession.test.ts

@@ -1,5 +1,6 @@
 import { describe, it } from "@effect/vitest"
-import { Duration, Effect, Encoding, Fiber, Logger, Redacted, Ref, Stream } from "effect"
+import { Duration, Effect, Fiber, Logger, Redacted, Ref, Stream } from "effect"
+import { Base64 } from "effect/encoding"
 import { expect } from "vitest"
 import type { RealtimeEvent } from "@effect-uai/core/Realtime"
 import { RealtimeInput } from "@effect-uai/core/Realtime"
@@ -55,7 +56,7 @@ const tags = (events: ReadonlyArray<RealtimeEvent>) => events.map((e) => e._tag)
 const audioPart = (bytes: ReadonlyArray<number>) => ({
   inlineData: {
     mimeType: "audio/pcm;rate=24000",
-    data: Encoding.encodeBase64(new Uint8Array(bytes)),
+    data: Base64.encode(new Uint8Array(bytes)),
   },
 })
 
@@ -195,7 +196,7 @@ describe("Gemini live session tools", () => {
               output: {
                 type: "function_call_output",
                 call_id: "fc_1",
-                output: '{"celsius":32}',
+                output: [{ type: "input_json", value: { celsius: 32 } }],
                 providerData: undefined,
               },
             }),
@@ -218,7 +219,7 @@ describe("Gemini live session tools", () => {
         {
           id: "fc_1",
           name: "get_weather",
-          response: { celsius: 32 },
+          response: { output: { celsius: 32 } },
           scheduling: "WHEN_IDLE",
         },
       ])
@@ -241,7 +242,7 @@ describe("Gemini live session tools", () => {
                 output: {
                   type: "function_call_output",
                   call_id: "fc_1",
-                  output: "{}",
+                  output: [{ type: "input_json", value: {} }],
                   providerData: undefined,
                 },
               }),
@@ -266,7 +267,7 @@ describe("Gemini live session tools", () => {
             output: {
               type: "function_call_output",
               call_id: "fc_unknown",
-              output: "{}",
+              output: [{ type: "input_json", value: {} }],
               providerData: undefined,
             },
           }),
@@ -359,7 +360,7 @@ describe("Gemini live session history", () => {
           {
             type: "function_call_output",
             call_id: "fc_1",
-            output: '{"now":"12:00"}',
+            output: [{ type: "input_json", value: { now: "12:00" } }],
             providerData: undefined,
           },
         ],
@@ -406,7 +407,7 @@ describe("Gemini live session video", () => {
       expect(sent.filter((f: any) => f.realtimeInput?.video !== undefined)).toEqual([
         {
           realtimeInput: {
-            video: { data: Encoding.encodeBase64(new Uint8Array([1, 2])), mimeType: "image/jpeg" },
+            video: { data: Base64.encode(new Uint8Array([1, 2])), mimeType: "image/jpeg" },
           },
         },
       ])

package/src/realtimeSession.ts

@@ -13,7 +13,6 @@ import {
   Cause,
   Duration,
   Effect,
-  Encoding,
   Match,
   Pull,
   Queue,
@@ -24,7 +23,8 @@ import {
   type Scope,
   Stream,
 } from "effect"
-import * as Socket from "effect/unstable/socket/Socket"
+import { Base64 } from "effect/encoding"
+import * as Socket from "effect/socket/Socket"
 import * as AiError from "@effect-uai/core/AiError"
 import type { AudioFormat } from "@effect-uai/core/Audio"
 import * as Capabilities from "@effect-uai/core/Capabilities"
@@ -36,7 +36,7 @@ import {
 } from "@effect-uai/core/Realtime"
 import type { RealtimeSessionHandle } from "@effect-uai/core/RealtimeSession"
 import * as WebSocketSession from "@effect-uai/core/WebSocketSession"
-import { parsedResponse, toolDescriptorsToTools } from "./codec.js"
+import { functionResponseBody, toolDescriptorsToTools } from "./codec.js"
 import type { GeminiLiveModel } from "./models.js"
 
 const PROVIDER = "gemini-live"
@@ -383,7 +383,7 @@ const usageOf = (metadata: typeof UsageMetadata.Type): Usage => ({
 })
 
 const decodeAudio = (b64: string): Effect.Effect<Uint8Array, AiError.AiError> =>
-  Result.match(Encoding.decodeBase64(b64), {
+  Result.match(Base64.decode(b64), {
     onSuccess: Effect.succeed,
     onFailure: (cause) =>
       Effect.fail(
@@ -555,7 +555,7 @@ const videoPart = (
   Match.value(frame).pipe(
     Match.tag("base64", (s) => Effect.succeed({ data: s.base64, mimeType: s.mimeType })),
     Match.tag("bytes", (s) =>
-      Effect.succeed({ data: Encoding.encodeBase64(s.bytes), mimeType: s.mimeType }),
+      Effect.succeed({ data: Base64.encode(s.bytes), mimeType: s.mimeType }),
     ),
     Match.tag("url", () =>
       Effect.fail(
@@ -596,7 +596,7 @@ const handleInput = (
         JSON.stringify({
           realtimeInput: {
             audio: {
-              data: Encoding.encodeBase64(i.bytes),
+              data: Base64.encode(i.bytes),
               mimeType: `audio/pcm;rate=${options.rate}`,
             },
           },
@@ -635,7 +635,7 @@ const handleInput = (
                 {
                   id: i.output.call_id,
                   name,
-                  response: parsedResponse(i.output.output),
+                  ...functionResponseBody(i.output),
                   scheduling: options.scheduling,
                 },
               ],