@xandreed/plugin-models 0.13.0 → 0.15.0

package/dist/llm/chat-wire.entity.d.ts

@@ -0,0 +1,123 @@
+import { Schema } from "effect";
+/** The usage object OpenAI-compatible completions carry (streaming sends it
+ *  on the last chunk under `stream_options: {include_usage: true}`). */
+export declare const CompletionUsage: Schema.Struct<{
+    readonly prompt_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+    readonly completion_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+    readonly total_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+    /** DeepSeek-style cache accounting. */
+    readonly prompt_cache_hit_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+    /** Moonshot-style cache accounting. */
+    readonly cached_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+    /** OpenAI-native cache reads; gateways (OpenCode's among them) add the cache writes. */
+    readonly prompt_tokens_details: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+        readonly cached_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        readonly cache_write_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+    }>>>;
+    /** OpenAI-native reasoning accounting, counted inside `completion_tokens`. */
+    readonly completion_tokens_details: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+        readonly reasoning_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+    }>>>;
+}>;
+export type CompletionUsage = typeof CompletionUsage.Type;
+/** One non-streaming chat completion. */
+export declare const ChatCompletion: Schema.Struct<{
+    readonly choices: Schema.optionalKey<Schema.NullOr<Schema.$Array<Schema.Struct<{
+        readonly finish_reason: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        readonly message: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+            readonly tool_calls: Schema.optionalKey<Schema.NullOr<Schema.$Array<Schema.Struct<{
+                readonly id: Schema.optionalKey<Schema.NullOr<Schema.brand<Schema.String, "ToolCallId">>>;
+                readonly function: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                    readonly name: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly arguments: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                }>>>;
+            }>>>>;
+            readonly content: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly reasoning_content: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly reasoning: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        }>>>;
+    }>>>>;
+    readonly usage: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+        readonly prompt_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        readonly completion_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        readonly total_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        /** DeepSeek-style cache accounting. */
+        readonly prompt_cache_hit_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        /** Moonshot-style cache accounting. */
+        readonly cached_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        /** OpenAI-native cache reads; gateways (OpenCode's among them) add the cache writes. */
+        readonly prompt_tokens_details: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+            readonly cached_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+            readonly cache_write_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        }>>>;
+        /** OpenAI-native reasoning accounting, counted inside `completion_tokens`. */
+        readonly completion_tokens_details: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+            readonly reasoning_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        }>>>;
+    }>>>;
+}>;
+export type ChatCompletion = typeof ChatCompletion.Type;
+/** A streamed tool-call fragment: fragments of one call share its `index`. */
+export declare const StreamToolCall: Schema.Struct<{
+    readonly index: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+    readonly id: Schema.optionalKey<Schema.NullOr<Schema.brand<Schema.String, "ToolCallId">>>;
+    readonly function: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+        readonly name: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        readonly arguments: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    }>>>;
+}>;
+export type StreamToolCall = typeof StreamToolCall.Type;
+/** One `data:` chunk of a streaming chat completion. */
+export declare const StreamChunk: Schema.Struct<{
+    readonly choices: Schema.optionalKey<Schema.NullOr<Schema.$Array<Schema.Struct<{
+        readonly finish_reason: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        readonly delta: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+            readonly tool_calls: Schema.optionalKey<Schema.NullOr<Schema.$Array<Schema.Struct<{
+                readonly index: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+                readonly id: Schema.optionalKey<Schema.NullOr<Schema.brand<Schema.String, "ToolCallId">>>;
+                readonly function: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                    readonly name: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly arguments: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                }>>>;
+            }>>>>;
+            readonly content: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly reasoning_content: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly reasoning: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        }>>>;
+    }>>>>;
+    readonly usage: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+        readonly prompt_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        readonly completion_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        readonly total_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        /** DeepSeek-style cache accounting. */
+        readonly prompt_cache_hit_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        /** Moonshot-style cache accounting. */
+        readonly cached_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        /** OpenAI-native cache reads; gateways (OpenCode's among them) add the cache writes. */
+        readonly prompt_tokens_details: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+            readonly cached_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+            readonly cache_write_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        }>>>;
+        /** OpenAI-native reasoning accounting, counted inside `completion_tokens`. */
+        readonly completion_tokens_details: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+            readonly reasoning_tokens: Schema.optionalKey<Schema.NullOr<Schema.Number>>;
+        }>>>;
+    }>>>;
+    readonly error: Schema.optionalKey<Schema.Unknown>;
+}>;
+export type StreamChunk = typeof StreamChunk.Type;
+/** The OpenAI error object a gateway reports a failure with: its type, its code and its message. */
+export declare const GatewayError: Schema.Struct<{
+    readonly type: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly code: Schema.optionalKey<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.Number]>>>;
+    readonly message: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+}>;
+export type GatewayError = typeof GatewayError.Type;
+/** A failed request's body in the OpenAI error shape. */
+export declare const GatewayErrorBody: Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly type: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        readonly code: Schema.optionalKey<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.Number]>>>;
+        readonly message: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    }>;
+}>;

