@xandreed/plugin-models 0.14.0 → 0.15.1

package/dist/index.js

@@ -1,82 +1,30 @@
-export {
-  ANTHROPIC_OAUTH_BETA,
-  beginAnthropicOAuth,
-  CLAUDE_CODE_SYSTEM,
-  exchangeAnthropicCode,
-  generatePkce,
-  parseAuthorizationInput,
-  refreshAnthropicToken
-} from "./auth/anthropicOAuth.js";
-export {
-  beginOpenAiCodexOAuth,
-  exchangeOpenAiCodexCode,
-  OPENAI_CODEX_CALLBACK_PATH,
-  OPENAI_CODEX_CALLBACK_PORT,
-  OPENAI_CODEX_CLIENT_ID,
-  OPENAI_CODEX_REDIRECT_URI,
-  openAiCodexAccountId,
-  refreshOpenAiCodexToken
-} from "./auth/openAiCodexOAuth.js";
-export { authPaths, LocalAuthStoreLive } from "./auth/localAuth.js";
+export { beginAnthropicOAuth, exchangeAnthropicCode, parseAuthorizationInput, refreshAnthropicToken } from "./auth/anthropicOAuth.js";
+export { beginOpenAiCodexOAuth, exchangeOpenAiCodexCode, refreshOpenAiCodexToken } from "./auth/openAiCodexOAuth.js";
+export { LocalAuthStoreLive } from "./auth/localAuth.js";
 export { MemoryAuthStoreLive } from "./auth/memory-auth.adapter.js";
-export { CredentialInput, CredentialInputs } from "./auth/credential-input.entity.js";
-export { credentialsOf, toCredential, toCredentialInput } from "./auth/credential-input.entity.functions.js";
+export { AccountId, CredentialInput, CredentialInputs, InstallationId } from "./auth/credential-input.entity.js";
 export { RefreshableProvider } from "./auth/credential-refresh.entity.js";
 export { isUsableAt, REFRESH_SKEW_MS, refreshCredential } from "./auth/credential-refresh.entity.functions.js";
 export { HostCredentials } from "./ports/host-credentials.port.js";
+export { AuthError, AuthStore, Credential } from "./ports/auth-store.port.js";
+export { EngineSettings, SETTINGS_KEYS, SettingsError, SettingsStore } from "./ports/settings-store.port.js";
 export { LocalSettingsStoreLive } from "./settings/localSettings.js";
 export { MemorySettingsStoreLive } from "./settings/memory-settings.adapter.js";
 export { RoleField, SettingValue } from "./settings/settings-value.entity.js";
 export { applyRole, applySetting, coerceSettingValue, ROLE_FIELDS, roleSelection, settingsFromRecord } from "./settings/settings-value.entity.functions.js";
 export { roleModelView } from "./settings/roleView.js";
-export {
-  fromChatCompletion,
-  makeCompatLanguageModel,
-  promptWithImageLabels,
-  toChatMessages,
-  toChatTools
-} from "./llm/compat.js";
-export { makeOpenAiCodexLanguageModel, OPENAI_CODEX_API_URL, toOpenAiCodexRequestBody } from "./llm/openAiCodex.js";
-export { makeOpenAiCodexWebSocketHttpClient, normalizeOpenAiCodexWebSocketEvent, openAiCodexRefusal, openAiCodexUuidV7, OpenAiCodexWebSocketHttpClient } from "./llm/openAiCodexWebSocket.js";
-export {
-  buildProvider,
-  chatCompletionsUrl,
-  endpointOwnKey,
-  OPENCODE_CHAT_URL,
-  OPENCODE_RESPONSES_API_URL,
-  prependClaudeCode,
-  usesOpenCodeResponses,
-  withAnthropicCacheBreakpoints
-} from "./llm/providers.js";
-export {
-  classifyLlmError,
-  LLM_REQUEST_TIMEOUT_MS,
-  MAX_HONORED_RETRY_AFTER_MS,
-  rejectEmptyResponse,
-  retryableLlm
-} from "./llm/retry.js";
-export { generateWith, LanguageModelLive, LanguageModelSelectionLive } from "./llm/router.js";
-export {
-  configuredModelCatalog,
-  ConfiguredModelCatalogLive,
-  imageInputFor,
-  reasoningEffortsFor
-} from "./llm/modelCatalog.js";
+export { makeOpenAiCodexWebSocketHttpClient } from "./llm/openAiCodexWebSocket.js";
+export { LLM_CALL_BUDGET_MS, LLM_REQUEST_TIMEOUT_MS } from "./llm/retry.js";
+export { ModelRetryPolicy, modelRetryDefaults } from "./llm/model-retry-policy.entity.js";
+export { CurrentModelRetryPolicy } from "./ports/model-retry-policy.port.js";
+export { LanguageModelLive, LanguageModelSelectionLive } from "./llm/router.js";
+export { ConfiguredModelCatalogLive, imageInputFor, reasoningEffortsFor } from "./llm/modelCatalog.js";
 export { UtilityLlmLive } from "./llm/utilityLlm.js";
 export { modelsPlugin, default } from "./plugin.adapter.js";
 export { CurrentModelEndpoints, ModelEndpoint, ModelEndpoints } from "./ports/model-endpoints.port.js";
 export { ModelsTransport } from "./ports/models-transport.port.js";
-export { ModelsTransportLive, transportFetch } from "./transport/models-transport.adapter.js";
-export {
-  BUN_WEBSOCKET_PROXY_VERSION,
-  HttpProxyOptions,
-  NODE_WEBSOCKET_PROXY_VERSION,
-  NoProxyRule,
-  PROXY_VARIABLES,
-  ProxyConfig,
-  ProxyEnvironment,
-  ProxyInvalid,
-  ProxyUnsupported,
-  ProxyUrlOption
-} from "./transport/http-proxy.entity.js";
-export { bypassesProxy, isLoopback, parseNoProxy, proxyFor, redactCredentials, resolveProxy } from "./transport/http-proxy.entity.functions.js";
+export { ModelsTransportLive } from "./transport/models-transport.adapter.js";
+export { HttpProxyOptions, ProxyInvalid, ProxyUnsupported, ProxyUrlOption } from "./transport/http-proxy.entity.js";
+export { ModelThinking, ModelSettings, ModelSettingsMap, ModelSettingsError } from "./llm/model-settings.entity.js";
+export { PromptCacheSettings } from "./llm/prompt-cache.entity.js";
+export { CurrentModelSettings } from "./ports/model-settings.port.js";

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,6 +1,6 @@
-import { AiError, LanguageModel, Prompt, Tool } from "effect/ai";
-import { Effect } from "effect";
-import type { CompletionUsage, UsageReading } 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
@@ -10,10 +10,11 @@ import type { ModelsFetch } from "../ports/models-transport.port.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;
@@ -37,15 +38,23 @@ export interface CompatConfig {
     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 passes its `ModelsTransport`'s, which knows the proxy); defaults to the global fetch. */
+    /** 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 call. */
+    /** 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>;
 }
-/** How `toChatMessages` writes a request. */
+/**
+ * How `toChatMessages` writes a request.
+ *
+ * @public
+ */
 export interface ChatMessageOptions {
     /** Send images as `image_url` parts (default false: label lines). */
     readonly images?: boolean;
@@ -85,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, reading?: UsageReading) => 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 {};