@opencode/ai 0.0.0-beta-19275

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

@@ -0,0 +1,155 @@
+import { Effect, Option } from "effect";
+import { AIError, LLMEvent } from "../../schema/index.js";
+import { eventError, parseToolInput } from "../shared.js";
+import { parse } from "./partial-json.js";
+const parsePartialInput = Option.liftThrowable(parse);
+/** Create empty accumulator state for one provider stream. */
+export const empty = () => ({});
+const withTool = (tools, key, tool) => {
+    return { ...tools, [key]: tool };
+};
+const withoutTool = (tools, key) => {
+    const next = { ...tools };
+    delete next[key];
+    return next;
+};
+const inputStart = (tool) => LLMEvent.toolInputStart({
+    id: tool.id,
+    name: tool.name,
+    namespace: tool.namespace,
+    providerExecuted: tool.providerExecuted ? true : undefined,
+    providerMetadata: tool.providerMetadata,
+});
+const inputDelta = (tool, text) => LLMEvent.toolInputDelta({
+    id: tool.id,
+    name: tool.name,
+    namespace: tool.namespace,
+    text,
+    input: Option.getOrElse(parsePartialInput(tool.input), () => ({})),
+});
+const toolCall = (route, tool, inputOverride) => {
+    const raw = inputOverride ?? tool.input;
+    return parseToolInput(route, tool.name, raw).pipe(Effect.catch((error) => tool.providerExecuted
+        ? Effect.fail(error)
+        : Effect.succeed(Option.getOrElse(Option.map(parsePartialInput(raw), (input) => input ?? {}), () => ({})))), Effect.map((input) => LLMEvent.toolCall({
+        id: tool.id,
+        name: tool.name,
+        namespace: tool.namespace,
+        input,
+        providerExecuted: tool.providerExecuted ? true : undefined,
+        providerMetadata: tool.providerMetadata,
+    })));
+};
+const finishEvents = (tool, event) => [
+    LLMEvent.toolInputEnd({
+        id: tool.id,
+        name: tool.name,
+        namespace: tool.namespace,
+        providerMetadata: tool.providerMetadata,
+    }),
+    event,
+];
+/** Store the updated tool and produce the optional public delta event. */
+const appendTool = (tools, key, tool, text) => {
+    const events = [];
+    if (!tools[key])
+        events.push(inputStart(tool));
+    if (text.length > 0)
+        events.push(inputDelta(tool, text));
+    return {
+        tools: withTool(tools, key, tool),
+        tool,
+        events,
+    };
+};
+export const isError = (result) => result instanceof AIError;
+/**
+ * Register a tool call whose start event arrived before any argument deltas.
+ * Used by Anthropic `content_block_start`, Bedrock `contentBlockStart`, and
+ * OpenAI Responses `response.output_item.added`.
+ */
+export const start = (tools, key, tool) => withTool(tools, key, { ...tool, input: tool.input ?? "" });
+/**
+ * Append a streamed argument delta, starting the tool if this provider encodes
+ * identity on the first delta instead of a separate start event. OpenAI Chat has
+ * this shape: `tool_calls[].index` is the stream key, and `id` / `name` may only
+ * appear on the first delta for that index.
+ */
+export const appendOrStart = (route, tools, key, delta, missingToolMessage) => {
+    const current = tools[key];
+    const id = current?.id ?? delta.id;
+    const name = current?.name ?? delta.name;
+    if (!id || !name)
+        return eventError(route, missingToolMessage);
+    const tool = {
+        id,
+        name,
+        namespace: current?.namespace,
+        input: `${current?.input ?? ""}${delta.text}`,
+        providerExecuted: current?.providerExecuted,
+        providerMetadata: current?.providerMetadata,
+    };
+    if (current && delta.text.length === 0 && current.id === id && current.name === name)
+        return { tools, tool: current, events: [] };
+    return appendTool(tools, key, tool, delta.text);
+};
+/**
+ * Append argument text to a started tool. Returns `undefined` when no tool is
+ * open under `key`, for protocols that ignore deltas without a matching block.
+ */
+export const append = (tools, key, text) => {
+    const current = tools[key];
+    if (!current)
+        return undefined;
+    if (text.length === 0)
+        return { tools, tool: current, events: [] };
+    return appendTool(tools, key, { ...current, input: `${current.input}${text}` }, text);
+};
+/**
+ * Append argument text to a tool that must already have been started. This keeps
+ * protocols honest when their stream grammar promises a start event before any
+ * argument delta.
+ */
+export const appendExisting = (route, tools, key, text, missingToolMessage) => append(tools, key, text) ?? eventError(route, missingToolMessage);
+/**
+ * Finalize one pending tool call: parse the accumulated raw JSON, remove it
+ * from state, and recover incomplete local arguments when needed.
+ * Missing keys are a no-op because some providers emit stop events for
+ * non-tool content blocks.
+ */
+export const finish = (route, tools, key) => Effect.gen(function* () {
+    const tool = tools[key];
+    if (!tool)
+        return { tools };
+    return {
+        tools: withoutTool(tools, key),
+        events: finishEvents(tool, yield* toolCall(route, tool)),
+    };
+});
+/**
+ * Finalize one pending tool call with an authoritative final input string.
+ * OpenAI Responses can send accumulated deltas and then repeat the completed
+ * arguments on `response.output_item.done`; the final value wins.
+ */
+export const finishWithInput = (route, tools, key, input) => Effect.gen(function* () {
+    const tool = tools[key];
+    if (!tool)
+        return { tools };
+    return {
+        tools: withoutTool(tools, key),
+        events: finishEvents(tool, yield* toolCall(route, tool, input)),
+    };
+});
+/**
+ * Finalize every pending tool call at once. OpenAI Chat has this shape: it does
+ * not emit per-tool stop events, so all accumulated calls finish independently
+ * when the choice receives a terminal `finish_reason`.
+ */
+export const finishAll = (route, tools) => Effect.gen(function* () {
+    const pending = Object.values(tools).filter((tool) => tool !== undefined);
+    return {
+        tools: empty(),
+        events: yield* Effect.forEach(pending, (tool) => toolCall(route, tool).pipe(Effect.map((event) => finishEvents(tool, event)))).pipe(Effect.map((events) => events.flat())),
+    };
+});
+export * as ToolStream from "./tool-stream.js";

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

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