package/dist/llm/chat-wire.entity.functions.d.ts

@@ -0,0 +1,28 @@
+import { AiError } from "effect/ai";
+import { Effect, Option, Schema } from "effect";
+import { ChatCompletion, GatewayError, StreamChunk } from "./chat-wire.entity.js";
+/** A completion body, decoded; one that is no JSON or of the wrong shape is the provider's `InvalidResponseError`. */
+export declare const decodeChatCompletion: (moduleName: string, text: string) => Effect.Effect<ChatCompletion, AiError.AiError>;
+/** A `data:` line's chunk, decoded; one that is no JSON object of the chunk's shape (`null` included) is the provider's `InvalidResponseError`. */
+export declare const decodeStreamChunk: (moduleName: string, payload: string) => Effect.Effect<StreamChunk, AiError.AiError>;
+/** A tool call's arguments, parsed: the model's own output, so a failure is the caller's to name. */
+export declare const decodeToolArguments: (text: string) => Effect.Effect<Schema.Json, Schema.SchemaError>;
+/** The OpenAI error object of a failed request's body, when it has one. */
+export declare const gatewayErrorOf: (body: string) => Option.Option<GatewayError>;
+/** The OpenAI error object of a stream's error chunk, when it is one. */
+export declare const chunkErrorOf: (error: unknown) => Option.Option<GatewayError>;
+/**
+ * The error types and codes gateways report an exhausted balance or quota
+ * with: OpenCode's `CreditsError`, OpenAI's `insufficient_quota` and
+ * `billing_insufficient_balance`, Moonshot's `exceeded_current_quota_error`.
+ */
+export declare const QUOTA_ERRORS: ReadonlySet<string>;
+/**
+ * Whether a failure is an exhausted balance or quota, which no retry and no
+ * fallback model fixes: a 402 (Payment Required), or an error whose type or
+ * code names one (`QUOTA_ERRORS`), at any status. A plain 429 is not: it is
+ * a rate limit, retried. The message text is not read.
+ */
+export declare const isQuotaExhausted: (status: Option.Option<number>, error: Option.Option<GatewayError>) => boolean;
+/** Whether a gateway rejected the selected model (OpenCode's `ModelError`), whatever status it answered with. */
+export declare const isModelRejection: (error: GatewayError) => boolean;

package/dist/llm/chat-wire.entity.functions.js

@@ -0,0 +1,10 @@
+import { AiError } from "effect/ai";
+import { Effect, Option, Schema } from "effect";
+import { ChatCompletion, GatewayError, GatewayErrorBody, StreamChunk } from "./chat-wire.entity.js";
+const invalidResponse = (moduleName, method, what) => (error) => AiError.make({ module: moduleName, method, reason: new AiError.InvalidResponseError({ description: `${what}: ${error.message}` }) }), completion = Schema.decodeUnknownEffect(Schema.fromJsonString(ChatCompletion)), chunk = Schema.decodeUnknownEffect(Schema.fromJsonString(StreamChunk)), json = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Json)), errorBody = Schema.decodeUnknownOption(Schema.fromJsonString(GatewayErrorBody)), errorObject = Schema.decodeUnknownOption(GatewayError);
+export const decodeChatCompletion = (moduleName, text) => completion(text).pipe(Effect.mapError(invalidResponse(moduleName, "generateText", "the completion body is not a chat completion"))), decodeStreamChunk = (moduleName, payload) => chunk(payload).pipe(Effect.mapError(invalidResponse(moduleName, "streamText", `a data: line is not a completion chunk (${payload.slice(0, 200)})`))), decodeToolArguments = (text) => json(text), gatewayErrorOf = (body) => Option.map(errorBody(body), (decoded) => decoded.error), chunkErrorOf = (error) => errorObject(error), QUOTA_ERRORS = new Set([
+  "CreditsError",
+  "insufficient_quota",
+  "billing_insufficient_balance",
+  "exceeded_current_quota_error"
+]), isQuotaExhausted = (status, error) => Option.contains(status, 402) || Option.exists(error, (found) => [found.type, found.code].some((name) => typeof name === "string" && QUOTA_ERRORS.has(name))), isModelRejection = (error) => error.type === "ModelError" || /model .*not supported/i.test(error.message ?? "");

