@opencode/ai 0.0.0-reserved → 2.0.0

package/dist/protocols/utils/partial-json.js

@@ -0,0 +1,279 @@
+/*
+ * Adapted from partial-json by the Promplate Dev Team:
+ * https://github.com/promplate/partial-json-parser-js
+ *
+ * MIT License
+ *
+ * Copyright (c) 2023 Promplate Dev Team
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { Schema } from "effect";
+import { Allow } from "./partial-json-options.js";
+export * from "./partial-json-options.js";
+export class PartialJSON extends Error {
+}
+export class MalformedJSON extends Error {
+}
+const decodeJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
+/** Parse complete or incomplete JSON, restricted by the supplied partial-value flags. */
+export function parseJSON(jsonString, allowPartial = Allow.ALL) {
+    if (typeof jsonString !== "string")
+        throw new TypeError(`expecting str, got ${typeof jsonString}`);
+    const input = jsonString.trim();
+    if (!input)
+        throw new Error(`${jsonString} is empty`);
+    try {
+        return decodeJson(input);
+    }
+    catch { }
+    const repaired = repairJSON(input);
+    if (repaired !== input) {
+        try {
+            return decodeJson(repaired);
+        }
+        catch { }
+    }
+    try {
+        return _parseJSON(input, allowPartial);
+    }
+    catch (error) {
+        if (repaired !== input)
+            return _parseJSON(repaired, allowPartial);
+        throw error;
+    }
+}
+const repairJSON = (input) => {
+    let repaired = "";
+    let quoted = false;
+    for (let index = 0; index < input.length; index++) {
+        const character = input[index];
+        if (!quoted) {
+            repaired += character;
+            if (character === '"')
+                quoted = true;
+            continue;
+        }
+        if (character === '"') {
+            repaired += character;
+            quoted = false;
+            continue;
+        }
+        if (character === "\\") {
+            const next = input[index + 1];
+            if (next === "u" && /^[0-9a-fA-F]{4}$/.test(input.slice(index + 2, index + 6))) {
+                repaired += input.slice(index, index + 6);
+                index += 5;
+                continue;
+            }
+            if (next !== undefined && '"\\/bfnrtu'.includes(next)) {
+                repaired += `\\${next}`;
+                index++;
+                continue;
+            }
+            repaired += "\\\\";
+            continue;
+        }
+        const code = character.charCodeAt(0);
+        repaired += code <= 0x1f ? `\\u${code.toString(16).padStart(4, "0")}` : character;
+    }
+    return repaired;
+};
+const _parseJSON = (jsonString, allow) => {
+    const length = jsonString.length;
+    let index = 0;
+    const markPartialJSON = (message) => {
+        throw new PartialJSON(`${message} at position ${index}`);
+    };
+    const throwMalformedError = (message) => {
+        throw new MalformedJSON(`${message} at position ${index}`);
+    };
+    const parseAny = () => {
+        skipBlank();
+        if (index >= length)
+            markPartialJSON("Unexpected end of input");
+        if (jsonString[index] === '"')
+            return parseStr();
+        if (jsonString[index] === "{")
+            return parseObj();
+        if (jsonString[index] === "[")
+            return parseArr();
+        if (jsonString.substring(index, index + 4) === "null" ||
+            (Allow.NULL & allow && length - index < 4 && "null".startsWith(jsonString.substring(index)))) {
+            index += 4;
+            return null;
+        }
+        if (jsonString.substring(index, index + 4) === "true" ||
+            (Allow.BOOL & allow && length - index < 4 && "true".startsWith(jsonString.substring(index)))) {
+            index += 4;
+            return true;
+        }
+        if (jsonString.substring(index, index + 5) === "false" ||
+            (Allow.BOOL & allow && length - index < 5 && "false".startsWith(jsonString.substring(index)))) {
+            index += 5;
+            return false;
+        }
+        if (jsonString.substring(index, index + 8) === "Infinity" ||
+            (Allow.INFINITY & allow && length - index < 8 && "Infinity".startsWith(jsonString.substring(index)))) {
+            index += 8;
+            return Infinity;
+        }
+        if (jsonString.substring(index, index + 9) === "-Infinity" ||
+            (Allow._INFINITY & allow &&
+                1 < length - index &&
+                length - index < 9 &&
+                "-Infinity".startsWith(jsonString.substring(index)))) {
+            index += 9;
+            return -Infinity;
+        }
+        if (jsonString.substring(index, index + 3) === "NaN" ||
+            (Allow.NAN & allow && length - index < 3 && "NaN".startsWith(jsonString.substring(index)))) {
+            index += 3;
+            return NaN;
+        }
+        return parseNum();
+    };
+    const parseStr = () => {
+        const start = index;
+        let escape = false;
+        index++;
+        while (index < length && (jsonString[index] !== '"' || (escape && jsonString[index - 1] === "\\"))) {
+            escape = jsonString[index] === "\\" ? !escape : false;
+            index++;
+        }
+        if (jsonString.charAt(index) === '"') {
+            try {
+                return decodeJson(jsonString.substring(start, ++index - Number(escape)));
+            }
+            catch (error) {
+                throwMalformedError(String(error));
+            }
+        }
+        if (Allow.STR & allow) {
+            try {
+                return decodeJson(`${jsonString.substring(start, index - Number(escape))}"`);
+            }
+            catch {
+                return decodeJson(`${jsonString.substring(start, jsonString.lastIndexOf("\\"))}"`);
+            }
+        }
+        return markPartialJSON("Unterminated string literal");
+    };
+    const parseObj = () => {
+        index++;
+        skipBlank();
+        const object = {};
+        try {
+            while (jsonString[index] !== "}") {
+                skipBlank();
+                if (index >= length && Allow.OBJ & allow)
+                    return object;
+                const key = parseStr();
+                skipBlank();
+                index++;
+                try {
+                    Object.defineProperty(object, key, {
+                        value: parseAny(),
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                    });
+                }
+                catch (error) {
+                    if (Allow.OBJ & allow)
+                        return object;
+                    throw error;
+                }
+                skipBlank();
+                if (jsonString[index] === ",")
+                    index++;
+            }
+        }
+        catch {
+            if (Allow.OBJ & allow)
+                return object;
+            return markPartialJSON("Expected '}' at end of object");
+        }
+        index++;
+        return object;
+    };
+    const parseArr = () => {
+        index++;
+        const array = [];
+        try {
+            while (jsonString[index] !== "]") {
+                array.push(parseAny());
+                skipBlank();
+                if (jsonString[index] === ",")
+                    index++;
+            }
+        }
+        catch {
+            if (Allow.ARR & allow)
+                return array;
+            return markPartialJSON("Expected ']' at end of array");
+        }
+        index++;
+        return array;
+    };
+    const parseNum = () => {
+        if (index === 0) {
+            if (jsonString === "-")
+                throwMalformedError("Not sure what '-' is");
+            try {
+                return decodeJson(jsonString);
+            }
+            catch (error) {
+                if (Allow.NUM & allow) {
+                    try {
+                        return decodeJson(jsonString.substring(0, jsonString.lastIndexOf("e")));
+                    }
+                    catch { }
+                }
+                throwMalformedError(String(error));
+            }
+        }
+        const start = index;
+        if (jsonString[index] === "-")
+            index++;
+        while (jsonString[index] && !",]}".includes(jsonString[index]))
+            index++;
+        if (index === length && !(Allow.NUM & allow))
+            markPartialJSON("Unterminated number literal");
+        try {
+            return decodeJson(jsonString.substring(start, index));
+        }
+        catch (error) {
+            if (jsonString.substring(start, index) === "-")
+                markPartialJSON("Not sure what '-' is");
+            try {
+                return decodeJson(jsonString.substring(start, jsonString.lastIndexOf("e")));
+            }
+            catch {
+                throwMalformedError(String(error));
+            }
+        }
+    };
+    const skipBlank = () => {
+        while (index < length && " \n\r\t".includes(jsonString[index]))
+            index++;
+    };
+    return parseAny();
+};
+export const parse = parseJSON;