package/dist/protocols/xai-images.js

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

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

@@ -0,0 +1,250 @@
+import { Protocol } from "../route/protocol.js";
+import { OpenResponses } from "./open-responses.js";
+export declare const protocol: Protocol<{
+    readonly input: readonly ({
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "web_search_call";
+        readonly status?: string | undefined;
+        readonly action?: {
+            readonly [x: string]: unknown;
+        } | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "file_search_call";
+        readonly status?: string | undefined;
+        readonly queries?: readonly string[] | undefined;
+        readonly results?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "code_interpreter_call";
+        readonly status?: string | undefined;
+        readonly code?: string | null | undefined;
+        readonly container_id?: string | null | undefined;
+        readonly outputs?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "mcp_call";
+        readonly status?: string | undefined;
+        readonly name?: string | undefined;
+        readonly output?: string | null | undefined;
+        readonly error?: unknown;
+        readonly arguments?: string | undefined;
+        readonly server_label?: string | undefined;
+    } | {
+        readonly type: "reasoning";
+        readonly summary: readonly {
+            readonly type: "summary_text";
+            readonly text: string;
+        }[];
+        readonly id?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+    } | {
+        readonly type: "compaction";
+        readonly encrypted_content: string;
+        readonly id?: string | null | undefined;
+    } | {
+        readonly role: "system";
+        readonly content: string;
+    } | {
+        readonly role: "developer";
+        readonly content: string;
+    } | {
+        readonly content: readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+            readonly detail?: string | undefined;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
+            readonly file_url?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        })[];
+        readonly role: "user";
+        readonly id?: string | undefined;
+        readonly type?: "message" | undefined;
+        readonly status?: string | undefined;
+    } | {
+        readonly type: "message";
+        readonly content: readonly {
+            readonly type: "output_text";
+            readonly text: string;
+        }[];
+        readonly role: "assistant";
+        readonly id?: string | undefined;
+        readonly status?: string | undefined;
+        readonly phase?: "commentary" | "final_answer" | null | undefined;
+    } | {
+        readonly type: "function_call";
+        readonly name: string;
+        readonly arguments: string;
+        readonly call_id: string;
+        readonly id?: string | undefined;
+        readonly namespace?: string | undefined;
+    } | {
+        readonly type: "function_call_output";
+        readonly call_id: string;
+        readonly output: string | readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+            readonly detail?: string | undefined;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
+            readonly file_url?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        } | {
+            readonly type: "input_video";
+            readonly video_url: string;
+        })[];
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "x_search_call";
+        readonly status?: string | undefined;
+        readonly action?: {
+            readonly [x: string]: unknown;
+        } | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "image_generation_call";
+        readonly status?: string | undefined;
+        readonly error?: unknown;
+        readonly result?: unknown;
+    })[];
+    readonly model: string;
+    readonly stream: true;
+    readonly metadata?: {
+        readonly [x: string]: string;
+    } | undefined;
+    readonly instructions?: string | undefined;
+    readonly reasoning?: {
+        readonly summary?: "auto" | "concise" | "detailed" | undefined;
+        readonly effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+    } | undefined;
+    readonly tools?: readonly {
+        readonly type: "function";
+        readonly description: string;
+        readonly name: string;
+        readonly parameters: {
+            readonly [x: string]: unknown;
+        };
+        readonly strict?: boolean | undefined;
+    }[] | undefined;
+    readonly text?: {
+        readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
+    } | undefined;
+    readonly temperature?: number | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly name: string;
+    } | {
+        readonly type: "allowed_tools";
+        readonly mode: "required" | "auto" | "none";
+        readonly tools: readonly {
+            readonly type: "function";
+            readonly name: string;
+        }[];
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly parallel_tool_calls?: boolean | undefined;
+    readonly store?: boolean | undefined;
+    readonly include?: readonly import("./utils/open-responses-options.js").ResponseIncludable[] | undefined;
+    readonly truncation?: "auto" | "disabled" | undefined;
+    readonly stream_options?: {
+        readonly include_obfuscation?: boolean | undefined;
+    } | undefined;
+    readonly safety_identifier?: string | undefined;
+    readonly top_logprobs?: number | undefined;
+    readonly max_output_tokens?: number | undefined;
+    readonly max_tool_calls?: number | undefined;
+}, string, {
+    readonly [x: string]: unknown;
+    readonly type: string;
+    readonly status?: unknown;
+    readonly code?: string | null | undefined;
+    readonly message?: string | undefined;
+    readonly headers?: unknown;
+    readonly text?: string | undefined;
+    readonly error?: {
+        readonly type?: string | null | undefined;
+        readonly code?: string | null | undefined;
+        readonly message?: string | null | undefined;
+        readonly param?: string | null | undefined;
+    } | null | undefined;
+    readonly item?: {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id?: string | undefined;
+        readonly name?: string | undefined;
+        readonly namespace?: string | undefined;
+        readonly arguments?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+        readonly call_id?: string | undefined;
+    } | null | undefined;
+    readonly delta?: string | undefined;
+    readonly response?: {
+        readonly [x: string]: unknown;
+        readonly id?: string | undefined;
+        readonly output?: readonly {
+            readonly [x: string]: unknown;
+            readonly type: string;
+            readonly id?: string | undefined;
+            readonly name?: string | undefined;
+            readonly namespace?: string | undefined;
+            readonly arguments?: string | undefined;
+            readonly encrypted_content?: string | null | undefined;
+            readonly call_id?: string | undefined;
+        }[] | undefined;
+        readonly error?: {
+            readonly type?: string | null | undefined;
+            readonly code?: string | null | undefined;
+            readonly message?: string | null | undefined;
+            readonly param?: string | null | undefined;
+        } | null | undefined;
+        readonly usage?: {
+            readonly input_tokens?: number | undefined;
+            readonly output_tokens?: number | undefined;
+            readonly output_tokens_details?: {
+                readonly reasoning_tokens?: number | undefined;
+            } | null | undefined;
+            readonly total_tokens?: number | undefined;
+            readonly input_tokens_details?: {
+                readonly cached_tokens?: number | undefined;
+                readonly cache_write_tokens?: number | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        readonly service_tier?: string | null | undefined;
+        readonly incomplete_details?: {
+            readonly reason?: string | undefined;
+        } | null | undefined;
+    } | undefined;
+    readonly arguments?: string | undefined;
+    readonly param?: string | null | undefined;
+    readonly status_code?: unknown;
+    readonly item_id?: string | undefined;
+    readonly output_index?: number | undefined;
+    readonly summary_index?: number | undefined;
+}, OpenResponses.ParserState>;
+export declare const compact: import("../route/client.js").CompactOperation;
+export * as XAIResponses from "./xai-responses.js";

package/dist/protocols/xai-responses.js

@@ -0,0 +1,81 @@
+import { Effect, Schema } from "effect";
+import { Protocol } from "../route/protocol.js";
+import { OpenResponses } from "./open-responses.js";
+import { JsonObject, optionalNull, ProviderShared } from "./shared.js";
+import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
+import { ResponsesCompaction } from "./utils/responses-compaction.js";
+const ADAPTER = "xai-responses";
+const NAME = "xAI Responses";
+const XAIResponsesHostedToolItem = Schema.Union([
+    Schema.StructWithRest(Schema.Struct({
+        type: Schema.tag("x_search_call"),
+        id: Schema.String,
+        status: Schema.optional(Schema.String),
+        action: optionalNull(JsonObject),
+    }), [JsonObject]),
+    Schema.StructWithRest(Schema.Struct({
+        type: Schema.tag("image_generation_call"),
+        id: Schema.String,
+        status: Schema.optional(Schema.String),
+        result: Schema.optional(Schema.Unknown),
+        error: Schema.optional(Schema.Unknown),
+    }), [JsonObject]),
+]);
+const XAIResponsesBody = Schema.Struct({
+    ...OpenResponses.coreFields,
+    input: Schema.Array(Schema.Union([OpenResponses.InputItem, XAIResponsesHostedToolItem])),
+    stream: Schema.Literal(true),
+});
+const adapter = {
+    id: ADAPTER,
+    name: NAME,
+    restoreHostedToolItem: (item) => (Schema.is(XAIResponsesHostedToolItem)(item) ? item : undefined),
+};
+const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(XAIResponsesBody));
+const fromRequest = Effect.fn("XAIResponses.fromRequest")(function* (request) {
+    if (request.providerOptions?.contextManagement !== undefined)
+        return yield* ProviderShared.unsupportedOperation({
+            operation: "in-band-compaction",
+            provider: request.model.provider,
+            route: request.model.route.id,
+            message: "xAI requires explicit compaction through LLMClient.compact; automatic context management is not supported",
+        });
+    return yield* decodeBody(yield* OpenResponses.fromRequestWithAdapter(request, adapter));
+});
+const HOSTED_TOOLS = {
+    web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
+    x_search_call: { name: "x_search", input: (item) => item.action ?? {} },
+    file_search_call: { name: "file_search", input: (item) => ({ queries: item.queries ?? [] }) },
+    code_interpreter_call: {
+        name: "code_interpreter",
+        input: (item) => ({ code: item.code, container_id: item.container_id }),
+    },
+    image_generation_call: { name: "image_generation", input: () => ({}) },
+    mcp_call: {
+        name: "mcp",
+        input: (item) => ({ server_label: item.server_label, name: item.name, arguments: item.arguments }),
+    },
+};
+// Grok speaks the standard Responses reasoning dialect (`reasoning_summary_text.*`,
+// handled by the baseline); only its hosted tool vocabulary differs.
+const step = (state, input) => {
+    const event = OpenResponses.normalize(state, input);
+    if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
+        return ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS);
+    return OpenResponses.step(state, event);
+};
+export const protocol = Protocol.make({
+    id: ADAPTER,
+    body: {
+        schema: XAIResponsesBody,
+        from: fromRequest,
+    },
+    stream: {
+        event: OpenResponses.protocol.stream.event,
+        initial: (request) => OpenResponses.initial(request, adapter),
+        step,
+        terminal: OpenResponses.terminal,
+    },
+});
+export const compact = ResponsesCompaction.make(adapter);
+export * as XAIResponses from "./xai-responses.js";

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

@@ -0,0 +1,22 @@
+import { ImageModel } from "../image.js";
+import { type Definition as AuthDefinition } from "../route/auth.js";
+import { type HttpOptions } from "../schema/index.js";
+export declare const DEFAULT_BASE_URL = "https://api.z.ai/api/paas/v4";
+export declare const PATH = "/images/generations";
+export type ZAIImageString<Known extends string> = Known | (string & {});
+export type ZAIImageOptions = {
+    readonly size?: ZAIImageString<"1024x1024" | "768x1344" | "864x1152" | "1344x768" | "1152x864" | "1440x720" | "720x1440">;
+    readonly quality?: ZAIImageString<"hd" | "standard">;
+    readonly userID?: string;
+} & Record<string, unknown>;
+export interface ModelInput {
+    readonly id: string;
+    readonly auth: AuthDefinition;
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions;
+}
+export declare const model: (input: ModelInput) => ImageModel<ZAIImageOptions>;
+export declare const ZAIImages: {
+    readonly model: (input: ModelInput) => ImageModel<ZAIImageOptions>;
+};