package/dist/llm/chat-wire.entity.js

@@ -0,0 +1,37 @@
+import { Schema } from "effect";
+import { ToolCallId } from "@xandreed/core";
+const Count = Schema.optionalKey(Schema.NullOr(Schema.Number)), Text = Schema.optionalKey(Schema.NullOr(Schema.String));
+export const CompletionUsage = Schema.Struct({
+  prompt_tokens: Count,
+  completion_tokens: Count,
+  total_tokens: Count,
+  prompt_cache_hit_tokens: Count,
+  cached_tokens: Count,
+  prompt_tokens_details: Schema.optionalKey(Schema.NullOr(Schema.Struct({ cached_tokens: Count, cache_write_tokens: Count }))),
+  completion_tokens_details: Schema.optionalKey(Schema.NullOr(Schema.Struct({ reasoning_tokens: Count })))
+});
+const WireToolCallId = Schema.optionalKey(Schema.NullOr(ToolCallId)), ToolCallFunction = Schema.optionalKey(Schema.NullOr(Schema.Struct({ name: Text, arguments: Text }))), MessageText = { content: Text, reasoning_content: Text, reasoning: Text };
+export const ChatCompletion = Schema.Struct({
+  choices: Schema.optionalKey(Schema.NullOr(Schema.Array(Schema.Struct({
+    finish_reason: Text,
+    message: Schema.optionalKey(Schema.NullOr(Schema.Struct({
+      ...MessageText,
+      tool_calls: Schema.optionalKey(Schema.NullOr(Schema.Array(Schema.Struct({ id: WireToolCallId, function: ToolCallFunction }))))
+    })))
+  })))),
+  usage: Schema.optionalKey(Schema.NullOr(CompletionUsage))
+}), StreamToolCall = Schema.Struct({ index: Count, id: WireToolCallId, function: ToolCallFunction }), StreamChunk = Schema.Struct({
+  choices: Schema.optionalKey(Schema.NullOr(Schema.Array(Schema.Struct({
+    finish_reason: Text,
+    delta: Schema.optionalKey(Schema.NullOr(Schema.Struct({
+      ...MessageText,
+      tool_calls: Schema.optionalKey(Schema.NullOr(Schema.Array(StreamToolCall)))
+    })))
+  })))),
+  usage: Schema.optionalKey(Schema.NullOr(CompletionUsage)),
+  error: Schema.optionalKey(Schema.Unknown)
+}), GatewayError = Schema.Struct({
+  type: Text,
+  code: Schema.optionalKey(Schema.NullOr(Schema.Union([Schema.String, Schema.Number]))),
+  message: Text
+}), GatewayErrorBody = Schema.Struct({ error: GatewayError });

package/dist/llm/compat-telemetry.adapter.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import type { Tracer } from "effect";
+/** Annotate the actual native operation, never a routing or engine wrapper. */
+export declare const annotateCompatRequest: (span: Tracer.Span, provider: string, model: string) => Effect.Effect<void>;
+/** Raw cumulative fields replace their own attributes; missing counts never become zero. */
+export declare const observeCompatUsage: (span: Tracer.Span, raw: unknown, final: boolean, reasoning?: boolean) => Effect.Effect<void>;

package/dist/llm/compat-telemetry.adapter.js