package/dist/protocols/utils/responses-checkpoint.d.ts

@@ -0,0 +1,4 @@
+import { type RouteBody, type TriggerCompactOperation } from "../../route/client.js";
+/** Collect a trigger response before acknowledging transport completion. No generation output escapes. */
+export declare const make: <Body>(body: RouteBody<Body>) => TriggerCompactOperation;
+export * as ResponsesCheckpoint from "./responses-checkpoint.js";

package/dist/protocols/utils/responses-checkpoint.js

@@ -0,0 +1,107 @@
+import { Effect, Schema, Stream } from "effect";
+import { Route } from "../../route/client.js";
+import { Protocol } from "../../route/protocol.js";
+import { CompactionCheckpointResponse, HttpOptions, LLMEvent, LLMRequest } from "../../schema/index.js";
+import { OpenResponses } from "../open-responses.js";
+import { ProviderShared } from "../shared.js";
+const onOutputItem = Effect.fn("ResponsesCheckpoint.onOutputItem")(function* (state, input) {
+    const event = OpenResponses.normalize(state.parser, input);
+    const item = event.item;
+    if (!item)
+        return state;
+    const parser = event.output_index === undefined || state.parser.outputItems[event.output_index] === item.id
+        ? state.parser
+        : { ...state.parser, outputItems: { ...state.parser.outputItems, [event.output_index]: item.id } };
+    const next = parser === state.parser ? state : { ...state, parser };
+    if (event.type === "response.output_item.added" || item.type !== "compaction")
+        return next;
+    if (event.output_index !== undefined &&
+        Object.entries(state.parser.outputItems).some(([index, id]) => id === item.id && Number(index) !== event.output_index))
+        return yield* ProviderShared.eventError(parser.id, "Compaction checkpoint appeared in multiple output slots");
+    if (!item.encrypted_content)
+        return yield* ProviderShared.eventError(parser.id, "Compaction output is missing its encrypted content");
+    const previous = state.checkpoints[item.id];
+    if (previous && previous.encrypted !== item.encrypted_content)
+        return yield* ProviderShared.eventError(parser.id, "Compaction output changed after completion");
+    if (previous)
+        return next;
+    return {
+        ...next,
+        checkpoints: {
+            ...state.checkpoints,
+            [item.id]: { type: "compaction", provider: parser.provider, id: item.id, encrypted: item.encrypted_content },
+        },
+    };
+});
+/** Collect a trigger response before acknowledging transport completion. No generation output escapes. */
+export const make = (body) => Effect.fn("ResponsesCheckpoint.execute")(function* (request, executor, options) {
+    const source = request.model.route;
+    let result;
+    // Route registries erase the frame type. The codec validates that boundary before parsing.
+    const event = OpenResponses.protocol.stream.event;
+    const protocol = Protocol.make({
+        id: source.protocol,
+        body,
+        stream: {
+            event,
+            initial: (request) => ({
+                parser: { id: source.id, provider: request.model.provider, outputItems: {} },
+                checkpoints: {},
+            }),
+            terminal: OpenResponses.terminal,
+            step: Effect.fn("ResponsesCheckpoint.step")(function* (state, event) {
+                if (event.response?.id && state.responseID && event.response.id !== state.responseID)
+                    return yield* ProviderShared.eventError(source.id, "Compaction response ID changed during execution");
+                if (event.type === "response.created")
+                    return [{ ...state, responseID: event.response?.id }, []];
+                if (event.type === "error" || event.type === "response.failed")
+                    return yield* OpenResponses.providerFailure(event, "Compaction request failed");
+                if (event.type === "response.incomplete")
+                    return yield* ProviderShared.eventError(source.id, "Compaction response was incomplete");
+                if (event.type === "response.output_item.added" || event.type === "response.output_item.done")
+                    return [yield* onOutputItem(state, event), []];
+                if (event.type !== "response.completed")
+                    return [state, []];
+                const responseID = event.response?.id;
+                if (!responseID?.trim())
+                    return yield* ProviderShared.eventError(source.id, "Compaction response is missing its response ID");
+                if (event.response?.status !== undefined && event.response.status !== "completed")
+                    return yield* ProviderShared.eventError(source.id, "Compaction response did not complete successfully");
+                let next = state;
+                for (const [index, item] of (event.response?.output ?? []).entries()) {
+                    next = yield* onOutputItem(next, { type: "response.output_item.done", output_index: index, item });
+                }
+                const checkpoints = Object.values(next.checkpoints);
+                const checkpoint = checkpoints[0];
+                if (checkpoints.length !== 1 || !checkpoint)
+                    return yield* ProviderShared.eventError(source.id, "Compaction response must contain exactly one checkpoint");
+                result = new CompactionCheckpointResponse({
+                    checkpoint,
+                    responseID,
+                    usage: OpenResponses.mapUsage(event.response?.usage, OpenResponses.metadataKey(request.model)),
+                });
+                return [next, [LLMEvent.finish({ reason: { normalized: "stop" } })]];
+            }),
+        },
+    });
+    const route = Route.make({
+        id: source.id,
+        provider: source.provider,
+        providerMetadataKey: source.providerMetadataKey,
+        protocol,
+        endpoint: source.endpoint,
+        auth: source.auth,
+        transport: source.transport,
+    });
+    const native = yield* body.from(request);
+    // The body builder already applied and validated overlays. Do not let transport reapply them.
+    const preparedRequest = LLMRequest.update(request, {
+        http: request.http === undefined ? undefined : new HttpOptions({ ...request.http, body: undefined }),
+    });
+    const prepared = yield* route.prepareTransport(native, preparedRequest, options);
+    yield* route.streamPrepared(prepared, preparedRequest, { http: executor }, options).pipe(Stream.runDrain);
+    if (!result)
+        return yield* ProviderShared.eventError(source.id, "Compaction response ended without a checkpoint");
+    return result;
+});
+export * as ResponsesCheckpoint from "./responses-checkpoint.js";

