@opencode/ai 2.0.11 → 2.0.13

package/README.md

@@ -29,6 +29,47 @@ await Effect.runPromise(program.pipe(Effect.provide(llmLayer)))
 
 Run `LLMClient.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses, Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.
 
+## Experimental evaluation
+
+Evaluation models compare shared state with typed choice, score, and boolean questions. The API is
+isolated under an experimental entrypoint and provider namespace while the contract evolves:
+
+```ts
+import { Effect } from "effect"
+import { Evaluation, EvaluationClient } from "@opencode/ai/experimental"
+import { TypeSafeAI } from "@opencode/ai/providers"
+
+const model = TypeSafeAI.configure().experimental.evaluation("jev-latest")
+
+const program = Evaluation.evaluate({
+  model,
+  state: "I was charged twice. Please refund the duplicate payment.",
+  questions: {
+    department: {
+      type: "choice",
+      instructions: "Which team should handle this?",
+      criteria: { billing: "Payments and refunds", technical: "Bugs and outages" },
+    },
+    urgency: {
+      type: "score",
+      instructions: "How urgent is this?",
+      criteria: ["Can wait", "Needs prompt attention", "Blocking revenue"],
+    },
+    refund: { type: "boolean", instructions: "Is the customer asking for a refund?" },
+  },
+})
+
+const response = await Effect.runPromise(program.pipe(Effect.provide(EvaluationClient.fetchLayer)))
+
+console.log(response.answers.department.choice)
+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`.
+Choice and score confidence plus score legends remain available in provider metadata, and the
+provider's rounded probabilities are returned unchanged.
+
 ## Alibaba Cloud Model Studio
 
 `Alibaba` provides standard Model Studio inference. Configure a region explicitly, then select

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

@@ -0,0 +1,21 @@
+import { Context, Effect, Layer } from "effect";
+import { RequestExecutor } from "../route/executor.js";
+import { type 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 {
+    readonly evaluate: <Options extends EvaluationOptions, const Questions extends EvaluationQuestions>(request: EvaluationRequestFor<Options, Questions>) => Effect.Effect<EvaluationResponseFor<Questions>, AIError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/AI/Experimental/EvaluationClient", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const evaluate: <Options extends EvaluationOptions, const Questions extends EvaluationQuestions>(request: EvaluationRequestFor<Options, Questions>) => Effect.Effect<EvaluationResponseFor<Questions>, AIError, Service>;
+export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+export declare const fetchLayer: Layer.Layer<Service, never, never>;
+export declare const EvaluationClient: {
+    readonly Service: typeof Service;
+    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+    readonly fetchLayer: Layer.Layer<Service, never, never>;
+    readonly evaluate: <Options extends EvaluationOptions, const Questions extends EvaluationQuestions>(request: EvaluationRequestFor<Options, Questions>) => Effect.Effect<EvaluationResponseFor<Questions>, AIError, Service>;
+};
+export {};

package/dist/experimental/evaluation-client.js

@@ -0,0 +1,28 @@
+import { Context, Effect, Layer } from "effect";
+import { RequestExecutor } from "../route/executor.js";
+import { 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") {
+}
+export const evaluate = (request) => Effect.flatMap(Service, (client) => client.evaluate(request));
+export const layer = Layer.effect(Service, Effect.gen(function* () {
+    const executor = yield* RequestExecutor.Service;
+    return Service.of({
+        evaluate: (request) => request.model.route.evaluate({
+            ...sanitizeSurrogates({
+                ...request,
+                model: undefined,
+                http: mergeHttpOptions(request.model.http, request.http),
+            }),
+            model: request.model,
+        }, executor.execute),
+    });
+}));
+export const fetchLayer = layer.pipe(Layer.provide(RequestExecutor.fetchLayer));
+export const EvaluationClient = {
+    Service,
+    layer,
+    fetchLayer,
+    evaluate,
+};

package/dist/experimental/evaluation.d.ts

@@ -0,0 +1,234 @@
+import { Effect, Schema } from "effect";
+import { AIError, HttpOptions, ModelID, ProviderID, Usage } from "../schema/index.js";
+import { Service, type Execute } from "./evaluation-client.js";
+export declare const EvaluationInput: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+export type EvaluationInput = Schema.Schema.Type<typeof EvaluationInput>;
+export declare const ChoiceQuestion: Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly criteria: Schema.refine<{
+        readonly [x: string]: string | {
+            readonly [x: string]: Schema.Json;
+        } | readonly Schema.Json[] | null;
+    }, Schema.$Record<Schema.String, Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>>;
+}>;
+export type ChoiceQuestion = Schema.Schema.Type<typeof ChoiceQuestion>;
+export declare const ScoreQuestion: Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly criteria: Schema.$Array<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>;
+}>;
+export type ScoreQuestion = Schema.Schema.Type<typeof ScoreQuestion>;
+export declare const BooleanQuestion: Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly criteria: Schema.optional<Schema.Struct<{
+        readonly true: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>;
+        readonly false: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>;
+    }>>;
+}>;
+export type BooleanQuestion = Schema.Schema.Type<typeof BooleanQuestion>;
+export declare const EvaluationQuestion: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly criteria: Schema.refine<{
+        readonly [x: string]: string | {
+            readonly [x: string]: Schema.Json;
+        } | readonly Schema.Json[] | null;
+    }, Schema.$Record<Schema.String, Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly criteria: Schema.$Array<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly criteria: Schema.optional<Schema.Struct<{
+        readonly true: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>;
+        readonly false: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>;
+    }>>;
+}>]>;
+export type EvaluationQuestion = Schema.Schema.Type<typeof EvaluationQuestion>;
+export type EvaluationQuestions = Readonly<Record<string, EvaluationQuestion>>;
+export declare const ChoiceAnswer: Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly choice: Schema.String;
+    readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+}>;
+export type ChoiceAnswer = Schema.Schema.Type<typeof ChoiceAnswer>;
+export declare const ScoreAnswer: Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly score: Schema.Number;
+    readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+}>;
+export type ScoreAnswer = Schema.Schema.Type<typeof ScoreAnswer>;
+export declare const BooleanAnswer: Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly probability: Schema.Number;
+}>;
+export type BooleanAnswer = Schema.Schema.Type<typeof BooleanAnswer>;
+export declare const EvaluationAnswer: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly choice: Schema.String;
+    readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly score: Schema.Number;
+    readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly probability: Schema.Number;
+}>]>;
+export type EvaluationAnswer = Schema.Schema.Type<typeof EvaluationAnswer>;
+export type AnswerFor<Question extends EvaluationQuestion> = Question extends {
+    readonly type: "choice";
+    readonly criteria: infer Criteria;
+} ? {
+    readonly type: "choice";
+    readonly choice: Extract<keyof Criteria, string>;
+    readonly probabilities?: Readonly<Record<Extract<keyof Criteria, string>, number>>;
+} : Question extends {
+    readonly type: "score";
+} ? ScoreAnswer : BooleanAnswer;
+export type AnswersFor<Questions extends EvaluationQuestions> = {
+    readonly [ID in keyof Questions]: AnswerFor<Questions[ID]>;
+};
+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>;
+}
+export declare class EvaluationModel<Options extends EvaluationOptions = EvaluationOptions> {
+    protected readonly _Options: (options: Options) => Options;
+    readonly id: ModelID;
+    readonly provider: ProviderID;
+    readonly route: EvaluationRoute<Options>;
+    readonly http?: HttpOptions;
+    constructor(input: EvaluationModel.Input<Options>);
+    static make<Options extends EvaluationOptions = EvaluationOptions>(input: EvaluationModel.MakeInput<Options>): EvaluationModel<Options>;
+}
+export declare namespace EvaluationModel {
+    interface Input<Options extends EvaluationOptions = EvaluationOptions> {
+        readonly id: ModelID;
+        readonly provider: ProviderID;
+        readonly route: EvaluationRoute<Options>;
+        readonly http?: HttpOptions;
+    }
+    interface MakeInput<Options extends EvaluationOptions = EvaluationOptions> extends Omit<Input<Options>, "id" | "provider"> {
+        readonly id: string | ModelID;
+        readonly provider: string | ProviderID;
+    }
+}
+export declare const EvaluationModelSchema: Schema.declare<EvaluationModel<EvaluationOptions>, EvaluationModel<EvaluationOptions>>;
+declare const EvaluationRequest_base: Schema.Class<EvaluationRequest, Schema.Struct<{
+    readonly model: Schema.declare<EvaluationModel<EvaluationOptions>, EvaluationModel<EvaluationOptions>>;
+    readonly state: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly questions: Schema.refine<{
+        readonly [x: string]: {
+            readonly type: "choice";
+            readonly instructions: string | {
+                readonly [x: string]: Schema.Json;
+            } | readonly Schema.Json[];
+            readonly criteria: {
+                readonly [x: string]: string | {
+                    readonly [x: string]: Schema.Json;
+                } | readonly Schema.Json[] | null;
+            };
+        } | {
+            readonly type: "score";
+            readonly instructions: string | {
+                readonly [x: string]: Schema.Json;
+            } | readonly Schema.Json[];
+            readonly criteria: readonly (string | {
+                readonly [x: string]: Schema.Json;
+            } | readonly Schema.Json[] | null)[];
+        } | {
+            readonly type: "boolean";
+            readonly instructions: string | {
+                readonly [x: string]: Schema.Json;
+            } | readonly Schema.Json[];
+            readonly criteria?: {
+                readonly true?: string | {
+                    readonly [x: string]: Schema.Json;
+                } | readonly Schema.Json[] | null | undefined;
+                readonly false?: string | {
+                    readonly [x: string]: Schema.Json;
+                } | readonly Schema.Json[] | null | undefined;
+            } | undefined;
+        };
+    }, Schema.$Record<Schema.String, Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"choice">;
+        readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+        readonly criteria: Schema.refine<{
+            readonly [x: string]: string | {
+                readonly [x: string]: Schema.Json;
+            } | readonly Schema.Json[] | null;
+        }, Schema.$Record<Schema.String, Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"score">;
+        readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+        readonly criteria: Schema.$Array<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"boolean">;
+        readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+        readonly criteria: Schema.optional<Schema.Struct<{
+            readonly true: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>;
+            readonly false: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>;
+        }>>;
+    }>]>>>;
+    readonly options: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly http: Schema.optional<typeof HttpOptions>;
+}>, {}>;
+export declare class EvaluationRequest extends EvaluationRequest_base {
+    protected readonly _EvaluationRequest: void;
+}
+export type EvaluationModelOptions<Model> = Model extends EvaluationModel<infer Options> ? Options : never;
+export type EvaluationRequestFor<Options extends EvaluationOptions = EvaluationOptions, Questions extends EvaluationQuestions = EvaluationQuestions> = Omit<EvaluationRequest, "model" | "questions" | "options"> & {
+    readonly model: EvaluationModel<Options>;
+    readonly questions: Questions;
+    readonly options?: Options;
+};
+export type EvaluationRequestInput<Model extends object = EvaluationModel, Questions extends EvaluationQuestions = EvaluationQuestions> = Omit<ConstructorParameters<typeof EvaluationRequest>[0], "model" | "questions" | "options" | "http"> & {
+    readonly model: Model;
+    readonly questions: Questions;
+    readonly options?: NoInfer<EvaluationModelOptions<Model>>;
+    readonly http?: HttpOptions.Input;
+} & (Model extends EvaluationModel<EvaluationModelOptions<Model>> ? unknown : never);
+declare const EvaluationRounding_base: Schema.Class<EvaluationRounding, Schema.Struct<{
+    readonly probabilityDecimals: Schema.optional<Schema.Int>;
+    readonly scoreDecimals: Schema.optional<Schema.Int>;
+}>, {}>;
+export declare class EvaluationRounding extends EvaluationRounding_base {
+}
+declare const EvaluationResponse_base: Schema.Class<EvaluationResponse, Schema.Struct<{
+    readonly model: Schema.brand<Schema.String, "AI.ModelID">;
+    readonly answers: Schema.$Record<Schema.String, Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"choice">;
+        readonly choice: Schema.String;
+        readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"score">;
+        readonly score: Schema.Number;
+        readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"boolean">;
+        readonly probability: Schema.Number;
+    }>]>>;
+    readonly usage: Schema.optional<typeof Usage>;
+    readonly rounding: Schema.optional<typeof EvaluationRounding>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>, {}>;
+export declare class EvaluationResponse extends EvaluationResponse_base {
+}
+export type EvaluationResponseFor<Questions extends EvaluationQuestions> = Omit<EvaluationResponse, "answers"> & {
+    readonly answers: AnswersFor<Questions>;
+};
+export declare function request<const Model extends object, const Questions extends EvaluationQuestions>(input: EvaluationRequestInput<Model, Questions>): EvaluationRequestFor<EvaluationModelOptions<Model>, Questions>;
+export declare function request(input: EvaluationRequest): EvaluationRequest;
+export declare function evaluate<const Model extends object, const Questions extends EvaluationQuestions>(input: EvaluationRequestInput<Model, Questions>): Effect.Effect<EvaluationResponseFor<Questions>, AIError, Service>;
+export declare function evaluate(input: EvaluationRequest): Effect.Effect<EvaluationResponse, AIError, Service>;
+export declare const Evaluation: {
+    readonly request: typeof request;
+    readonly evaluate: typeof evaluate;
+};
+export {};

package/dist/experimental/evaluation.js

@@ -0,0 +1,114 @@
+import { Effect, Schema } from "effect";
+import { AIError, HttpOptions, InvalidRequestError, ModelID, ProviderID, ProviderMetadata, Usage, } from "../schema/index.js";
+import { EvaluationClient, Service } from "./evaluation-client.js";
+export const EvaluationInput = Schema.Union([Schema.String, Schema.JsonObject, Schema.Array(Schema.Json)]);
+const EvaluationCriterion = Schema.NullOr(EvaluationInput);
+const ChoiceCriteria = Schema.Record(Schema.String, EvaluationCriterion).pipe(Schema.refine((x) => Object.keys(x).length > 0, {
+    message: "Choice criteria must be a nonempty option map",
+}));
+export const ChoiceQuestion = Schema.Struct({
+    type: Schema.Literal("choice"),
+    instructions: EvaluationInput,
+    criteria: ChoiceCriteria,
+});
+export const ScoreQuestion = Schema.Struct({
+    type: Schema.Literal("score"),
+    instructions: EvaluationInput,
+    criteria: Schema.Array(EvaluationCriterion).check(Schema.isMinLength(2)),
+});
+export const BooleanQuestion = Schema.Struct({
+    type: Schema.Literal("boolean"),
+    instructions: EvaluationInput,
+    criteria: Schema.optional(Schema.Struct({
+        true: Schema.optional(EvaluationCriterion),
+        false: Schema.optional(EvaluationCriterion),
+    })),
+});
+export const EvaluationQuestion = Schema.Union([ChoiceQuestion, ScoreQuestion, BooleanQuestion]).pipe(Schema.toTaggedUnion("type"));
+const EvaluationQuestions = Schema.Record(Schema.String, EvaluationQuestion).pipe(Schema.refine((x) => Object.keys(x).length > 0, {
+    message: "Evaluation questions must be a nonempty map",
+}));
+const Probability = Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 1 }));
+export const ChoiceAnswer = Schema.Struct({
+    type: Schema.Literal("choice"),
+    choice: Schema.String,
+    probabilities: Schema.optional(Schema.Record(Schema.String, Probability)),
+});
+export const ScoreAnswer = Schema.Struct({
+    type: Schema.Literal("score"),
+    score: Schema.Number,
+    probabilities: Schema.optional(Schema.Record(Schema.String, Probability)),
+});
+export const BooleanAnswer = Schema.Struct({
+    type: Schema.Literal("boolean"),
+    probability: Probability,
+});
+export const EvaluationAnswer = Schema.Union([ChoiceAnswer, ScoreAnswer, BooleanAnswer]).pipe(Schema.toTaggedUnion("type"));
+export class EvaluationModel {
+    id;
+    provider;
+    route;
+    http;
+    constructor(input) {
+        this.id = input.id;
+        this.provider = input.provider;
+        this.route = input.route;
+        this.http = input.http;
+    }
+    static make(input) {
+        return new EvaluationModel({
+            id: ModelID.make(input.id),
+            provider: ProviderID.make(input.provider),
+            route: input.route,
+            http: input.http,
+        });
+    }
+}
+export const EvaluationModelSchema = Schema.declare((value) => value instanceof EvaluationModel, {
+    expected: "Evaluation.Model",
+});
+export class EvaluationRequest extends Schema.Class("Evaluation.Request")({
+    model: EvaluationModelSchema,
+    state: EvaluationInput,
+    questions: EvaluationQuestions,
+    options: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    http: Schema.optional(HttpOptions),
+}) {
+}
+export class EvaluationRounding extends Schema.Class("Evaluation.Rounding")({
+    probabilityDecimals: Schema.optional(Schema.Int),
+    scoreDecimals: Schema.optional(Schema.Int),
+}) {
+}
+export class EvaluationResponse extends Schema.Class("Evaluation.Response")({
+    model: ModelID,
+    answers: Schema.Record(Schema.String, EvaluationAnswer),
+    usage: Schema.optional(Usage),
+    rounding: Schema.optional(EvaluationRounding),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}) {
+}
+export function request(input) {
+    if (input instanceof EvaluationRequest)
+        return input;
+    return new EvaluationRequest({
+        ...input,
+        model: input.model,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+}
+export function evaluate(input) {
+    return Effect.try({
+        try: () => (input instanceof EvaluationRequest ? input : request(input)),
+        catch: (cause) => new AIError({
+            reason: new InvalidRequestError({
+                message: cause instanceof Error ? cause.message : String(cause),
+                cause,
+            }),
+        }),
+    }).pipe(Effect.flatMap((request) => EvaluationClient.evaluate(request)));
+}
+export const Evaluation = {
+    request,
+    evaluate,
+};

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

@@ -0,0 +1,16 @@
+import { EvaluationModel } from "./evaluation.js";
+import { type Definition as AuthDefinition } from "../route/auth.js";
+import { HttpOptions, ModelID } from "../schema/index.js";
+export interface ModelInput {
+    readonly id: string | ModelID;
+    readonly provider: string;
+    readonly providerMetadataKey: string;
+    readonly auth: AuthDefinition;
+    readonly baseURL: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions;
+}
+export declare const model: (cfg: ModelInput) => EvaluationModel<import("./evaluation.js").EvaluationOptions>;
+export declare const SystemOne: {
+    readonly model: (cfg: ModelInput) => EvaluationModel<import("./evaluation.js").EvaluationOptions>;
+};

package/dist/experimental/system-one.js

@@ -0,0 +1,143 @@
+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 { Auth } from "../route/auth.js";
+import { AIError, HttpContext, HttpOptions, InvalidProviderOutputError, InvalidRequestError, ModelID, Usage, mergeJsonRecords, } from "../schema/index.js";
+const Noul = Schema.Struct({
+    type: Schema.Literal("noul"),
+    instructions: EvaluationInput,
+    criteria: Schema.optional(Schema.Struct({
+        true: Schema.optional(Schema.NullOr(EvaluationInput)),
+        false: Schema.optional(Schema.NullOr(EvaluationInput)),
+    })),
+});
+const Question = Schema.Union([
+    ChoiceQuestion.pipe(Schema.refine((x) => Object.keys(x.criteria).length <= 255, {
+        message: "System One Choice questions support at most 255 options",
+    })),
+    ScoreQuestion.pipe(Schema.refine((x) => x.criteria.length <= 10, {
+        message: "System One Score questions support at most 10 levels",
+    })),
+    Noul,
+]);
+const Request = Schema.StructWithRest(Schema.Struct({
+    model: Schema.String,
+    state: EvaluationInput,
+    questions: Schema.Record(Schema.String, Question),
+}), [Schema.Record(Schema.String, Schema.Any)]);
+const Probability = Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 1 }));
+const NoulAnswer = Schema.Struct({ type: Schema.Literal("noul"), noul: Probability });
+const Choice = Schema.Struct({
+    type: Schema.Literal("choice"),
+    choice: Schema.String,
+    probabilities: Schema.Record(Schema.String, Probability),
+    confidence: Schema.optional(Probability),
+});
+const Score = Schema.Struct({
+    type: Schema.Literal("score"),
+    score: Schema.Number,
+    probabilities: Schema.Record(Schema.String, Probability),
+    legend: Schema.optional(Schema.Record(Schema.String, Schema.Json)),
+    confidence: Schema.optional(Probability),
+});
+const NativeUsage = Schema.Struct({
+    input_tokens: Schema.optional(Schema.Number),
+    output_tokens: Schema.optional(Schema.Number),
+});
+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 = {
+        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({
+                ...mergeJsonRecords(req.options, req.http?.body),
+                model: req.model.id,
+                state: req.state,
+                questions: Object.fromEntries(Object.entries(req.questions).map(([id, x]) => [id, x.type === "boolean" ? { ...x, type: "noul" } : x])),
+            }).pipe(Effect.mapError((cause) => new AIError({ reason: new InvalidRequestError({ message: cause.message, cause }) })));
+            const headers = yield* Auth.toEffect(cfg.auth)({
+                request: req,
+                method: "POST",
+                url: url.toString(),
+                body,
+                headers: Headers.fromInput({ ...cfg.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: route.id, 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 confidence = {};
+            const legend = {};
+            const answers = Object.fromEntries(entries.map(([id, question]) => {
+                const answer = data.answers[id];
+                if (question.type === "boolean")
+                    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 },
+                    ];
+                }
+                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 }];
+            }));
+            const meta = {
+                ...(Object.keys(confidence).length === 0 ? {} : { confidence }),
+                ...(Object.keys(legend).length === 0 ? {} : { legend }),
+            };
+            return new EvaluationResponse({
+                model: ModelID.make(data.model),
+                answers,
+                usage: data.usage
+                    ? new Usage({
+                        inputTokens: data.usage.input_tokens,
+                        outputTokens: data.usage.output_tokens,
+                        totalTokens: data.usage.input_tokens === undefined && data.usage.output_tokens === undefined
+                            ? undefined
+                            : (data.usage.input_tokens ?? 0) + (data.usage.output_tokens ?? 0),
+                        providerMetadata: { [cfg.providerMetadataKey]: data.usage },
+                    })
+                    : undefined,
+                rounding: new EvaluationRounding({ probabilityDecimals: 2, scoreDecimals: 2 }),
+                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/experimental.d.ts

@@ -0,0 +1,3 @@
+export { EvaluationClient } from "./experimental/evaluation-client.js";
+export { BooleanAnswer, BooleanQuestion, ChoiceAnswer, ChoiceQuestion, Evaluation, EvaluationAnswer, EvaluationInput, EvaluationModel, EvaluationModelSchema, EvaluationQuestion, EvaluationRequest, EvaluationResponse, EvaluationRounding, ScoreAnswer, ScoreQuestion, } from "./experimental/evaluation.js";
+export type { AnswerFor, AnswersFor, EvaluationModelOptions, EvaluationOptions, EvaluationQuestions, EvaluationRequestFor, EvaluationRequestInput, EvaluationResponseFor, EvaluationRoute, } from "./experimental/evaluation.js";

package/dist/experimental.js

@@ -0,0 +1,2 @@
+export { EvaluationClient } from "./experimental/evaluation-client.js";
+export { BooleanAnswer, BooleanQuestion, ChoiceAnswer, ChoiceQuestion, Evaluation, EvaluationAnswer, EvaluationInput, EvaluationModel, EvaluationModelSchema, EvaluationQuestion, EvaluationRequest, EvaluationResponse, EvaluationRounding, ScoreAnswer, ScoreQuestion, } from "./experimental/evaluation.js";

package/dist/providers/google-vertex.js

@@ -10,23 +10,11 @@ import { GoogleVertexShared } from "./google-vertex-shared.js";
 export const id = ProviderID.make("google-vertex");
 const fromRequest = Effect.fn("GoogleVertex.fromRequest")(function* (request) {
     const { serviceTier: _, ...body } = yield* Gemini.protocol.body.from(request);
-    // Vertex's native REST schema rejects `id` on FunctionCall/FunctionResponse parts with HTTP 400,
-    // unlike AI Studio, so history minted there cannot be lowered verbatim.
-    const contents = body.contents.map((content) => ({
-        ...content,
-        parts: (content.parts ?? []).map((part) => {
-            if ("functionCall" in part)
-                return { ...part, functionCall: { ...part.functionCall, id: undefined } };
-            if ("functionResponse" in part)
-                return { ...part, functionResponse: { ...part.functionResponse, id: undefined } };
-            return part;
-        }),
-    }));
     const value = request.providerOptions?.labels;
     const labels = ProviderShared.isRecord(value)
         ? Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"))
         : undefined;
-    return { ...body, contents, labels };
+    return { ...body, labels };
 });
 const protocol = {
     ...Gemini.protocol,

package/dist/providers/index.d.ts

@@ -24,8 +24,10 @@ export * as Moonshot from "./moonshot.js";
 export * as OpenAI from "./openai.js";
 export * as OpenAICompatible from "./openai-compatible.js";
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";
+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 XAI from "./xai.js";
 export * as ZAI from "./zai.js";
 export * as ZAICodingPlan from "./zai-coding-plan.js";

package/dist/providers/index.js

@@ -24,8 +24,10 @@ export * as Moonshot from "./moonshot.js";
 export * as OpenAI from "./openai.js";
 export * as OpenAICompatible from "./openai-compatible.js";
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";
+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 XAI from "./xai.js";
 export * as ZAI from "./zai.js";
 export * as ZAICodingPlan from "./zai-coding-plan.js";

package/dist/providers/opencode-zen.d.ts

@@ -0,0 +1,32 @@
+import { HttpOptions, type ModelID } from "../schema/index.js";
+import { type ProviderAuthOption } from "../route/auth-options.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+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) => import("../experimental.js").EvaluationModel<import("../experimental.js").EvaluationOptions>;
+    };
+    configure: (input?: Options) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    experimental: {
+        evaluation: (modelID: string | ModelID) => import("../experimental.js").EvaluationModel<import("../experimental.js").EvaluationOptions>;
+    };
+    configure: (input?: Options) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        experimental: {
+            evaluation: (modelID: string | ModelID) => import("../experimental.js").EvaluationModel<import("../experimental.js").EvaluationOptions>;
+        };
+        configure: /*elided*/ any;
+    };
+};
+export declare const experimental: {
+    evaluation: (modelID: string | ModelID) => import("../experimental.js").EvaluationModel<import("../experimental.js").EvaluationOptions>;
+};
+export * as OpenCodeZen from "./opencode-zen.js";

package/dist/providers/opencode-zen.js

@@ -0,0 +1,20 @@
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { AuthOptions } from "../route/auth-options.js";
+import { SystemOne } from "../experimental/system-one.js";
+export const id = ProviderID.make("opencode");
+const baseURL = "https://opencode.ai/zen/v1";
+export const configure = (input = {}) => {
+    const evaluation = (modelID) => SystemOne.model({
+        id: modelID,
+        provider: id,
+        providerMetadataKey: "opencode",
+        auth: AuthOptions.bearer(input, "OPENCODE_API_KEY"),
+        baseURL: input.baseURL ?? baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+    return { id, experimental: { evaluation }, configure };
+};
+export const provider = configure();
+export const experimental = provider.experimental;
+export * as OpenCodeZen from "./opencode-zen.js";

package/dist/providers/typesafe-ai.d.ts

@@ -0,0 +1,32 @@
+import { HttpOptions, type ModelID } from "../schema/index.js";
+import { type ProviderAuthOption } from "../route/auth-options.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+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) => import("../experimental.js").EvaluationModel<import("../experimental.js").EvaluationOptions>;
+    };
+    configure: (input?: Options) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    experimental: {
+        evaluation: (modelID: string | ModelID) => import("../experimental.js").EvaluationModel<import("../experimental.js").EvaluationOptions>;
+    };
+    configure: (input?: Options) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        experimental: {
+            evaluation: (modelID: string | ModelID) => import("../experimental.js").EvaluationModel<import("../experimental.js").EvaluationOptions>;
+        };
+        configure: /*elided*/ any;
+    };
+};
+export declare const experimental: {
+    evaluation: (modelID: string | ModelID) => import("../experimental.js").EvaluationModel<import("../experimental.js").EvaluationOptions>;
+};
+export * as TypeSafeAI from "./typesafe-ai.js";

package/dist/providers/typesafe-ai.js

@@ -0,0 +1,20 @@
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { AuthOptions } from "../route/auth-options.js";
+import { SystemOne } from "../experimental/system-one.js";
+export const id = ProviderID.make("typesafe-ai");
+const baseURL = "https://api.typesafe.ai/v1";
+export const configure = (input = {}) => {
+    const evaluation = (modelID) => SystemOne.model({
+        id: modelID,
+        provider: id,
+        providerMetadataKey: "typesafe",
+        auth: AuthOptions.bearer(input, "TYPESAFE_API_KEY"),
+        baseURL: input.baseURL ?? baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+    return { id, experimental: { evaluation }, configure };
+};
+export const provider = configure();
+export const experimental = provider.experimental;
+export * as TypeSafeAI from "./typesafe-ai.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.11",
+  "version": "2.0.13",
   "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": "2.0.11",
+    "@opencode/http-recorder": "2.0.13",
     "@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": "2.0.11",
+    "@opencode/schema": "2.0.13",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"