@opencode/ai 0.0.0-dev-19993 → 0.0.0-dev-19996

package/README.md

@@ -66,7 +66,17 @@ console.log(response.answers.refund.probability)
 ```
 
 `TypeSafeAI` reads `TYPESAFE_API_KEY`. `OpenCodeZen` exposes the same selector and reads
-`OPENCODE_API_KEY`. The common API uses `boolean`; System One routes lower it to native `noul`.
+`OPENCODE_API_KEY`. OpenRouter and Vercel AI Gateway use the same provider shape:
+
+```ts
+import { OpenRouter, VercelAIGateway } from "@opencode/ai/providers"
+
+OpenRouter.configure().experimental.evaluation("typesafe/jev-1.13")
+VercelAIGateway.configure().experimental.evaluation("typesafe-ai/jev")
+```
+
+OpenRouter reads `OPENROUTER_API_KEY`. Vercel reads `AI_GATEWAY_API_KEY`, then `VERCEL_OIDC_TOKEN`.
+The common API uses `boolean`; System One routes lower it to native `noul`.
 Choice and score confidence plus score legends remain available in provider metadata, and the
 provider's rounded probabilities are returned unchanged.
 

package/dist/experimental/evaluation-client.d.ts

@@ -1,6 +1,6 @@
 import { Context, Effect, Layer } from "effect";
 import { RequestExecutor } from "../route/executor.js";
-import { type AIError } from "../schema/index.js";
+import { AIError } from "../schema/index.js";
 import { type EvaluationOptions, type EvaluationQuestions, type EvaluationRequestFor, type EvaluationResponseFor } from "./evaluation.js";
 export type Execute = RequestExecutor.Interface["execute"];
 export interface Interface {

package/dist/experimental/evaluation-client.js

@@ -1,6 +1,6 @@
 import { Context, Effect, Layer } from "effect";
 import { RequestExecutor } from "../route/executor.js";
-import { mergeHttpOptions } from "../schema/index.js";
+import { AIError, InvalidProviderOutputError, mergeHttpOptions } from "../schema/index.js";
 import { sanitizeSurrogates } from "../utils/sanitize.js";
 import {} from "./evaluation.js";
 export class Service extends Context.Service()("@opencode/AI/Experimental/EvaluationClient") {
@@ -9,14 +9,50 @@ export const evaluate = (request) => Effect.flatMap(Service, (client) => client.
 export const layer = Layer.effect(Service, Effect.gen(function* () {
     const executor = yield* RequestExecutor.Service;
     return Service.of({
-        evaluate: (request) => request.model.route.evaluate({
+        evaluate: (request) => request.model.route
+            .evaluate({
             ...sanitizeSurrogates({
                 ...request,
                 model: undefined,
                 http: mergeHttpOptions(request.model.http, request.http),
             }),
             model: request.model,
-        }, executor.execute),
+        }, executor.execute)
+            .pipe(Effect.flatMap((response) => {
+            const questions = Object.entries(request.questions);
+            if (questions.length === Object.keys(response.answers).length &&
+                questions.every(([id, question]) => {
+                    const answer = response.answers[id];
+                    if (question.type === "boolean")
+                        return answer?.type === "boolean";
+                    if (question.type === "choice") {
+                        if (answer?.type !== "choice" || !Object.hasOwn(question.criteria, answer.choice))
+                            return false;
+                        if (answer.probabilities === undefined)
+                            return true;
+                        const keys = Object.keys(question.criteria);
+                        const probabilities = answer.probabilities;
+                        return (Object.keys(probabilities).length === keys.length &&
+                            keys.every((key) => Object.hasOwn(probabilities, key)));
+                    }
+                    if (answer?.type !== "score" || answer.score < 0 || answer.score > question.criteria.length - 1)
+                        return false;
+                    if (answer.probabilities === undefined)
+                        return true;
+                    const keys = question.criteria.map((_, index) => String(index));
+                    const probabilities = answer.probabilities;
+                    return (Object.keys(probabilities).length === keys.length &&
+                        keys.every((key) => Object.hasOwn(probabilities, key)));
+                }))
+                return Effect.succeed(response);
+            return Effect.fail(new AIError({
+                reason: new InvalidProviderOutputError({
+                    route: request.model.route.id,
+                    message: "Evaluation answers do not match the requested questions",
+                    cause: response.answers,
+                }),
+            }));
+        })),
     });
 }));
 export const fetchLayer = layer.pipe(Layer.provide(RequestExecutor.fetchLayer));

package/dist/experimental/evaluation.d.ts

@@ -96,7 +96,7 @@ export type AnswersFor<Questions extends EvaluationQuestions> = {
 export type EvaluationOptions = Record<string, unknown>;
 export interface EvaluationRoute<Options extends EvaluationOptions = EvaluationOptions> {
     readonly id: string;
-    readonly evaluate: <const Questions extends EvaluationQuestions>(request: EvaluationRequestFor<Options, Questions>, execute: Execute) => Effect.Effect<EvaluationResponseFor<Questions>, AIError>;
+    readonly evaluate: (request: EvaluationRequestFor<Options>, execute: Execute) => Effect.Effect<EvaluationResponse, AIError>;
 }
 export declare class EvaluationModel<Options extends EvaluationOptions = EvaluationOptions> {
     protected readonly _Options: (options: Options) => Options;

package/dist/experimental/system-one.d.ts

@@ -1,4 +1,4 @@
-import { EvaluationModel } from "./evaluation.js";
+import { EvaluationModel, type EvaluationOptions } from "./evaluation.js";
 import { type Definition as AuthDefinition } from "../route/auth.js";
 import { HttpOptions, ModelID } from "../schema/index.js";
 export interface ModelInput {
@@ -10,7 +10,7 @@ export interface ModelInput {
     readonly headers?: Record<string, string>;
     readonly http?: HttpOptions;
 }
-export declare const model: (cfg: ModelInput) => EvaluationModel<import("./evaluation.js").EvaluationOptions>;
+export declare const model: <Options extends EvaluationOptions = EvaluationOptions>(cfg: ModelInput) => EvaluationModel<Options>;
 export declare const SystemOne: {
-    readonly model: (cfg: ModelInput) => EvaluationModel<import("./evaluation.js").EvaluationOptions>;
+    readonly model: <Options extends EvaluationOptions = EvaluationOptions>(cfg: ModelInput) => EvaluationModel<Options>;
 };

package/dist/experimental/system-one.js

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
-import { BooleanAnswer, ChoiceAnswer, ChoiceQuestion, EvaluationInput, EvaluationModel, EvaluationResponse, EvaluationRounding, ScoreAnswer, ScoreQuestion, } from "./evaluation.js";
+import { ChoiceQuestion, EvaluationInput, EvaluationModel, EvaluationResponse, EvaluationRounding, ScoreQuestion, } from "./evaluation.js";
 import { Auth } from "../route/auth.js";
 import { AIError, HttpContext, HttpOptions, InvalidProviderOutputError, InvalidRequestError, ModelID, Usage, mergeJsonRecords, } from "../schema/index.js";
 const Noul = Schema.Struct({
@@ -40,19 +40,29 @@ const Score = Schema.Struct({
     legend: Schema.optional(Schema.Record(Schema.String, Schema.Json)),
     confidence: Schema.optional(Probability),
 });
-const NativeUsage = Schema.Struct({
+const Answer = Schema.Union([NoulAnswer, Choice, Score]).pipe(Schema.toTaggedUnion("type"));
+const NativeUsage = Schema.StructWithRest(Schema.Struct({
     input_tokens: Schema.optional(Schema.Number),
     output_tokens: Schema.optional(Schema.Number),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+const Response = Schema.Struct({
+    model: Schema.String,
+    answers: Schema.Record(Schema.String, Answer),
+    usage: Schema.optional(NativeUsage),
+    id: Schema.optional(Schema.String),
+    provider: Schema.optional(Schema.String),
+    provider_metadata: Schema.optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))),
 });
-const encode = Schema.encodeUnknownEffect(Schema.fromJsonString(Request));
-const exact = (x, keys) => Object.keys(x).length === keys.length && keys.every((key) => Object.hasOwn(x, key));
-export const model = (cfg) => {
-    const route = {
+export const model = (cfg) => EvaluationModel.make({
+    id: cfg.id,
+    provider: cfg.provider,
+    http: cfg.http,
+    route: {
         id: "system-one",
         evaluate: (req, send) => Effect.gen(function* () {
             const url = new URL(`${cfg.baseURL.replace(/\/$/, "")}/systemone`);
             Object.entries(req.http?.query ?? {}).forEach(([key, value]) => url.searchParams.set(key, value));
-            const body = yield* encode({
+            const body = yield* Schema.encodeUnknownEffect(Schema.fromJsonString(Request))({
                 ...mergeJsonRecords(req.options, req.http?.body),
                 model: req.model.id,
                 state: req.state,
@@ -67,56 +77,36 @@ export const model = (cfg) => {
             });
             const res = yield* send(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(body, "application/json")));
             const http = new HttpContext({ url: res.request.url, status: res.status, headers: res.headers });
-            const fail = (message, cause, body) => new AIError({ reason: new InvalidProviderOutputError({ route: route.id, message, body, http, cause }) });
+            const fail = (message, cause, body) => new AIError({ reason: new InvalidProviderOutputError({ route: "system-one", message, body, http, cause }) });
             const text = yield* res.text.pipe(Effect.mapError((cause) => fail("Failed to read the System One response", cause)));
-            const entries = Object.entries(req.questions);
-            const output = Schema.Struct({
-                model: Schema.String,
-                answers: Schema.Struct(Object.fromEntries(entries.map(([id, question]) => {
-                    if (question.type === "boolean")
-                        return [id, NoulAnswer];
-                    if (question.type === "choice") {
-                        const keys = Object.keys(question.criteria);
-                        return [
-                            id,
-                            Choice.pipe(Schema.refine((x) => Object.hasOwn(question.criteria, x.choice) && exact(x.probabilities, keys), { message: `Question "${id}" returned an invalid choice answer` })),
-                        ];
-                    }
-                    const keys = question.criteria.map((_, index) => String(index));
-                    return [
-                        id,
-                        Score.pipe(Schema.refine((x) => x.score >= 0 && x.score <= question.criteria.length - 1 && exact(x.probabilities, keys), { message: `Question "${id}" returned an invalid score answer` })),
-                    ];
-                }))),
-                usage: Schema.optional(NativeUsage),
-            });
-            const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(output))(text).pipe(Effect.mapError((cause) => fail("System One returned an invalid response", cause, text)));
+            const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(Effect.mapError((cause) => fail("System One returned an invalid response", cause, text)));
             const confidence = {};
             const legend = {};
-            const answers = Object.fromEntries(entries.map(([id, question]) => {
-                const answer = data.answers[id];
-                if (question.type === "boolean")
+            const answers = Object.fromEntries(Object.entries(data.answers).map(([id, answer]) => {
+                if (answer.type === "noul")
+                    return [id, { type: "boolean", probability: answer.noul }];
+                if (answer.type === "choice") {
+                    if (answer.confidence !== undefined)
+                        confidence[id] = answer.confidence;
                     return [
                         id,
-                        { type: "boolean", probability: answer.noul },
-                    ];
-                if (question.type === "choice") {
-                    const value = answer;
-                    if (value.confidence !== undefined)
-                        confidence[id] = value.confidence;
-                    return [
-                        id,
-                        { type: "choice", choice: value.choice, probabilities: value.probabilities },
+                        {
+                            type: "choice",
+                            choice: answer.choice,
+                            probabilities: answer.probabilities,
+                        },
                     ];
                 }
-                const value = answer;
-                if (value.confidence !== undefined)
-                    confidence[id] = value.confidence;
-                if (value.legend !== undefined)
-                    legend[id] = value.legend;
-                return [id, { type: "score", score: value.score, probabilities: value.probabilities }];
+                if (answer.confidence !== undefined)
+                    confidence[id] = answer.confidence;
+                if (answer.legend !== undefined)
+                    legend[id] = answer.legend;
+                return [id, { type: "score", score: answer.score, probabilities: answer.probabilities }];
             }));
             const meta = {
+                ...(data.id === undefined ? {} : { responseId: data.id }),
+                ...(data.provider === undefined ? {} : { provider: data.provider }),
+                ...data.provider_metadata?.[cfg.providerMetadataKey],
                 ...(Object.keys(confidence).length === 0 ? {} : { confidence }),
                 ...(Object.keys(legend).length === 0 ? {} : { legend }),
             };
@@ -137,7 +127,6 @@ export const model = (cfg) => {
                 providerMetadata: Object.keys(meta).length === 0 ? undefined : { [cfg.providerMetadataKey]: meta },
             });
         }),
-    };
-    return EvaluationModel.make({ id: cfg.id, provider: cfg.provider, route, http: cfg.http });
-};
+    },
+});
 export const SystemOne = { model };

package/dist/providers/index.d.ts

@@ -28,6 +28,7 @@ export * as OpenCodeZen from "./opencode-zen.js";
 export * as OpenRouter from "./openrouter.js";
 export * as TogetherAI from "./togetherai.js";
 export * as TypeSafeAI from "./typesafe-ai.js";
+export * as VercelAIGateway from "./vercel-ai-gateway.js";
 export * as XAI from "./xai.js";
 export * as ZAI from "./zai.js";
 export * as ZAICodingPlan from "./zai-coding-plan.js";

package/dist/providers/index.js

@@ -28,6 +28,7 @@ export * as OpenCodeZen from "./opencode-zen.js";
 export * as OpenRouter from "./openrouter.js";
 export * as TogetherAI from "./togetherai.js";
 export * as TypeSafeAI from "./typesafe-ai.js";
+export * as VercelAIGateway from "./vercel-ai-gateway.js";
 export * as XAI from "./xai.js";
 export * as ZAI from "./zai.js";
 export * as ZAICodingPlan from "./zai-coding-plan.js";

package/dist/providers/openrouter.d.ts

@@ -73,6 +73,13 @@ export interface OpenRouterOptions {
     }>;
 }
 export type OpenRouterProviderOptionsInput = OpenRouterOptions;
+export interface OpenRouterEvaluationOptions {
+    readonly [key: string]: unknown;
+    readonly provider?: OpenRouterProviderRouting;
+    readonly session_id?: string;
+    readonly trace?: Readonly<Record<string, unknown>>;
+    readonly user?: string;
+}
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
     readonly providerOptions?: OpenRouterProviderOptionsInput;
@@ -548,16 +555,28 @@ export declare const routes: Route<{
 export declare const configure: (input?: LanguageModelOptions) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenRouterOptions, import("../route/client.js").CompactionOperations | undefined>;
+    experimental: {
+        evaluation: (modelID: string | ModelID) => import("../experimental.js").EvaluationModel<OpenRouterEvaluationOptions>;
+    };
     configure: (input?: LanguageModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenRouterOptions, import("../route/client.js").CompactionOperations | undefined>;
+    experimental: {
+        evaluation: (modelID: string | ModelID) => import("../experimental.js").EvaluationModel<OpenRouterEvaluationOptions>;
+    };
     configure: (input?: LanguageModelOptions) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
         model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenRouterOptions, import("../route/client.js").CompactionOperations | undefined>;
+        experimental: {
+            evaluation: (modelID: string | ModelID) => import("../experimental.js").EvaluationModel<OpenRouterEvaluationOptions>;
+        };
         configure: /*elided*/ any;
     };
 };
+export declare const experimental: {
+    evaluation: (modelID: string | ModelID) => import("../experimental.js").EvaluationModel<OpenRouterEvaluationOptions>;
+};
 export declare const model: ProviderPackage.Definition<Settings, OpenRouterProviderOptionsInput>["model"];
 export {};

package/dist/providers/openrouter.js

@@ -3,7 +3,8 @@ import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
 import { Protocol } from "../route/protocol.js";
 import { AuthOptions } from "../route/auth-options.js";
-import { ProviderID } from "../schema/index.js";
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { SystemOne } from "../experimental/system-one.js";
 import { OpenAIChat } from "../protocols/openai-chat.js";
 import { newBreakpoints, ttlBucket } from "../protocols/utils/cache.js";
 import { isRecord } from "../protocols/shared.js";
@@ -98,13 +99,24 @@ const configuredRoute = (input) => {
 };
 export const configure = (input = {}) => {
     const route = configuredRoute(input);
+    const evaluation = (modelID) => SystemOne.model({
+        id: modelID,
+        provider: id,
+        providerMetadataKey: "openrouter",
+        auth: AuthOptions.bearer(input, "OPENROUTER_API_KEY"),
+        baseURL: input.baseURL ?? baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
     return {
         id,
         model: (modelID) => route.model({ id: modelID, compatibility: { supportsPromptCacheKey: true } }),
+        experimental: { evaluation },
         configure,
     };
 };
 export const provider = configure();
+export const experimental = provider.experimental;
 export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOptions }) => configure({
     apiKey,
     baseURL,

package/dist/providers/vercel-ai-gateway.d.ts

@@ -0,0 +1,41 @@
+import { EvaluationModel } from "../experimental/evaluation.js";
+import { type ProviderAuthOption } from "../route/auth-options.js";
+import { HttpOptions, ModelID } from "../schema/index.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export interface EvaluationOptions {
+    readonly [key: string]: unknown;
+    readonly gateway?: Readonly<{
+        readonly [key: string]: unknown;
+        readonly zeroDataRetention?: boolean;
+        readonly only?: ReadonlyArray<string>;
+    }>;
+}
+export type Options = ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions.Input;
+};
+export declare const configure: (input?: Options) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    experimental: {
+        evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
+    };
+    configure: (input?: Options) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    experimental: {
+        evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
+    };
+    configure: (input?: Options) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        experimental: {
+            evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
+        };
+        configure: /*elided*/ any;
+    };
+};
+export declare const experimental: {
+    evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
+};
+export * as VercelAIGateway from "./vercel-ai-gateway.js";

package/dist/providers/vercel-ai-gateway.js

@@ -0,0 +1,85 @@
+import { Effect, Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { EvaluationAnswer, EvaluationInput, EvaluationModel, EvaluationQuestion, EvaluationResponse, EvaluationRounding, } from "../experimental/evaluation.js";
+import { Auth } from "../route/auth.js";
+import { AuthOptions } from "../route/auth-options.js";
+import { AIError, HttpContext, HttpOptions, InvalidProviderOutputError, InvalidRequestError, ModelID, ProviderID, ProviderMetadata, Usage, } from "../schema/index.js";
+export const id = ProviderID.make("vercel-ai-gateway");
+const baseURL = "https://ai-gateway.vercel.sh/v1";
+const Request = Schema.StructWithRest(Schema.Struct({
+    model: Schema.String,
+    state: EvaluationInput,
+    questions: Schema.Record(Schema.String, EvaluationQuestion),
+    providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+}), [Schema.Record(Schema.String, Schema.Any)]);
+const Response = Schema.Struct({
+    model: Schema.optional(Schema.String),
+    answers: Schema.Record(Schema.String, EvaluationAnswer),
+    usage: Schema.optional(Schema.Struct({
+        inputTokens: Schema.optional(Schema.Number),
+        outputTokens: Schema.optional(Schema.Number),
+    })),
+    rounding: Schema.optional(EvaluationRounding),
+    providerMetadata: Schema.optional(ProviderMetadata),
+});
+export const configure = (input = {}) => {
+    const evaluation = (modelID) => EvaluationModel.make({
+        id: modelID,
+        provider: id,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        route: {
+            id: "vercel-evaluation",
+            evaluate: (req, send) => Effect.gen(function* () {
+                const url = new URL(`${(input.baseURL ?? baseURL).replace(/\/$/, "")}/evaluate`);
+                Object.entries(req.http?.query ?? {}).forEach(([key, value]) => url.searchParams.set(key, value));
+                const body = yield* Schema.encodeUnknownEffect(Schema.fromJsonString(Request))({
+                    ...req.http?.body,
+                    model: req.model.id,
+                    state: req.state,
+                    questions: req.questions,
+                    providerOptions: req.options,
+                }).pipe(Effect.mapError((cause) => new AIError({ reason: new InvalidRequestError({ message: cause.message, cause }) })));
+                const headers = yield* Auth.toEffect(AuthOptions.bearer(input, ["AI_GATEWAY_API_KEY", "VERCEL_OIDC_TOKEN"]))({
+                    request: req,
+                    method: "POST",
+                    url: url.toString(),
+                    body,
+                    headers: Headers.fromInput({ ...input.headers, ...req.http?.headers }),
+                });
+                const res = yield* send(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(body, "application/json")));
+                const http = new HttpContext({ url: res.request.url, status: res.status, headers: res.headers });
+                const fail = (message, cause, body) => new AIError({
+                    reason: new InvalidProviderOutputError({
+                        route: "vercel-evaluation",
+                        message,
+                        body,
+                        http,
+                        cause,
+                    }),
+                });
+                const text = yield* res.text.pipe(Effect.mapError((cause) => fail("Failed to read the Vercel AI Gateway evaluation response", cause)));
+                const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(Effect.mapError((cause) => fail("Vercel AI Gateway returned an invalid evaluation response", cause, text)));
+                return new EvaluationResponse({
+                    model: ModelID.make(data.model ?? req.model.id),
+                    answers: data.answers,
+                    usage: data.usage
+                        ? new Usage({
+                            inputTokens: data.usage.inputTokens,
+                            outputTokens: data.usage.outputTokens,
+                            totalTokens: data.usage.inputTokens === undefined && data.usage.outputTokens === undefined
+                                ? undefined
+                                : (data.usage.inputTokens ?? 0) + (data.usage.outputTokens ?? 0),
+                            providerMetadata: { gateway: data.usage },
+                        })
+                        : undefined,
+                    rounding: data.rounding,
+                    providerMetadata: data.providerMetadata,
+                });
+            }),
+        },
+    });
+    return { id, experimental: { evaluation }, configure };
+};
+export const provider = configure();
+export const experimental = provider.experimental;
+export * as VercelAIGateway from "./vercel-ai-gateway.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-19993",
+  "version": "0.0.0-dev-19996",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "0.0.0-dev-19993",
+    "@opencode/http-recorder": "0.0.0-dev-19996",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -40,7 +40,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "0.0.0-dev-19993",
+    "@opencode/schema": "0.0.0-dev-19996",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"