package/dist/protocols/utils/responses-compaction.d.ts

@@ -0,0 +1,4 @@
+import type { CompactOperation } from "../../route/client.js";
+import { OpenResponses } from "../open-responses.js";
+export declare const make: (adapter: OpenResponses.ProviderAdapter) => CompactOperation;
+export * as ResponsesCompaction from "./responses-compaction.js";

package/dist/protocols/utils/responses-compaction.js

@@ -0,0 +1,129 @@
+import { Effect, Schema, Stream } from "effect";
+import { AIError, InvalidProviderOutputError, CompactionPart, CompactionResponse, HttpOptions, LLMRequest, Message, mergeJsonRecords, } from "../../schema/index.js";
+import { Endpoint } from "../../route/endpoint.js";
+import { RequestExecutor } from "../../route/executor.js";
+import { HttpTransport } from "../../route/transport/index.js";
+import { OpenResponses } from "../open-responses.js";
+import { JsonObject, optionalNull, ProviderShared } from "../shared.js";
+const Body = Schema.Struct({
+    model: Schema.String,
+    input: Schema.Array(Schema.Unknown),
+    instructions: optionalNull(Schema.String),
+    previous_response_id: optionalNull(Schema.String),
+    service_tier: optionalNull(Schema.String),
+    prompt_cache_key: optionalNull(Schema.String),
+    prompt_cache_retention: optionalNull(Schema.String),
+    prompt_cache_options: optionalNull(Schema.Struct({ mode: Schema.optional(Schema.String), ttl: Schema.optional(Schema.String) })),
+});
+const Text = Schema.Union([OpenResponses.OpenResponsesInputText, OpenResponses.OpenResponsesOutputText]);
+const File = Schema.Union([
+    Schema.Struct({
+        ...OpenResponses.OpenResponsesInputFile.fields,
+        file_url: Schema.String,
+        file_data: Schema.optional(Schema.Never),
+    }),
+    Schema.Struct({
+        ...OpenResponses.OpenResponsesInputFile.fields,
+        file_data: Schema.String,
+        file_url: Schema.optional(Schema.Never),
+    }),
+]);
+const MessageFields = {
+    type: Schema.Literal("message"),
+    id: Schema.optional(Schema.String),
+    status: Schema.optional(Schema.String),
+    phase: Schema.optional(OpenResponses.MessagePhase),
+};
+const Response = Schema.Struct({
+    object: Schema.Literal("response.compaction"),
+    output: Schema.Array(Schema.Union([
+        OpenResponses.CompactionItem,
+        OpenResponses.OpenResponsesReasoningItem,
+        Schema.Struct({
+            ...MessageFields,
+            role: Schema.Literal("user"),
+            content: Schema.Array(Schema.Union([Text, OpenResponses.OpenResponsesInputImage, File])).check(Schema.isMinLength(1)),
+        }),
+        Schema.Struct({
+            ...MessageFields,
+            role: Schema.Literal("assistant"),
+            content: Schema.Array(Text).check(Schema.isMinLength(1)),
+        }),
+    ])),
+    usage: Schema.optional(Schema.StructWithRest(OpenResponses.OpenResponsesUsage, [JsonObject])),
+});
+export const make = (adapter) => Effect.fn("ResponsesCompaction.execute")(function* (request, executor, options) {
+    const route = request.model.route;
+    const native = yield* OpenResponses.lowerConversation(request, adapter);
+    const body = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(mergeJsonRecords({
+        ...native,
+        service_tier: request.providerOptions?.serviceTier,
+        prompt_cache_key: ProviderShared.promptCacheKey(request),
+    }, request.http?.body));
+    const url = Endpoint.render(route.endpoint, { request, body: native });
+    url.pathname = `${url.pathname.replace(/\/$/, "")}/compact`;
+    const parts = yield* HttpTransport.jsonRequestParts({
+        request: LLMRequest.update(request, {
+            http: request.http === undefined ? undefined : new HttpOptions({ ...request.http, body: undefined }),
+        }),
+        body,
+        endpoint: Endpoint.path(url.toString()),
+        auth: route.auth,
+        encodeBody: Schema.encodeSync(Schema.fromJsonString(Body)),
+    });
+    const response = yield* executor.execute(ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }), options?.http);
+    const text = yield* RequestExecutor.responseStream(response).pipe(Stream.decodeText(), Stream.runFold(() => "", (text, chunk) => text + chunk));
+    const invalid = (message, cause) => new AIError({
+        reason: new InvalidProviderOutputError({
+            route: route.id,
+            message,
+            body: text,
+            cause,
+            http: RequestExecutor.responseHttp(response),
+        }),
+    });
+    const result = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(Effect.mapError((cause) => invalid("Invalid compaction response", cause)));
+    if (!result.output.some((item) => item.type === "compaction"))
+        return yield* invalid("Compaction response did not contain a checkpoint");
+    return new CompactionResponse({
+        replacement: result.output.map((item) => toMessage(item, request.model)),
+        usage: OpenResponses.mapUsage(result.usage, OpenResponses.metadataKey(request.model)),
+    });
+});
+function toMessage(item, model) {
+    if (item.type === "compaction")
+        return Message.assistant(CompactionPart.make({ provider: model.provider, id: item.id ?? undefined, encrypted: item.encrypted_content }));
+    const key = OpenResponses.metadataKey(model);
+    if (item.type === "reasoning") {
+        const summary = item.summary.length ? item.summary : [{ text: "" }];
+        return Message.assistant(summary.map((part) => ({
+            type: "reasoning",
+            text: part.text,
+            providerMetadata: { [key]: { itemId: item.id, reasoningEncryptedContent: item.encrypted_content } },
+        })));
+    }
+    return Message.make({
+        role: item.role,
+        providerMetadata: { [key]: { itemId: item.id, type: item.type, status: item.status, phase: item.phase } },
+        content: item.content.map((part) => {
+            if (part.type === "input_text" || part.type === "output_text")
+                return { type: "text", text: part.text };
+            if (part.type === "input_image")
+                return {
+                    type: "media",
+                    data: part.image_url,
+                    mediaType: /^data:([^;,]+)/.exec(part.image_url)?.[1] ?? "image/*",
+                    providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
+                };
+            const data = part.file_url === undefined ? part.file_data : part.file_url;
+            return {
+                type: "media",
+                data,
+                filename: part.filename,
+                mediaType: /^data:([^;,]+)/.exec(data)?.[1] ?? "application/octet-stream",
+                providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
+            };
+        }),
+    });
+}
+export * as ResponsesCompaction from "./responses-compaction.js";

