@opencode-ai/ai 0.0.0-next-15903 → 0.0.0-next-15909

package/README.md

@@ -63,6 +63,53 @@ yield *
   })
 ```
 
+xAI image models use the same request API with xAI-native controls:
+
+```ts
+yield *
+  Image.generate({
+    model: XAI.configure({ apiKey }).image("any-model-id"),
+    prompt,
+    options: {
+      n: 2,
+      aspectRatio: "16:9",
+      resolution: "1k",
+      responseFormat: "b64_json",
+      future_option: true,
+    },
+    http,
+  })
+```
+
+Google's current Gemini image models use the same direct API:
+
+```ts
+import { Google } from "@opencode-ai/ai/providers"
+
+const googleProgram = Effect.gen(function* () {
+  const response = yield* Image.generate({
+    model: Google.configure({ apiKey }).image("any-model-id"),
+    prompt: "A robot tending a rooftop garden",
+    options: {
+      aspectRatio: "16:9",
+      imageSize: "2K",
+      seed: 42,
+      thinkingLevel: "HIGH",
+      includeThoughts: true,
+      futureOption: true,
+    },
+    http,
+  })
+
+  return response.images
+})
+```
+
+Google image options are request-scoped and inferred from the selected model. Known fields autocomplete while
+future string values and arbitrary native Gemini `generationConfig` fields remain available. Native fields override
+their mapped aliases, and `http.body` is the final deep overlay. The selected model ID is sent to Gemini
+`generateContent` without a local allowlist.
+
 Conversational image generation remains part of the LLM interaction. OpenAI Responses exposes it through its hosted image tool:
 
 ```ts

package/dist/protocols/google-images.d.ts

@@ -0,0 +1,32 @@
+import { ImageModel } from "../image";
+import { type Definition as AuthDefinition } from "../route/auth";
+import { type HttpOptions } from "../schema";
+export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+export type GoogleImageString<Known extends string> = Known | (string & {});
+export type GoogleImageOptions = {
+    readonly aspectRatio?: GoogleImageString<"1:1" | "2:3" | "3:2" | "3:4" | "4:3" | "4:5" | "5:4" | "9:16" | "16:9" | "21:9">;
+    readonly imageSize?: GoogleImageString<"1K" | "2K" | "4K">;
+    readonly seed?: number;
+    readonly thinkingLevel?: GoogleImageString<"MINIMAL" | "LOW" | "MEDIUM" | "HIGH">;
+    readonly includeThoughts?: boolean;
+} & Record<string, unknown>;
+export type GoogleImageBody = Record<string, unknown> & {
+    readonly contents: ReadonlyArray<{
+        readonly role: "user";
+        readonly parts: ReadonlyArray<{
+            readonly text: string;
+        }>;
+    }>;
+    readonly generationConfig: Record<string, unknown>;
+};
+export interface ModelInput {
+    readonly id: string;
+    readonly auth: AuthDefinition;
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions;
+}
+export declare const model: (input: ModelInput) => ImageModel<GoogleImageOptions>;
+export declare const GoogleImages: {
+    readonly model: (input: ModelInput) => ImageModel<GoogleImageOptions>;
+};

package/dist/protocols/google-images.js