@@ -0,0 +1,21 @@
+import { Effect, Option } from "effect";
+import { providerUsageCounts } from "./model-usage.entity.functions.js";
+export const annotateCompatRequest = (span, provider, model) => Effect.sync(() => {
+  span.attribute("gen_ai.provider.name", provider);
+  span.attribute("gen_ai.request.model", model);
+  span.attribute("gen_ai.operation.name", "chat");
+}), observeCompatUsage = (span, raw, final, reasoning = !0) => Option.match(providerUsageCounts("compat", raw, reasoning), {
+  onNone: () => Effect.void,
+  onSome: (counts) => Effect.sync(() => {
+    [
+      ["gen_ai.usage.input_tokens", counts.inputTokens],
+      ["gen_ai.usage.output_tokens", !final && counts.outputTokens === 0 ? void 0 : counts.outputTokens],
+      ["gen_ai.usage.cache_read.input_tokens", counts.cacheReadTokens],
+      ["gen_ai.usage.cache_write.input_tokens", counts.cacheWriteTokens],
+      ["gen_ai.usage.reasoning.output_tokens", counts.reasoningTokens]
+    ].forEach(([name, value]) => {
+      if (value !== void 0 && Number.isSafeInteger(value))
+        span.attribute(name, value);
+    });
+  })
+});

package/dist/llm/compat.d.ts

@@ -1,7 +1,7 @@
-import { AiError, LanguageModel, Tool } from "effect/ai";
-import type { Prompt } from "effect/ai";
-import { Effect } from "effect";
-import type { CompletionUsage } from "./sse.js";
+import { AiError, LanguageModel, Prompt, Tool, type Response as ResponseParts } from "effect/ai";
+import { Effect, Schema } from "effect";
+import type { UsageReading } from "./sse.js";
+import type { ModelsFetch } from "../ports/models-transport.port.js";
 /**
  * A generic OpenAI-compatible `/chat/completions` `LanguageModel` over raw
  * `fetch`. The official `@effect/ai-openai` client targets api.openai.com;
@@ -10,10 +10,11 @@ import type { CompletionUsage } from "./sse.js";
  *
  * `generateText` consumes whole turns (`stream: false`); `streamText` runs
  * the same request with `stream: true` through the pure SSE state machine in
- * `sse.ts`. Errors BEFORE any stream part surface with the same taxonomy as
- * `generateText` — that boundary is what the retry gate (router) keys on.
+ * `sse.ts`. Both paths use the same bounded request policy before handing
+ * off a successful response; body and SSE failures after handoff are final.
  */
 type Json = Record<string, unknown>;
