@opencode/ai 0.0.0-reserved → 2.0.1

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

@@ -0,0 +1,202 @@
+import { Protocol } from "../route/protocol.js";
+import { OpenAIChat } from "./openai-chat.js";
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | (string & {});
+export type OptionsInput = {
+    readonly reasoningEffort?: ReasoningEffort;
+    readonly thinking?: {
+        readonly type?: "enabled" | "disabled" | (string & {});
+        /** False retains historical reasoning; omission preserves the endpoint's default. */
+        readonly clear_thinking?: boolean;
+    };
+    readonly toolStream?: boolean;
+    readonly doSample?: boolean;
+    readonly responseFormat?: {
+        readonly type: "text" | "json_object" | (string & {});
+    };
+    readonly requestID?: string;
+    readonly userID?: string;
+};
+export declare const compatibility: {
+    maxTokensField: "max_tokens";
+    supportsStore: false;
+    supportsStrictMode: false;
+    reasoningField: string;
+    zaiToolStream: false;
+};
+export declare const protocol: Protocol<{
+    readonly model: string;
+    readonly messages: readonly ({
+        readonly role: "system";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly role: "user";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly [x: string]: unknown;
+        readonly content: string | null;
+        readonly role: "assistant";
+        readonly reasoning?: string | undefined;
+        readonly reasoning_content?: string | undefined;
+        readonly reasoning_text?: string | undefined;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+        readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | undefined;
+        readonly reasoning_details?: unknown;
+    } | {
+        readonly content: string;
+        readonly role: "tool";
+        readonly tool_call_id: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    })[];
+    readonly stream: true;
+    readonly max_completion_tokens?: number | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly tools?: readonly {
+        readonly function: {
+            readonly description: string;
+            readonly name: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+            readonly strict?: boolean | undefined;
+        };
+        readonly type: "function";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    readonly stop?: readonly string[] | undefined;
+    readonly temperature?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly thinking?: {
+        readonly type?: string | undefined;
+        readonly clear_thinking?: boolean | undefined;
+    } | undefined;
+    readonly user_id?: string | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly 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 reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly store?: boolean | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly tool_stream?: boolean | undefined;
+    readonly response_format?: {
+        readonly type: string;
+    } | undefined;
+    readonly do_sample?: boolean | undefined;
+    readonly request_id?: string | undefined;
+}, string, "[DONE]" | {
+    readonly [x: string]: unknown;
+    readonly error?: {
+        readonly [x: string]: unknown;
+        readonly message: string;
+        readonly code?: string | number | null | undefined;
+    } | null | undefined;
+    readonly usage?: {
+        readonly [x: string]: unknown;
+        readonly cached_tokens?: number | null | undefined;
+        readonly prompt_tokens?: number | null | undefined;
+        readonly completion_tokens?: number | null | undefined;
+        readonly total_tokens?: number | null | undefined;
+        readonly prompt_tokens_details?: {
+            readonly [x: string]: unknown;
+            readonly cached_tokens?: number | null | undefined;
+            readonly cache_write_tokens?: number | null | undefined;
+        } | null | undefined;
+        readonly prompt_cache_hit_tokens?: number | null | undefined;
+        readonly completion_tokens_details?: {
+            readonly [x: string]: unknown;
+            readonly reasoning_tokens?: number | null | undefined;
+            readonly accepted_prediction_tokens?: number | null | undefined;
+            readonly rejected_prediction_tokens?: number | null | undefined;
+        } | null | undefined;
+    } | null | undefined;
+    readonly choices?: readonly {
+        readonly [x: string]: unknown;
+        readonly delta?: {
+            readonly [x: string]: unknown;
+            readonly reasoning?: string | null | undefined;
+            readonly reasoning_content?: string | null | undefined;
+            readonly reasoning_text?: string | null | undefined;
+            readonly content?: string | null | undefined;
+            readonly refusal?: string | null | undefined;
+            readonly tool_calls?: readonly {
+                readonly function?: {
+                    readonly name?: string | null | undefined;
+                    readonly arguments?: string | null | undefined;
+                } | null | undefined;
+                readonly id?: string | null | undefined;
+                readonly index?: number | null | undefined;
+            }[] | null | undefined;
+            readonly reasoning_details?: unknown;
+        } | null | undefined;
+        readonly usage?: {
+            readonly [x: string]: unknown;
+            readonly cached_tokens?: number | null | undefined;
+            readonly prompt_tokens?: number | null | undefined;
+            readonly completion_tokens?: number | null | undefined;
+            readonly total_tokens?: number | null | undefined;
+            readonly prompt_tokens_details?: {
+                readonly [x: string]: unknown;
+                readonly cached_tokens?: number | null | undefined;
+                readonly cache_write_tokens?: number | null | undefined;
+            } | null | undefined;
+            readonly prompt_cache_hit_tokens?: number | null | undefined;
+            readonly completion_tokens_details?: {
+                readonly [x: string]: unknown;
+                readonly reasoning_tokens?: number | null | undefined;
+                readonly accepted_prediction_tokens?: number | null | undefined;
+                readonly rejected_prediction_tokens?: number | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        readonly finish_reason?: string | null | undefined;
+        readonly native_finish_reason?: string | null | undefined;
+    }[] | null | undefined;
+}, OpenAIChat.ParserState>;
+export * as ZAIChat from "./zai-chat.js";

package/dist/protocols/zai-chat.js

@@ -0,0 +1,49 @@
+import { Effect, Schema } from "effect";
+import { Protocol } from "../route/protocol.js";
+import { OpenAIChat } from "./openai-chat.js";
+import { ProviderShared } from "./shared.js";
+const Options = Schema.Struct({
+    reasoningEffort: Schema.optional(Schema.String),
+    thinking: Schema.optional(Schema.Struct({ type: Schema.optional(Schema.String), clear_thinking: Schema.optional(Schema.Boolean) })),
+    toolStream: Schema.optional(Schema.Boolean),
+    doSample: Schema.optional(Schema.Boolean),
+    responseFormat: Schema.optional(Schema.Struct({ type: Schema.String })),
+    requestID: Schema.optional(Schema.String),
+    userID: Schema.optional(Schema.String),
+});
+const Body = Schema.Struct({
+    ...OpenAIChat.bodyFields,
+    thinking: Options.fields.thinking,
+    do_sample: Options.fields.doSample,
+    response_format: Options.fields.responseFormat,
+    request_id: Options.fields.requestID,
+    user_id: Options.fields.userID,
+});
+const fromRequest = Effect.fn("ZAIChat.fromRequest")(function* (request) {
+    const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(request.providerOptions ?? {});
+    const body = yield* OpenAIChat.protocol.body.from(request);
+    return {
+        ...body,
+        thinking: options.thinking,
+        // Tool streaming was introduced in GLM-4.6; older models must not receive the opt-in.
+        tool_stream: options.toolStream ??
+            (body.tools?.length && /^glm-(?:4\.[67]|5(?:[.-]|$))/i.test(request.model.id) ? true : undefined),
+        do_sample: options.doSample,
+        response_format: options.responseFormat,
+        request_id: options.requestID,
+        user_id: options.userID,
+    };
+});
+export const compatibility = {
+    maxTokensField: "max_tokens",
+    supportsStore: false,
+    supportsStrictMode: false,
+    reasoningField: "reasoning_content",
+    zaiToolStream: false,
+};
+export const protocol = Protocol.make({
+    id: "zai-chat",
+    body: { schema: Body, from: fromRequest },
+    stream: OpenAIChat.protocol.stream,
+});
+export * as ZAIChat from "./zai-chat.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>;
+};

package/dist/protocols/zai-images.js

@@ -0,0 +1,79 @@
+import { Effect, Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { GeneratedImage, ImageModel, ImageResponse } from "../image.js";
+import { Auth } from "../route/auth.js";
+import { mergeHttpOptions, mergeJsonRecords } from "../schema/index.js";
+import { ProviderShared } from "./shared.js";
+import { ImageInputs } from "./utils/image-input.js";
+const ADAPTER = "zai-images";
+export const DEFAULT_BASE_URL = "https://api.z.ai/api/paas/v4";
+export const PATH = "/images/generations";
+const ZAIImageResponse = Schema.Struct({
+    created: Schema.optional(Schema.Int),
+    id: Schema.optional(Schema.String),
+    request_id: Schema.optional(Schema.String),
+    data: Schema.Array(Schema.Struct({ url: Schema.String })),
+    content_filter: Schema.optional(Schema.Array(Schema.Struct({
+        role: Schema.optional(Schema.String),
+        level: Schema.optional(Schema.Number),
+    }))),
+});
+const nativeOptions = (options) => {
+    if (!options)
+        return undefined;
+    const { userID, ...native } = options;
+    return {
+        user_id: userID,
+        ...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("ZAIImages.generate")(function* (request, execute) {
+            if ((request.images?.length ?? 0) > 0)
+                return yield* ImageInputs.invalid("Z.ai hosted image generation does not support image inputs");
+            const http = mergeHttpOptions(request.model.http, request.http);
+            const requestBody = mergeJsonRecords({ model: request.model.id, prompt: request.prompt }, nativeOptions(request.options), http?.body);
+            const text = ProviderShared.encodeJson(requestBody);
+            const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${PATH}`, http?.query);
+            const headers = yield* Auth.toEffect(input.auth)({
+                request,
+                method: "POST",
+                url,
+                body: text,
+                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
+            });
+            const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
+            const output = yield* ProviderShared.imageResponse(ADAPTER, "Z.ai Images", response);
+            const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(ZAIImageResponse))(output.body).pipe(Effect.mapError((cause) => output.invalid("Z.ai Images returned an invalid response", cause)));
+            if (decoded.data.length === 0)
+                return yield* output.invalid("Z.ai Images returned no images");
+            return new ImageResponse({
+                images: decoded.data.map((item) => new GeneratedImage({
+                    mediaType: "application/octet-stream",
+                    data: item.url,
+                })),
+                providerMetadata: {
+                    zai: {
+                        created: decoded.created,
+                        id: decoded.id,
+                        requestID: decoded.request_id,
+                        contentFilter: decoded.content_filter,
+                    },
+                },
+            });
+        }),
+    };
+    return ImageModel.make({ id: input.id, provider: "zai", route, http: input.http });
+};
+export const ZAIImages = {
+    model,
+};