@@ -0,0 +1,174 @@
+import { Effect, Encoding, Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { GeneratedImage, ImageModel, ImageResponse } from "../image";
+import { Auth } from "../route/auth";
+import { InvalidProviderOutputReason, LLMError, Usage, mergeHttpOptions, mergeJsonRecords, } from "../schema";
+import { ProviderShared } from "./shared";
+const ADAPTER = "google-images";
+export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+const GoogleUsage = Schema.StructWithRest(Schema.Struct({
+    cachedContentTokenCount: Schema.optional(Schema.Number),
+    thoughtsTokenCount: Schema.optional(Schema.Number),
+    promptTokenCount: Schema.optional(Schema.Number),
+    candidatesTokenCount: Schema.optional(Schema.Number),
+    totalTokenCount: Schema.optional(Schema.Number),
+    promptTokensDetails: Schema.optional(Schema.Unknown),
+    candidatesTokensDetails: Schema.optional(Schema.Unknown),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+const GoogleImageResponse = Schema.Struct({
+    candidates: Schema.optional(Schema.Array(Schema.Struct({
+        index: Schema.optional(Schema.Number),
+        content: Schema.optional(Schema.Struct({
+            parts: Schema.Array(Schema.Struct({
+                text: Schema.optional(Schema.String),
+                thought: Schema.optional(Schema.Boolean),
+                thoughtSignature: Schema.optional(Schema.String),
+                inlineData: Schema.optional(Schema.Struct({
+                    mimeType: Schema.String,
+                    data: Schema.String,
+                })),
+            })),
+        })),
+        finishReason: Schema.optional(Schema.String),
+        finishMessage: Schema.optional(Schema.String),
+        safetyRatings: Schema.optional(Schema.Unknown),
+        citationMetadata: Schema.optional(Schema.Unknown),
+        groundingMetadata: Schema.optional(Schema.Unknown),
+    }))),
+    usageMetadata: Schema.optional(GoogleUsage),
+    modelVersion: Schema.optional(Schema.String),
+    responseId: Schema.optional(Schema.String),
+    promptFeedback: Schema.optional(Schema.Unknown),
+});
+const nativeOptions = (options) => {
+    const { aspectRatio, imageSize, seed, thinkingLevel, includeThoughts, ...native } = options ?? {};
+    const image = {
+        aspectRatio,
+        imageSize,
+    };
+    const thinkingConfig = {
+        thinkingLevel,
+        includeThoughts,
+    };
+    return (mergeJsonRecords({
+        responseModalities: ["IMAGE"],
+        imageConfig: Object.values(image).some((value) => value !== undefined) ? image : undefined,
+        seed,
+        thinkingConfig: Object.values(thinkingConfig).some((value) => value !== undefined) ? thinkingConfig : undefined,
+    }, native) ?? { responseModalities: ["IMAGE"] });
+};
+const body = (request, overlay) => mergeJsonRecords({
+    contents: [{ role: "user", parts: [{ text: request.prompt }] }],
+    generationConfig: nativeOptions(request.options),
+}, overlay);
+const invalidOutput = (message, providerMetadata) => new LLMError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER, providerMetadata }),
+});
+const applyQuery = (url, query) => {
+    if (!query)
+        return url;
+    const next = new URL(url);
+    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
+    return next.toString();
+};
+export const model = (input) => {
+    const route = {
+        id: ADAPTER,
+        generate: Effect.fn("GoogleImages.generate")(function* (request, execute) {
+            const http = mergeHttpOptions(request.model.http, request.http);
+            const text = ProviderShared.encodeJson(body(request, http?.body));
+            const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}/models/${request.model.id}:generateContent`, http?.query);
+            const headers = yield* Auth.toEffect(input.auth)({
+                request,
+                method: "POST",
+                url,
+                body: text,
+                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
+            });
+            const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
+            const payload = yield* response.json.pipe(Effect.mapError(() => invalidOutput("Failed to read the Google Images response")));
+            const decoded = yield* Schema.decodeUnknownEffect(GoogleImageResponse)(payload).pipe(Effect.mapError(() => invalidOutput("Google Images returned an invalid response")));
+            const candidates = decoded.candidates ?? [];
+            const candidateMetadata = candidates.map((candidate, candidateIndex) => ({
+                index: candidate.index ?? candidateIndex,
+                finishReason: candidate.finishReason,
+                finishMessage: candidate.finishMessage,
+                safetyRatings: candidate.safetyRatings,
+                citationMetadata: candidate.citationMetadata,
+                groundingMetadata: candidate.groundingMetadata,
+                parts: (candidate.content?.parts ?? []).map((part) => part.inlineData === undefined
+                    ? {
+                        type: "text",
+                        text: part.text,
+                        thought: part.thought,
+                        thoughtSignature: part.thoughtSignature,
+                    }
+                    : {
+                        type: "inlineData",
+                        mediaType: part.inlineData.mimeType,
+                        thought: part.thought,
+                        thoughtSignature: part.thoughtSignature,
+                    }),
+            }));
+            const encoded = candidates.flatMap((candidate, candidateIndex) => (candidate.content?.parts ?? []).flatMap((part, partIndex) => part.inlineData === undefined || part.thought === true
+                ? []
+                : [{ candidate, candidateIndex, partIndex, inlineData: part.inlineData }]));
+            const images = yield* Effect.forEach(encoded, (item) => Effect.fromResult(Encoding.decodeBase64(item.inlineData.data)).pipe(Effect.mapError(() => invalidOutput(`Google Images candidate ${item.candidateIndex} part ${item.partIndex} contains invalid base64 data`)), Effect.map((data) => new GeneratedImage({
+                mediaType: item.inlineData.mimeType,
+                data,
+                providerMetadata: {
+                    google: {
+                        candidateIndex: item.candidate.index ?? item.candidateIndex,
+                        partIndex: item.partIndex,
+                        finishReason: item.candidate.finishReason,
+                        safetyRatings: item.candidate.safetyRatings,
+                        citationMetadata: item.candidate.citationMetadata,
+                        groundingMetadata: item.candidate.groundingMetadata,
+                        thoughtSignature: item.candidate.content?.parts[item.partIndex]?.thoughtSignature,
+                    },
+                },
+            }))));
+            if (images.length === 0) {
+                const finishReasons = candidates.flatMap((candidate) => candidate.finishReason === undefined ? [] : [candidate.finishReason]);
+                return yield* invalidOutput(`Google Images returned no final images${finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`}; inspect reason.providerMetadata.google for prompt feedback and candidate details`, {
+                    google: {
+                        promptFeedback: decoded.promptFeedback,
+                        candidates: candidateMetadata,
+                    },
+                });
+            }
+            const usage = decoded.usageMetadata;
+            const outputTokens = usage?.candidatesTokenCount === undefined
+                ? undefined
+                : usage.candidatesTokenCount + (usage.thoughtsTokenCount ?? 0);
+            return new ImageResponse({
+                images,
+                usage: usage === undefined
+                    ? undefined
+                    : new Usage({
+                        inputTokens: usage.promptTokenCount,
+                        outputTokens,
+                        nonCachedInputTokens: ProviderShared.subtractTokens(usage.promptTokenCount, usage.cachedContentTokenCount),
+                        cacheReadInputTokens: usage.cachedContentTokenCount,
+                        reasoningTokens: usage.thoughtsTokenCount,
+                        totalTokens: ProviderShared.totalTokens(usage.promptTokenCount, outputTokens, usage.totalTokenCount),
+                        providerMetadata: { google: usage },
+                    }),
+                providerMetadata: {
+                    google: {
+                        modelVersion: decoded.modelVersion,
+                        responseId: decoded.responseId,
+                        promptFeedback: decoded.promptFeedback,
+                        candidates: candidateMetadata,
+                    },
+                },
+            });
+        }),
+    };
+    return ImageModel.make({ id: input.id, provider: "google", route, http: input.http });
+};
+export const GoogleImages = {
+    model,
+};