+/** @public */
 export interface CompatConfig {
     /** Module name for `AiError` provenance (e.g. "OpenCode"). */
     readonly moduleName: string;
@@ -32,16 +33,55 @@ export interface CompatConfig {
      *  thinking defaults or call policy — for endpoints that reject the
      *  gateway extensions (Gemini's OpenAI-compatible API). */
     readonly standardOnly?: boolean;
-    /** Injectable for tests; defaults to global fetch. */
-    readonly fetchImpl?: typeof fetch;
-    /** Host-owned admission (e.g. reserve a worst-case cost) before every call. */
+    /** How the endpoint's usage is read (default: every count, reasoning
+     *  included; see `UsageReading`). */
+    readonly usage?: UsageReading;
+    /** The model reads images: send them as `image_url` parts (default false: label lines; see `toChatMessages`). */
+    readonly images?: boolean;
+    /** The fetch requests go through (the models plugin supplies its chosen transport); otherwise uses the call-local FetchHttpClient.Fetch reference. */
+    readonly fetchImpl?: ModelsFetch;
+    /** Host-owned admission (e.g. reserve a worst-case cost) before every
+     * physical send: the first and each retry the request policy makes. A
+     * failure ends the call without that send. */
     readonly beforeRequest?: (body: Readonly<Record<string, unknown>>) => Effect.Effect<void, AiError.AiError>;
-    /** Per-call accounting/resource boundary. Non-streaming responses are fully
-     * buffered inside request so interruption also aborts body consumption. */
+    /** Per-call accounting/resource boundary around the whole logical call,
+     * its retries included: it sees the final response or failure once.
+     * Non-streaming responses are fully buffered inside request so
+     * interruption also aborts body consumption. */
     readonly aroundRequest?: (body: Readonly<Record<string, unknown>>, request: Effect.Effect<Response, AiError.AiError>) => Effect.Effect<Response, AiError.AiError>;
 }
-/** Decoded `Prompt` messages → chat-completions message objects. */
-export declare const toChatMessages: (prompt: Prompt.Prompt) => ReadonlyArray<Json>;
+/**
+ * How `toChatMessages` writes a request.
+ *
+ * @public
+ */
+export interface ChatMessageOptions {
+    /** Send images as `image_url` parts (default false: label lines). */
+    readonly images?: boolean;
+}
+/**
+ * Decoded `Prompt` messages → chat-completions message objects. A
+ * text-only user message is its text, as before. Without `images`, a user
+ * message is one string: its text, then a label line per file part, and a
+ * tool result is its text with a label line per image. With `images`, a
+ * user message with images is a content array of its parts in order (an
+ * image as an `image_url` part with a `data:` URL), and a tool result is its
+ * text in the tool message, while its images, which a tool message cannot
+ * carry, follow all the batch's tool messages in one user message, each
+ * result's captioned `Images returned by <tool> (call <id>):`; a user
+ * message right after the batch is merged into it, so no two user messages
+ * follow each other, captioned `The user's message:` when it has images of
+ * its own.
+ */
+export declare const toChatMessages: (prompt: Prompt.Prompt, options?: ChatMessageOptions) => ReadonlyArray<Json>;
+/**
+ * A prompt with every file part a label line: what a route that reads no
+ * images is sent (the models plugin rewrites a request so on such routes).
+ * A user message with file parts becomes one text part (its text, then a
+ * label line each); a tool result with model output becomes its text with a
+ * label line per file part, as its result. Messages without files are kept.
+ */
+export declare const promptWithImageLabels: (prompt: Prompt.Prompt) => Prompt.Prompt;
 /** User-defined tools → chat-completions function declarations (empty when
  *  the request carries none — the caller omits the `tools` key entirely). */
 export declare const toChatTools: (tools: ReadonlyArray<Tool.Any>) => ReadonlyArray<Json>;
@@ -54,28 +94,39 @@ export declare const toChatTools: (tools: ReadonlyArray<Tool.Any>) => ReadonlyAr
  * `thinking: {type: "enabled"}`; qwen takes `enable_thinking`. Disabling is
  * never sent (kimi-k2.7+ rejects it outright); unknown families get nothing.
  */
-export declare const thinkingParams: (model: string) => Record<string, unknown>;
-interface ChatCompletion {
-    readonly choices?: ReadonlyArray<{
-        readonly finish_reason?: string;
+export declare const thinkingParams: (model: string) => Schema.JsonObject;
+/** Parse one non-streaming completion into `@effect/ai` encoded parts. */
+export declare const fromChatCompletion: (moduleName: string, body: {
+    readonly usage?: {
+        readonly prompt_tokens_details?: {
+            readonly cached_tokens?: number | null;
+            readonly cache_write_tokens?: number | null;
+        } | null;
+        readonly cached_tokens?: number | null;
+        readonly completion_tokens_details?: {
+            readonly reasoning_tokens?: number | null;
+        } | null;
+        readonly prompt_tokens?: number | null;
+        readonly completion_tokens?: number | null;
+        readonly total_tokens?: number | null;
+        readonly prompt_cache_hit_tokens?: number | null;
+    } | null;
+    readonly choices?: readonly {
         readonly message?: {
-            readonly content?: string | null;
-            /** DeepSeek-native vocabulary (kimi-k2.7-code, deepseek serve this). */
-            readonly reasoning_content?: string | null;
-            /** OpenRouter-style vocabulary (kimi-k2.6 via Moonshot serves this). */
             readonly reasoning?: string | null;
-            readonly tool_calls?: ReadonlyArray<{
-                readonly id?: string;
+            readonly content?: string | null;
+            readonly tool_calls?: readonly {
                 readonly function?: {
-                    readonly name?: string;
-                    readonly arguments?: string;
-                };
-            }>;
-        };
-    }>;
-    readonly usage?: CompletionUsage;
-}
-/** Parse one non-streaming completion into `@effect/ai` encoded parts. */
-export declare const fromChatCompletion: (moduleName: string, body: ChatCompletion) => Effect.Effect<ReadonlyArray<unknown>, AiError.AiError>;
+                    readonly name?: string | null;
+                    readonly arguments?: string | null;
+                } | null;
+                readonly id?: (string & import("effect/Brand").Brand<"ToolCallId">) | null;
+            }[] | null;
+            readonly reasoning_content?: string | null;
+        } | null;
+        readonly finish_reason?: string | null;
+    }[] | null;
+}, reading?: UsageReading | undefined) => Effect.Effect<readonly ResponseParts.PartEncoded[], AiError.AiError, never>;
+/** @public */
 export declare const makeCompatLanguageModel: (config: CompatConfig) => Effect.Effect<LanguageModel.LanguageModel>;
 export {};