package/dist/protocols/utils/responses-hosted-tools.d.ts

@@ -0,0 +1,26 @@
+import { Effect } from "effect";
+import { type AIError, type ToolResultPart } from "../../schema/index.js";
+import { OpenResponses } from "../open-responses.js";
+export type Item = OpenResponses.OutputItem & {
+    readonly status?: string;
+    readonly action?: unknown;
+    readonly queries?: unknown;
+    readonly results?: unknown;
+    readonly code?: string;
+    readonly container_id?: string;
+    readonly outputs?: unknown;
+    readonly server_label?: string;
+    readonly output?: unknown;
+    readonly result?: string;
+    readonly output_format?: "png" | "jpeg" | "webp";
+    readonly error?: unknown;
+};
+export interface Definition {
+    readonly name: string;
+    readonly input: (item: Item) => unknown;
+    readonly result?: (item: Item) => Effect.Effect<ToolResultPart["result"], AIError>;
+}
+export type Definitions = Readonly<Record<string, Definition>>;
+export declare const isItem: <Tools extends Definitions>(item: OpenResponses.OutputItem, tools: Tools) => item is Item;
+export declare const onDone: (state: OpenResponses.ParserState, item: Item, tools: Definitions) => Effect.Effect<OpenResponses.StepResult, AIError>;
+export * as ResponsesHostedTools from "./responses-hosted-tools.js";