package/dist/protocols/xai-images.d.ts

@@ -0,0 +1,25 @@
+import { ImageModel } from "../image";
+import { type Definition as AuthDefinition } from "../route/auth";
+import { type HttpOptions } from "../schema";
+export declare const DEFAULT_BASE_URL = "https://api.x.ai/v1";
+export declare const PATH = "/images/generations";
+export type XAIImageString<Known extends string> = Known | (string & {});
+export type XAIImageOptions = {
+    readonly n?: number;
+    readonly aspectRatio?: XAIImageString<"1:1" | "3:4" | "4:3" | "9:16" | "16:9" | "2:3" | "3:2" | "9:19.5" | "19.5:9" | "9:20" | "20:9" | "1:2" | "2:1" | "auto">;
+    readonly aspect_ratio?: XAIImageString<"1:1" | "3:4" | "4:3" | "9:16" | "16:9" | "2:3" | "3:2" | "9:19.5" | "19.5:9" | "9:20" | "20:9" | "1:2" | "2:1" | "auto">;
+    readonly resolution?: XAIImageString<"1k" | "2k">;
+    readonly responseFormat?: XAIImageString<"url" | "b64_json">;
+    readonly response_format?: XAIImageString<"url" | "b64_json">;
+} & Record<string, unknown>;
+export interface ModelInput {
+    readonly id: string;
+    readonly auth: AuthDefinition;
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions;
+}
+export declare const model: (input: ModelInput) => ImageModel<XAIImageOptions>;
+export declare const XAIImages: {
+    readonly model: (input: ModelInput) => ImageModel<XAIImageOptions>;
+};

package/dist/protocols/xai-images.js

