@alvin0/ai-agent-sdk-protocol-openai-chat-completions 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 alvin0 (chaulamdinhai) <chaulamdinhai@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# @alvin0/ai-agent-sdk-protocol-openai-chat-completions
+
+Runtime: **Universal** (Edge/Worker, browser, Deno, Bun, and Node).
+
+```sh
+pnpm add @alvin0/ai-agent-sdk-core @alvin0/ai-agent-sdk-protocol-openai-chat-completions
+```
+
+Universal OpenAI Chat Completions wire schema, request serializer, stream translator, and dialect. It owns no endpoint, credentials, fetch implementation, filesystem access, or Node.js APIs, and it knows nothing about any specific provider that happens to speak this wire format.
+
+```ts
+import { openAiChatCompletionsProtocol } from '@alvin0/ai-agent-sdk-protocol-openai-chat-completions'
+```
+
+Composition: `provider-author.protocol`. Lifecycle: `inert-value`; select it in
+`createRuntimeHttpProvider()` without any startup or cleanup obligation.
+
+The only runtime dependency is `@alvin0/ai-agent-sdk-core`.

package/dist/index.d.ts

@@ -0,0 +1,530 @@
+import { GenerateOptions, ModelError, ProviderRequestId, StreamChunk, UsageCounters } from "@alvin0/ai-agent-sdk-core";
+import { ModelTarget, ResolvedModelInfo } from "@alvin0/ai-agent-sdk-core/provider";
+//#region src/contract.d.ts
+/**
+ * The request fields a pure wire protocol is allowed to inspect.
+ *
+ * `model` is present at every decision point — `endpointPath`, `serialize` and
+ * `translate` all receive this shape — which is what makes model-keyed routing
+ * possible for a composite protocol built on top of this one.
+ */
+interface ProtocolRequest {
+  readonly options: GenerateOptions;
+  readonly model: ResolvedModelInfo;
+  readonly maxTokens: number;
+}
+/** One decoded SSE event, expressed without depending on an HTTP transport. */
+interface ProtocolSseEvent {
+  readonly event: string | undefined;
+  readonly data: string;
+}
+/** Protocol-internal chunks may carry a partial untrusted usage report. */
+type ProtocolStreamChunk = Exclude<StreamChunk, {
+  readonly type: 'usage';
+}> | {
+  readonly type: 'usage';
+  readonly usage: UsageCounters;
+};
+/** Structural protocol contract implemented without importing provider-http. */
+interface ProtocolDefinition<Dialect> {
+  readonly id: string;
+  readonly defaultDialect: Dialect;
+  endpointPath(request: ProtocolRequest, dialect: Dialect): string;
+  protocolHeaders?(dialect: Dialect): Record<string, string>;
+  serialize(request: ProtocolRequest, dialect: Dialect): unknown | Promise<unknown>;
+  translate(events: AsyncIterable<ProtocolSseEvent>, request: ProtocolRequest, displayName: string): AsyncGenerator<ProtocolStreamChunk>;
+}
+//#endregion
+//#region src/wire.d.ts
+/**
+ * The OpenAI Chat Completions wire shapes and the dialect describing how one
+ * endpoint differs from another.
+ *
+ * "OpenAI-compatible" is a family, not a single API: gateways, Azure
+ * deployments, editor-subscription endpoints, and self-hosted proxies all speak
+ * this protocol with small, well-known divergences — which field caps the
+ * output length, whether
+ * `parallel_tool_calls` is accepted at all, whether the system prompt travels
+ * as `system` or as `developer`. Those divergences are expressed here as DATA
+ * ({@link ChatCompletionsDialect}) so the serializer and the translator stay
+ * single-implementation.
+ *
+ * These types never leave this folder except through `ChatCompletionsDialect`.
+ *
+ * @module ai-agent-sdk/protocols/openai-chat-completions/wire
+ */
+/** Detail level requested for an input image. */
+type WireImageDetail = 'auto' | 'low' | 'high';
+/** One part of a multimodal message's content. */
+type WireContentPart = {
+  type: 'text';
+  text: string;
+} | {
+  type: 'image_url';
+  image_url: {
+    url: string;
+    detail?: WireImageDetail;
+  };
+};
+/**
+ * A tool call as the assistant turn carries it.
+ *
+ * `arguments` is a JSON-encoded STRING, not an object. When replaying a prior
+ * turn the string is sent back BYTE-FOR-BYTE as received: a
+ * `JSON.parse`/`JSON.stringify` round-trip reorders keys and renormalizes
+ * numbers, and some models use that exact string as context.
+ */
+interface WireToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    /** JSON-encoded STRING, verbatim. */
+    arguments: string;
+  };
+}
+/**
+ * One entry of the `messages` array.
+ *
+ * Note the shape of the conversation: unlike the Responses API's flat item
+ * list, this is a list of MESSAGES. A tool result is its own message with
+ * `role: 'tool'` correlated by `tool_call_id`, and an assistant turn that spoke
+ * and called two tools stays a single message carrying both `content` and
+ * `tool_calls`.
+ */
+type WireMessage = {
+  /** `developer` is the newer spelling; which one to use is a dialect knob. */
+  role: 'system' | 'developer';
+  content: string;
+} | {
+  role: 'user';
+  content: string | WireContentPart[];
+} | {
+  role: 'assistant';
+  /** Absent or null on a turn that only called tools. */
+  content?: string | null;
+  tool_calls?: WireToolCall[];
+} | {
+  role: 'tool';
+  /** Correlates with the `id` of the assistant's tool call. */
+  tool_call_id: string;
+  content: string;
+};
+/** A function tool, nested under a `function` key rather than flat. */
+interface WireFunctionTool {
+  type: 'function';
+  function: {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+    strict?: boolean;
+  };
+}
+type WireTool = WireFunctionTool;
+/** How the model must choose among the offered tools. */
+type WireToolChoice = 'auto' | 'none' | 'required' | {
+  type: 'function';
+  function: {
+    name: string;
+  };
+};
+/** Output format controls. */
+type WireResponseFormat = {
+  type: 'text';
+} | {
+  type: 'json_object';
+} | {
+  type: 'json_schema';
+  json_schema: {
+    name: string;
+    schema: Readonly<Record<string, unknown>>;
+    strict: true;
+  };
+};
+/** Streaming extras. */
+interface WireStreamOptions {
+  include_usage?: boolean;
+}
+/**
+ * The request body.
+ *
+ * Every optional field here is gated by a {@link ChatCompletionsDialect} flag,
+ * and a disabled flag means the key is ABSENT — never `null`, never a default
+ * value. Some gateways reject unknown-but-null keys outright, and a default
+ * value silently changes behaviour the caller never asked for.
+ */
+interface WireRequest {
+  model: string;
+  messages: WireMessage[];
+  stream: boolean;
+  stream_options?: WireStreamOptions;
+  /** Present under whichever name `dialect.maxTokensField` names. */
+  max_tokens?: number;
+  /** The reasoning-model spelling of the same cap. */
+  max_completion_tokens?: number;
+  temperature?: number;
+  top_p?: number;
+  frequency_penalty?: number;
+  presence_penalty?: number;
+  stop?: string | string[];
+  seed?: number;
+  reasoning_effort?: string;
+  tools?: WireTool[];
+  tool_choice?: WireToolChoice;
+  parallel_tool_calls?: boolean;
+  response_format?: WireResponseFormat;
+  /** Stable key letting the endpoint reuse a cached prompt prefix. */
+  prompt_cache_key?: string;
+  user?: string;
+}
+/** Cached-token breakdown of the prompt count. */
+interface WirePromptTokensDetails {
+  /** Portion of `prompt_tokens` served from cache — a SUBSET, not an addition. */
+  cached_tokens?: number;
+}
+/** Reasoning breakdown of the completion count. */
+interface WireCompletionTokensDetails {
+  reasoning_tokens?: number;
+}
+/** Token accounting as Chat Completions reports it. */
+interface WireUsage {
+  prompt_tokens?: number;
+  prompt_tokens_details?: WirePromptTokensDetails | null;
+  completion_tokens?: number;
+  completion_tokens_details?: WireCompletionTokensDetails | null;
+  total_tokens?: number;
+}
+/**
+ * Why a choice stopped.
+ *
+ * A value other than `null` is the TERMINAL FINISH of the stream. `[DONE]` is
+ * not: a truncated stream ends without ever producing one of these, and it is
+ * indistinguishable from a short answer unless the translator insists on
+ * seeing it.
+ */
+type WireFinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call';
+/**
+ * A tool-call fragment inside a streaming delta.
+ *
+ * `index` is the correlation key, NOT `id`: `id` and `function.name` arrive
+ * once, usually on the first fragment, while `function.arguments` arrives in
+ * many fragments that carry only `index`.
+ */
+interface WireToolCallDelta {
+  index: number;
+  id?: string;
+  type?: 'function';
+  function?: {
+    name?: string;
+    /** One fragment of the JSON string. Concatenate; do not parse. */
+    arguments?: string;
+  };
+}
+/** The incremental payload of one streamed choice. */
+interface WireChoiceDelta {
+  role?: 'assistant';
+  content?: string | null;
+  refusal?: string | null;
+  /** Non-standard but widely emitted by reasoning-capable endpoints. */
+  reasoning_content?: string | null;
+  tool_calls?: WireToolCallDelta[];
+}
+/** One streamed choice. */
+interface WireStreamChoice {
+  index?: number;
+  delta?: WireChoiceDelta;
+  finish_reason?: WireFinishReason | null;
+}
+/**
+ * One decoded `data:` payload of the stream.
+ *
+ * The usage-bearing final chunk has `choices: []`, so an empty `choices` array
+ * is normal traffic rather than a malformed event.
+ */
+interface WireStreamChunk {
+  id?: string;
+  object?: string;
+  created?: number;
+  model?: string;
+  choices?: WireStreamChoice[];
+  usage?: WireUsage | null;
+  /** Some gateways inline an error into the stream instead of failing the HTTP call. */
+  error?: WireErrorBody | null;
+}
+/** One choice of a non-streamed response. */
+interface WireChoice {
+  index?: number;
+  message?: {
+    role?: string;
+    content?: string | null;
+    refusal?: string | null;
+    tool_calls?: WireToolCall[];
+  };
+  finish_reason?: WireFinishReason | null;
+}
+/** A non-streamed response body. */
+interface WireResponse {
+  id?: string;
+  object?: string;
+  created?: number;
+  model?: string;
+  choices?: WireChoice[];
+  usage?: WireUsage | null;
+  error?: WireErrorBody | null;
+}
+/** The error payload of an HTTP error body, and of inline stream errors. */
+interface WireErrorBody {
+  type?: string;
+  code?: string | number;
+  message?: string;
+  param?: string | null;
+}
+/** An HTTP error response body, which nests the payload under `error`. */
+interface WireErrorResponse {
+  error?: WireErrorBody | string | null;
+}
+/**
+ * The set of differences between endpoints that speak Chat Completions.
+ *
+ * Expressed as data rather than as subclasses because the differences are all
+ * "send this field, under this name, or not at all" — behaviour is identical.
+ * Every flag maps one-to-one onto the presence of a wire field, and a disabled
+ * flag means the field is absent from the body entirely.
+ */
+interface ChatCompletionsDialect {
+  /** Send `temperature`, `top_p`, `frequency_penalty`, `presence_penalty`. */
+  readonly sampling: boolean;
+  /**
+   * Name of the output-length field; `false` sends no field at all.
+   *
+   * A three-value enum rather than a boolean because this is exactly where
+   * OpenAI-compatible endpoints split into two families: newer reasoning models
+   * reject `max_tokens` and require `max_completion_tokens`, while older
+   * gateways only understand `max_tokens`. A boolean would force each provider
+   * to fork the translator; an enum keeps one.
+   */
+  readonly maxTokensField: 'max_tokens' | 'max_completion_tokens' | false;
+  /**
+   * `response_format` support, three-state.
+   *
+   * `'json-schema'` sends the full schema with `strict: true`,
+   * `'json-object'` sends only `{ type: 'json_object' }` for endpoints that
+   * accept JSON mode but not schemas, and `false` sends nothing.
+   */
+  readonly structuredOutputs: 'json-schema' | 'json-object' | false;
+  /** Send `tools` + `tool_choice`. */
+  readonly tools: boolean;
+  /** Send `parallel_tool_calls`. */
+  readonly parallelToolCalls: boolean;
+  /** Send `stream_options: { include_usage: true }`. */
+  readonly streamUsage: boolean;
+  /** Role the system prompt travels under in `messages[0]`. */
+  readonly systemRole: 'system' | 'developer';
+  /** Send `stop`. */
+  readonly stop: boolean;
+  /** Send `seed`. */
+  readonly seed: boolean;
+  /** Send `reasoning_effort`. */
+  readonly reasoningEffort: boolean;
+  /** Prompt-cache key, sent when the endpoint accepts one. */
+  readonly promptCacheKey?: string;
+  /**
+   * Endpoint path appended to the base URL.
+   *
+   * Configurable because a gateway is free to mount the endpoint elsewhere, and
+   * hard-coding the path would make such a gateway unreachable without forking
+   * the protocol.
+   */
+  readonly path: string;
+}
+/**
+ * Conservative defaults.
+ *
+ * Conservative in one direction on purpose: a field an endpoint does not
+ * understand is usually a hard HTTP 400, while a field left unsent merely
+ * forgoes a feature. So `parallelToolCalls`, `seed` and `reasoningEffort` — the
+ * three fields older gateways most often reject — stay OFF until a provider
+ * opts in.
+ *
+ * Frozen because `defaultDialect` is snapshotted by the runtime and is shared
+ * across every adapter built on this protocol; a mutable default is a
+ * cross-provider side channel.
+ */
+declare const DEFAULT_DIALECT: ChatCompletionsDialect;
+//#endregion
+//#region src/errors.d.ts
+/**
+ * Recognize a moderation rejection in provider error text.
+ *
+ * Classified as `UNSUPPORTED_CONTENT` rather than as a new `CONTENT_FILTERED`
+ * code: the existing code already says exactly this — the request carried
+ * content the selected model will not accept — and it is already outside the
+ * default retryable set, which is the behaviour a filtered prompt needs.
+ * @param detail - provider error code/type/message text joined into one string.
+ * @returns true when the wording names content filtering or a content policy.
+ */
+declare function isContentFilteredError(detail: string): boolean;
+/**
+ * Map an HTTP status plus the provider's own error text onto a stable code.
+ *
+ * The status alone is not enough anywhere interesting: a 429 is either "slow
+ * down" (retry) or "your balance is gone" (never retry), and a 400 is either a
+ * prompt that overflows the context window (compact and retry), a moderation
+ * rejection, or a malformed request. All three distinctions are invisible in
+ * the status and each changes what the caller should do next, so the wording
+ * classifiers run in a fixed order ahead of the plain status buckets.
+ * @param status - status of a non-2xx response.
+ * @param detail - provider error code/type/message joined; empty when the body was unusable.
+ * @returns the normalized code, or `HTTP_{status}` when nothing classified it.
+ */
+declare function chatCompletionsErrorCode(status: number, detail?: string): string;
+/**
+ * Parse a `retry-after` header into milliseconds.
+ *
+ * Both defined forms appear in practice — delta-seconds and an HTTP date — so
+ * both are read. A date already in the past yields `undefined` rather than a
+ * negative delay, because a negative delay would be rejected downstream and
+ * take the whole diagnostic with it.
+ * @param value - the raw header value, or `null` when absent.
+ * @returns a positive finite delay in milliseconds, or `undefined` when absent or unusable.
+ */
+declare function chatCompletionsRetryAfterMs(value: string | null): number | undefined;
+/**
+ * Extract a provider request id for diagnostics.
+ *
+ * Nothing programmatic reads it, and it is still worth carrying: when an
+ * endpoint misbehaves, this id is the only handle its operators have for
+ * finding the request.
+ * @param headers - the response headers.
+ * @returns the first non-empty id found, or `undefined`.
+ */
+declare function chatCompletionsRequestId(headers: Headers): ProviderRequestId | undefined;
+/** An error body reduced to the two things the mapping needs. */
+interface ParsedChatCompletionsError {
+  /** Best human-readable message found, or `undefined` to fall back to the status. */
+  readonly message: string | undefined;
+  /** Provider `code`/`type`/`message` joined, as input to the wording classifiers. */
+  readonly detail: string;
+}
+/**
+ * Reduce an error body to a message and a classifier detail string.
+ *
+ * Tolerates every shape actually seen on this wire: the canonical
+ * `{error: {code, type, message}}`, a bare `{type, message}` with no wrapper, a
+ * `{detail: "..."}` in the FastAPI style some compatible endpoints use, an
+ * `{error: "..."}` carrying a plain string, and a body that is not JSON at all
+ * — which is what a gateway or load balancer sitting in front of the endpoint
+ * returns. In the last case the status stays authoritative and the raw text,
+ * truncated, is still the best classifier input available.
+ *
+ * A bare-string `error` contributes to the MESSAGE only, never to `detail`.
+ * That asymmetry is deliberate: `detail` is what decides the code, and it is
+ * held byte-identical to the shared provider mapping so the same
+ * `(status, body)` pair cannot classify differently here than it does for an
+ * existing provider.
+ * @param raw - the response body as text.
+ * @returns the message and the joined detail.
+ */
+declare function parseChatCompletionsErrorBody(raw: string): ParsedChatCompletionsError;
+/** Everything known about a non-2xx Chat Completions response. */
+interface ChatCompletionsHttpFailure {
+  /** Status of the response. */
+  readonly status: number;
+  /** The response body as text; empty when it could not be read. */
+  readonly body: string;
+  /** Response headers, read for `retry-after` and the request id. */
+  readonly headers: Headers;
+  /** Name used in the fallback message, e.g. the provider display name. */
+  readonly displayName: string;
+  /** Request URL, included in the fallback message for diagnosis. */
+  readonly url?: string;
+}
+/**
+ * Turn a non-2xx response into a fully populated {@link ModelError}.
+ *
+ * The provider's own message wins when there is one, because it is invariably
+ * more specific than anything this layer could synthesize; the synthesized
+ * fallback exists for bodies that carry no message at all. `cause` keeps the
+ * raw body so a diagnosis is possible even when the classifier found nothing.
+ * @param failure - the status, body, and headers of the failed response.
+ * @returns a ModelError carrying the code, status, retry delay, and request id.
+ */
+declare function chatCompletionsHttpError(failure: ChatCompletionsHttpFailure): ModelError;
+/**
+ * Map an error the endpoint inlined into a 200 stream onto the same taxonomy.
+ *
+ * Some gateways answer a rejected request with HTTP 200 and an `error` object
+ * inside a `data:` frame. There is no status to classify from, so the wording
+ * classifiers carry the whole decision, and the residual case is
+ * `MALFORMED_RESPONSE`: an error arriving where content was promised is a
+ * broken response, not a server fault to be retried.
+ * @param body - the `error` payload of a stream chunk.
+ * @param displayName - name used when the payload carries no message.
+ * @returns a ModelError with no `status`, since the HTTP call itself succeeded.
+ */
+declare function chatCompletionsStreamError(body: WireErrorBody, displayName: string): ModelError;
+/**
+ * Classify a failure raised before any status was seen.
+ *
+ * Kept apart from the status mapping because the three outcomes are decided by
+ * WHO ended the request, not by what the endpoint said: the caller's signal
+ * (`ABORTED`), a deadline (`TIMEOUT`), or the network (`TRANSPORT`). Web
+ * platform semantics supply the distinction — `AbortSignal.timeout` rejects
+ * with a `TimeoutError`, an explicit `abort()` with an `AbortError` — so no
+ * message parsing is involved.
+ * @param error - the thrown value.
+ * @param fallbackMessage - message used when the thrown value carries none.
+ * @returns a ModelError coded ABORTED, TIMEOUT, or TRANSPORT.
+ */
+declare function chatCompletionsTransportError(error: unknown, fallbackMessage: string): ModelError;
+//#endregion
+//#region src/protocol.d.ts
+/** Protocol id, usable as a stable string in configuration. */
+declare const OPENAI_CHAT_COMPLETIONS_PROTOCOL_ID = "openai-chat-completions";
+interface RuntimeProtocolRequest extends ProtocolRequest {
+  readonly model: ResolvedModelInfo;
+  readonly connection: {
+    readonly baseUrl: string;
+    readonly headers: Readonly<Record<string, string>>;
+  };
+}
+/** Marker-based runtime view, kept structurally independent from provider-http. */
+interface ChatCompletionsProtocolDefinition {
+  readonly kind: 'http-wire-protocol';
+  readonly apiVersion: 1;
+  readonly id: string;
+  readonly defaultDialect: ChatCompletionsDialect;
+  readonly exampleModel?: ModelTarget;
+  readonly endpointPath: (request: RuntimeProtocolRequest, dialect: ChatCompletionsDialect) => string;
+  readonly protocolHeaders?: (dialect: ChatCompletionsDialect) => Readonly<Record<string, string>>;
+  readonly serialize: (request: RuntimeProtocolRequest, dialect: ChatCompletionsDialect) => Readonly<Record<string, unknown>>;
+  readonly translate: (events: AsyncIterable<ProtocolSseEvent>, request: RuntimeProtocolRequest, displayName: string) => AsyncGenerator<ProtocolStreamChunk>;
+}
+/** The OpenAI Chat Completions wire protocol. */
+declare const openAiChatCompletionsProtocol: ProtocolDefinition<ChatCompletionsDialect> & ChatCompletionsProtocolDefinition;
+//#endregion
+//#region src/serialize.d.ts
+/**
+ * Build the Chat Completions request body.
+ * @param request - the resolved request, model, and output cap.
+ * @param dialect - which optional fields this endpoint accepts.
+ * @returns the wire body, ready to serialize.
+ */
+declare function serializeChatCompletionsRequest(request: ProtocolRequest, dialect: ChatCompletionsDialect): WireRequest;
+//#endregion
+//#region src/translate.d.ts
+/**
+ * Translate one Chat Completions SSE stream.
+ *
+ * Owns termination, and refuses to invent one: the stream is complete only when
+ * a `finish_reason` other than `null` has been seen. Events after that point are
+ * still read, because the `usage` chunk arrives there — with `choices: []`,
+ * which is normal traffic rather than a malformed event.
+ * @param events - decoded SSE events.
+ * @param displayName - provider name, used in diagnostics.
+ * @returns the chunk stream.
+ */
+declare function translateChatCompletionsStream(events: AsyncIterable<ProtocolSseEvent>, displayName: string): AsyncGenerator<ProtocolStreamChunk>;
+//#endregion
+export { type ChatCompletionsDialect, type ChatCompletionsHttpFailure, type ChatCompletionsProtocolDefinition, type DEFAULT_DIALECT, OPENAI_CHAT_COMPLETIONS_PROTOCOL_ID, type ParsedChatCompletionsError, type ProtocolDefinition, type ProtocolRequest, type ProtocolSseEvent, type ProtocolStreamChunk, type WireChoice, type WireChoiceDelta, type WireCompletionTokensDetails, type WireContentPart, type WireErrorBody, type WireErrorResponse, type WireFinishReason, type WireFunctionTool, type WireImageDetail, type WireMessage, type WirePromptTokensDetails, type WireRequest, type WireResponse, type WireResponseFormat, type WireStreamChoice, type WireStreamChunk, type WireStreamOptions, type WireTool, type WireToolCall, type WireToolCallDelta, type WireToolChoice, type WireUsage, chatCompletionsErrorCode, chatCompletionsHttpError, chatCompletionsRequestId, chatCompletionsRetryAfterMs, chatCompletionsStreamError, chatCompletionsTransportError, isContentFilteredError, openAiChatCompletionsProtocol, parseChatCompletionsErrorBody, serializeChatCompletionsRequest, translateChatCompletionsStream };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/contract.ts","../src/wire.ts","../src/errors.ts","../src/protocol.ts","../src/serialize.ts","../src/translate.ts"],"mappings":"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"}