package/dist/protocols/utils/responses-hosted-tools.js

@@ -0,0 +1,32 @@
+import { Effect } from "effect";
+import { LLMEvent } from "../../schema/index.js";
+import { OpenResponses } from "../open-responses.js";
+import { Lifecycle } from "./lifecycle.js";
+export const isItem = (item, tools) => item.type in tools;
+export const onDone = Effect.fn("ResponsesHostedTools.onDone")(function* (state, item, tools) {
+    const tool = tools[item.type];
+    if (!tool)
+        return [state, []];
+    const providerMetadata = OpenResponses.providerMetadata(state, { itemId: item.id });
+    const events = [];
+    const lifecycle = Lifecycle.stepStart(state.lifecycle, events);
+    events.push(LLMEvent.toolCall({
+        id: item.id,
+        name: tool.name,
+        input: tool.input(item),
+        providerExecuted: true,
+        providerMetadata,
+    }), LLMEvent.toolResult({
+        id: item.id,
+        name: tool.name,
+        result: tool.result
+            ? yield* tool.result(item)
+            : item.error !== undefined && item.error !== null
+                ? { type: "error", value: item.error }
+                : { type: "json", value: item },
+        providerExecuted: true,
+        providerMetadata,
+    }));
+    return [{ ...state, lifecycle }, events];
+});
+export * as ResponsesHostedTools from "./responses-hosted-tools.js";