@@ -0,0 +1,93 @@
+import { Effect, Encoding, Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { GeneratedImage, ImageModel, ImageResponse } from "../image";
+import { Auth } from "../route/auth";
+import { InvalidProviderOutputReason, LLMError, Usage, mergeHttpOptions, mergeJsonRecords, } from "../schema";
+import { ProviderShared, optionalNull } from "./shared";
+const ADAPTER = "xai-images";
+export const DEFAULT_BASE_URL = "https://api.x.ai/v1";
+export const PATH = "/images/generations";
+const XAIImageResponse = Schema.Struct({
+    data: Schema.Array(Schema.Struct({
+        b64_json: optionalNull(Schema.String),
+        url: optionalNull(Schema.String),
+        revised_prompt: optionalNull(Schema.String),
+        mime_type: optionalNull(Schema.String),
+    })),
+    usage: Schema.optional(Schema.Unknown),
+});
+const nativeOptions = (options) => {
+    if (!options)
+        return undefined;
+    const { aspectRatio, responseFormat, ...native } = options;
+    return {
+        aspect_ratio: aspectRatio,
+        response_format: responseFormat,
+        ...native,
+    };
+};
+const invalidOutput = (message) => new LLMError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
+});
+const applyQuery = (url, query) => {
+    if (!query)
+        return url;
+    const next = new URL(url);
+    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
+    return next.toString();
+};
+export const model = (input) => {
+    const route = {
+        id: ADAPTER,
+        generate: Effect.fn("XAIImages.generate")(function* (request, execute) {
+            const http = mergeHttpOptions(request.model.http, request.http);
+            const requestBody = mergeJsonRecords({ model: request.model.id, prompt: request.prompt }, nativeOptions(request.options), http?.body);
+            const text = ProviderShared.encodeJson(requestBody);
+            const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${PATH}`, http?.query);
+            const headers = yield* Auth.toEffect(input.auth)({
+                request,
+                method: "POST",
+                url,
+                body: text,
+                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
+            });
+            const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
+            const payload = yield* response.json.pipe(Effect.mapError(() => invalidOutput("Failed to read the xAI Images response")));
+            const decoded = yield* Schema.decodeUnknownEffect(XAIImageResponse)(payload).pipe(Effect.mapError(() => invalidOutput("xAI Images returned an invalid response")));
+            const images = yield* Effect.forEach(decoded.data, (item, index) => {
+                const mediaType = item.mime_type ?? "application/octet-stream";
+                if (item.b64_json)
+                    return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(Effect.mapError(() => invalidOutput(`xAI Images result ${index} contains invalid base64 data`)), Effect.map((data) => new GeneratedImage({
+                        mediaType,
+                        data,
+                        providerMetadata: item.revised_prompt === undefined || item.revised_prompt === null
+                            ? undefined
+                            : { xai: { revisedPrompt: item.revised_prompt } },
+                    })));
+                if (item.url)
+                    return Effect.succeed(new GeneratedImage({
+                        mediaType,
+                        data: item.url,
+                        providerMetadata: item.revised_prompt === undefined || item.revised_prompt === null
+                            ? undefined
+                            : { xai: { revisedPrompt: item.revised_prompt } },
+                    }));
+                return Effect.fail(invalidOutput(`xAI Images result ${index} has neither image data nor a URL`));
+            });
+            if (images.length === 0)
+                return yield* invalidOutput("xAI Images returned no images");
+            const usage = ProviderShared.isRecord(decoded.usage) ? decoded.usage : undefined;
+            return new ImageResponse({
+                images,
+                usage: usage === undefined ? undefined : new Usage({ providerMetadata: { xai: usage } }),
+                providerMetadata: usage === undefined ? undefined : { xai: { usage } },
+            });
+        }),
+    };
+    return ImageModel.make({ id: input.id, provider: "xai", route, http: input.http });
+};
+export const XAIImages = {
+    model,
+};

package/dist/providers/google.d.ts

@@ -2,6 +2,7 @@ import type { RouteDefaultsInput } from "../route/client";
 import type { ProviderAuthOption } from "../route/auth-options";
 import type { ProviderPackage } from "../provider-package";
 import { type ModelID, type ProviderOptions } from "../schema";
+export type { GoogleImageOptions } from "../protocols/google-images";
 export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
 export declare const routes: import("../route").Route<{
     readonly contents: readonly import("effect/Schema").Struct.ReadonlySide<{
@@ -69,15 +70,19 @@ export interface Settings extends ProviderPackage.Settings {
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
     model: (modelID: string | ModelID) => import("..").Model;
+    image: (modelID: string | ModelID) => import("..").ImageModel<import("./google").GoogleImageOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
     model: (modelID: string | ModelID) => import("..").Model;
+    image: (modelID: string | ModelID) => import("..").ImageModel<import("./google").GoogleImageOptions>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
         model: (modelID: string | ModelID) => import("..").Model;
+        image: (modelID: string | ModelID) => import("..").ImageModel<import("./google").GoogleImageOptions>;
         configure: /*elided*/ any;
     };
 };
 export declare const model: ProviderPackage.Definition<Settings>["model"];
+export declare const image: (modelID: string | ModelID) => import("..").ImageModel<import("./google").GoogleImageOptions>;

package/dist/providers/google.js

@@ -1,6 +1,7 @@
 import { Auth } from "../route/auth";
-import { ProviderID } from "../schema";
-import * as Gemini from "../protocols/gemini";
+import { HttpOptions, ProviderID, mergeHttpOptions } from "../schema";
+import { Gemini } from "../protocols/gemini";
+import { GoogleImages } from "../protocols/google-images";
 export const id = ProviderID.make("google");
 export const routes = [Gemini.route];
 const auth = (options) => {
@@ -16,9 +17,17 @@ const configuredRoute = (input) => {
 };
 export const configure = (input = {}) => {
     const route = configuredRoute(input);
+    const image = (modelID) => GoogleImages.model({
+        id: modelID,
+        auth: auth(input),
+        baseURL: input.baseURL,
+        headers: input.headers,
+        http: mergeHttpOptions(input.http === undefined ? undefined : HttpOptions.make(input.http)),
+    });
     return {
         id,
         model: (modelID) => route.model({ id: modelID }),
+        image,
         configure,
     };
 };
@@ -31,3 +40,4 @@ export const model = (modelID, settings) => configure({
     limits: settings.limits,
     providerOptions: settings.providerOptions,
 }).model(modelID);
+export const image = provider.image;

package/dist/providers/xai.d.ts

@@ -5,6 +5,7 @@ export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">
 export type ModelOptions = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
 };
+export type { XAIImageOptions } from "../protocols/xai-images";
 export declare const routes: (import("../route").Route<{
     readonly messages: readonly (import("effect/Schema").Struct.ReadonlySide<{
         readonly role: import("effect/Schema").Literal<"system">;
@@ -162,6 +163,7 @@ export declare const configure: (input?: ModelOptions) => {
     model: (modelID: string | ModelID) => import("..").Model;
     responses: (modelID: string | ModelID) => import("..").Model;
     chat: (modelID: string | ModelID) => import("..").Model;
+    image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;
     configure: (input?: ModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
@@ -169,14 +171,17 @@ export declare const provider: {
     model: (modelID: string | ModelID) => import("..").Model;
     responses: (modelID: string | ModelID) => import("..").Model;
     chat: (modelID: string | ModelID) => import("..").Model;
+    image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;
     configure: (input?: ModelOptions) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
         model: (modelID: string | ModelID) => import("..").Model;
         responses: (modelID: string | ModelID) => import("..").Model;
         chat: (modelID: string | ModelID) => import("..").Model;
+        image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;
         configure: /*elided*/ any;
     };
 };
 export declare const model: (modelID: string | ModelID) => import("..").Model;
 export declare const responses: (modelID: string | ModelID) => import("..").Model;
 export declare const chat: (modelID: string | ModelID) => import("..").Model;
+export declare const image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;

package/dist/providers/xai.js

@@ -1,8 +1,9 @@
 import { AuthOptions } from "../route/auth-options";
-import { ProviderID } from "../schema";
+import { HttpOptions, ProviderID } from "../schema";
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile";
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat";
 import * as OpenAIResponses from "../protocols/openai-responses";
+import { XAIImages } from "../protocols/xai-images";
 export const id = ProviderID.make("xai");
 export const routes = [OpenAIResponses.route, OpenAICompatibleChat.route];
 const auth = (options) => AuthOptions.bearer(options, "XAI_API_KEY");
@@ -29,11 +30,19 @@ export const configure = (input = {}) => {
     const chatRoute = configuredChatRoute(input);
     const responses = (modelID) => responsesRoute.model({ id: modelID });
     const chat = (modelID) => chatRoute.model({ id: modelID });
+    const image = (modelID) => XAIImages.model({
+        id: modelID,
+        auth: auth(input),
+        baseURL: input.baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
     return {
         id,
         model: responses,
         responses,
         chat,
+        image,
         configure,
     };
 };
@@ -41,3 +50,4 @@ export const provider = configure();
 export const model = provider.model;
 export const responses = provider.responses;
 export const chat = provider.chat;
+export const image = provider.image;

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-next-15903",
+  "version": "0.0.0-next-15909",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -26,7 +26,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-beta.98",
-    "@opencode-ai/http-recorder": "0.0.0-next-15903",
+    "@opencode-ai/http-recorder": "0.0.0-next-15909",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -35,7 +35,7 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-next-15903",
+    "@opencode-ai/schema": "0.0.0-next-15909",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-beta.98",
     "google-auth-library": "10.5.0"