package/dist/protocols/utils/tool-schema.d.ts

@@ -0,0 +1,8 @@
+import type { JsonSchema, LanguageModelToolSchemaCompatibility } from "../../schema/index.js";
+export declare const ToolSchemaProjection: {
+    readonly gemini: (schema: JsonSchema) => JsonSchema;
+    readonly modelCompatibility: (schema: JsonSchema, compatibility: LanguageModelToolSchemaCompatibility | undefined) => JsonSchema;
+    readonly moonshot: (schema: JsonSchema) => JsonSchema;
+    readonly openAI: (schema: JsonSchema) => JsonSchema;
+    readonly responses: (schema: JsonSchema) => JsonSchema;
+};

package/dist/protocols/utils/tool-schema.js

@@ -0,0 +1,54 @@
+import { isRecord } from "../../utils/record.js";
+import { GeminiToolSchema } from "./gemini-tool-schema.js";
+const tupleItemsSchema = (items) => {
+    const projected = items.map(moonshotNode);
+    if (projected.length === 0)
+        return {};
+    if (projected.length === 1)
+        return projected[0];
+    return { anyOf: projected };
+};
+const moonshotNode = (schema) => {
+    if (Array.isArray(schema))
+        return schema.map(moonshotNode);
+    if (!isRecord(schema))
+        return schema;
+    if (typeof schema.$ref === "string")
+        return { $ref: schema.$ref };
+    return Object.fromEntries(Object.entries(schema).flatMap(([key, value]) => {
+        if (key === "items" && Array.isArray(value))
+            return [[key, tupleItemsSchema(value)]];
+        if (key === "prefixItems") {
+            if ("items" in schema)
+                return [];
+            return [["items", tupleItemsSchema(Array.isArray(value) ? value : [])]];
+        }
+        if (key === "unevaluatedItems")
+            return [];
+        return [[key, moonshotNode(value)]];
+    }));
+};
+const moonshot = (schema) => {
+    const projected = moonshotNode(schema);
+    return isRecord(projected) ? projected : {};
+};
+const openAI = (schema) => schema;
+const responses = openAI;
+const gemini = (schema) => GeminiToolSchema.convert(schema) ?? {};
+const modelCompatibility = (schema, compatibility) => {
+    if (compatibility === undefined)
+        return schema;
+    switch (compatibility) {
+        case "gemini":
+            return gemini(schema);
+        case "moonshot":
+            return moonshot(schema);
+    }
+};
+export const ToolSchemaProjection = {
+    gemini,
+    modelCompatibility,
+    moonshot,
+    openAI,
+    responses,
+};