@morlay/dsh-llm-openai-compatible 0.0.1 → 0.0.2

package/src/serialize.ts

@@ -0,0 +1,336 @@
+import {
+  LlmError,
+  contentHasImage,
+  offloadRequestImagesWithPolicy,
+  textOnlyImageText,
+} from "@deepseek-ai/dsh-llm";
+import type { ContentBlock, GenerateOptions, Message } from "@deepseek-ai/dsh-llm";
+import { AttachmentError } from "@deepseek-ai/dsh-attachment";
+import type { AttachmentStore } from "@deepseek-ai/dsh-attachment";
+import type {
+  JSONSchema7,
+  LanguageModelV4FunctionTool,
+  LanguageModelV4Prompt,
+  SharedV4ProviderOptions,
+} from "@ai-sdk/provider";
+import { Buffer } from "node:buffer";
+import type { ReasoningEffort, ResolvedModelProfile, ResolvedProviderProfile } from "./adapter.ts";
+
+const TOOL_RESULT_IMAGE_TEXT = "Attached image(s) from tool result:";
+
+type UserContentPart = Extract<LanguageModelV4Prompt[number], { role: "user" }>["content"][number];
+
+export type OpenAICompatibleProviderOptions = SharedV4ProviderOptions & {
+  "openai-compatible"?: {
+    reasoningEffort?: string;
+
+    top_k?: number;
+  };
+};
+
+export interface OpenAICompatibleCallOptions {
+  prompt: LanguageModelV4Prompt;
+  maxOutputTokens?: number;
+  temperature?: number;
+  topP?: number;
+  presencePenalty?: number;
+  frequencyPenalty?: number;
+  seed?: number;
+  stopSequences?: string[];
+  tools?: LanguageModelV4FunctionTool[];
+  providerOptions?: OpenAICompatibleProviderOptions;
+}
+
+export function resolveReasoningWire(
+  model: ResolvedModelProfile | undefined,
+  effort: ResolvedProviderProfile["reasoning"] | undefined,
+): string | undefined {
+  if (effort === void 0) return void 0;
+  const declaration = model?.reasoningEfforts;
+  if (declaration === void 0 || declaration === false) {
+    const subject = model === void 0 ? "unlisted model" : `model "${model.id}"`;
+    throw new LlmError(
+      `OpenAI-compatible ${subject} declares no reasoning efforts, so "${effort}" cannot be selected`,
+      "UNSUPPORTED_REASONING_EFFORT",
+    );
+  }
+  const wire = declaration[effort];
+  if (wire === void 0) {
+    throw new LlmError(
+      `OpenAI-compatible model "${model.id}" does not support reasoning effort "${effort}"`,
+      "UNSUPPORTED_REASONING_EFFORT",
+    );
+  }
+  if (wire === null) return void 0;
+  return wire;
+}
+
+function flattenText(blocks: readonly ContentBlock[]): string {
+  return blocks
+    .filter((block) => block.type === "text")
+    .map((block) => block.text)
+    .join("");
+}
+
+function assertTextOnly(blocks: readonly ContentBlock[]): void {
+  if (contentHasImage(blocks)) {
+    throw new LlmError(
+      "The OpenAI-compatible chat-completions adapter does not support image content in this message.",
+      "UNSUPPORTED_CONTENT",
+    );
+  }
+}
+
+function assertSupportedImageRoles(messages: readonly Message[]): void {
+  for (const message of messages) {
+    if (message.role !== "user" && contentHasImage(message.content)) {
+      throw new LlmError(
+        `The OpenAI-compatible chat-completions adapter cannot represent image content in a ${message.role} message.`,
+        "UNSUPPORTED_CONTENT",
+      );
+    }
+  }
+}
+
+async function imagePart(
+  block: Extract<ContentBlock, { type: "image" }>,
+  attachments: AttachmentStore,
+  signal?: AbortSignal,
+): Promise<UserContentPart> {
+  try {
+    const stored = await attachments.readImage(block.attachment, signal);
+    return {
+      type: "file",
+      mediaType: stored.ref.mediaType,
+      data: {
+        type: "url",
+        url: new URL(
+          `data:${stored.ref.mediaType};base64,${Buffer.from(stored.data).toString("base64")}`,
+        ),
+      },
+    };
+  } catch (error) {
+    if (error instanceof AttachmentError)
+      throw new LlmError(error.message, error.code, { cause: error });
+    throw error;
+  }
+}
+
+function assistantParts(
+  message: Message,
+  toolNames: Map<string, string>,
+): Extract<LanguageModelV4Prompt[number], { role: "assistant" }>["content"] {
+  const parts: Extract<LanguageModelV4Prompt[number], { role: "assistant" }>["content"] = [];
+  for (const block of message.content) {
+    switch (block.type) {
+      case "text":
+        if (block.text.length > 0) parts.push({ type: "text", text: block.text });
+        break;
+      case "reasoning":
+        if (block.text.length > 0) parts.push({ type: "reasoning", text: block.text });
+        break;
+      case "tool-call": {
+        let input: unknown;
+        try {
+          input = JSON.parse(block.arguments) as unknown;
+        } catch {
+          throw new LlmError(
+            `assistant tool call "${block.id}" carries malformed JSON arguments`,
+            "MALFORMED_RESPONSE",
+          );
+        }
+        parts.push({ type: "tool-call", toolCallId: block.id, toolName: block.name, input });
+        toolNames.set(block.id, block.name);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return parts;
+}
+
+async function userParts(
+  blocks: readonly ContentBlock[],
+  resolveImage:
+    | ((
+        block: Extract<ContentBlock, { type: "image" }>,
+        signal?: AbortSignal,
+      ) => Promise<UserContentPart>)
+    | undefined,
+  signal?: AbortSignal,
+): Promise<UserContentPart[]> {
+  const parts: UserContentPart[] = [];
+  for (const block of blocks) {
+    switch (block.type) {
+      case "text":
+        if (block.text.length > 0) parts.push({ type: "text", text: block.text });
+        break;
+      case "image":
+        if (resolveImage === void 0)
+          throw new LlmError(
+            "The OpenAI-compatible chat-completions adapter does not support image content in this message.",
+            "UNSUPPORTED_CONTENT",
+          );
+        parts.push(await resolveImage(block, signal));
+        break;
+      case "tool-result":
+        parts.push(...(await userParts(block.content, resolveImage, signal)));
+        break;
+      default:
+        break;
+    }
+  }
+  return parts;
+}
+
+async function serializePrompt(
+  messages: readonly Message[],
+  resolveImage:
+    | ((
+        block: Extract<ContentBlock, { type: "image" }>,
+        signal?: AbortSignal,
+      ) => Promise<UserContentPart>)
+    | undefined,
+  signal?: AbortSignal,
+): Promise<LanguageModelV4Prompt> {
+  if (resolveImage === void 0) {
+    for (const message of messages) assertTextOnly(message.content);
+  } else {
+    assertSupportedImageRoles(messages);
+  }
+  const prompt: LanguageModelV4Prompt = [];
+  const toolNames = new Map<string, string>();
+  let pendingToolImages: UserContentPart[] = [];
+  const flushToolImages = () => {
+    if (pendingToolImages.length === 0) return;
+    prompt.push({
+      role: "user",
+      content: [{ type: "text", text: TOOL_RESULT_IMAGE_TEXT }, ...pendingToolImages],
+    });
+    pendingToolImages = [];
+  };
+  for (const message of messages) {
+    if (message.role === "system") {
+      flushToolImages();
+      prompt.push({ role: "system", content: flattenText(message.content) });
+      continue;
+    }
+    if (message.role === "assistant") {
+      flushToolImages();
+      const parts = assistantParts(message, toolNames);
+      if (parts.length > 0) prompt.push({ role: "assistant", content: parts });
+      continue;
+    }
+    const regular = message.content.filter((block) => block.type !== "tool-result");
+    const toolResults = message.content.filter((block) => block.type === "tool-result");
+    const content = await userParts(regular, resolveImage, signal);
+    if (content.length > 0 || toolResults.length === 0) {
+      flushToolImages();
+      prompt.push({ role: "user", content });
+    }
+    for (const result of toolResults) {
+      const images: UserContentPart[] = [];
+      if (resolveImage !== void 0) {
+        for (const block of result.content) {
+          if (block.type === "image") images.push(await resolveImage(block, signal));
+        }
+      }
+      prompt.push({
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: result.toolCallId,
+            toolName: toolNames.get(result.toolCallId) ?? "",
+            output: {
+              type: "text",
+              value:
+                flattenText(result.content) ||
+                (images.length > 0 ? "(see attached image)" : "(no output)"),
+            },
+          },
+        ],
+      });
+      pendingToolImages.push(...images);
+    }
+  }
+  flushToolImages();
+  return prompt;
+}
+
+function serializeTools(options: GenerateOptions): LanguageModelV4FunctionTool[] | undefined {
+  const tools = options.tools?.map((tool): LanguageModelV4FunctionTool => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.parameters as JSONSchema7,
+  }));
+  return tools !== void 0 && tools.length > 0 ? tools : void 0;
+}
+
+function callOptionsWithPrompt(
+  options: GenerateOptions,
+  profile: ResolvedProviderProfile,
+  model: ResolvedModelProfile | undefined,
+  prompt: LanguageModelV4Prompt,
+): OpenAICompatibleCallOptions {
+  const tools = serializeTools(options);
+  const temperature = options.temperature ?? profile.temperature;
+  const maxOutputTokens = options.maxTokens ?? model?.maxTokens ?? profile.defaultMaxTokens;
+  const requestedEffort: ReasoningEffort | undefined =
+    options.reasoningEffort === void 0
+      ? profile.reasoning
+      : (options.reasoningEffort as unknown as ReasoningEffort);
+  const reasoningEffort = resolveReasoningWire(model, requestedEffort);
+  const providerOptions: OpenAICompatibleProviderOptions = {
+    "openai-compatible": {
+      ...(reasoningEffort === void 0 ? {} : { reasoningEffort }),
+      ...(profile.topK === void 0 ? {} : { top_k: profile.topK }),
+    },
+  };
+  return {
+    prompt,
+    ...(temperature !== void 0 ? { temperature } : {}),
+    ...(profile.topP !== void 0 ? { topP: profile.topP } : {}),
+    ...(profile.presencePenalty !== void 0 ? { presencePenalty: profile.presencePenalty } : {}),
+    ...(profile.frequencyPenalty !== void 0 ? { frequencyPenalty: profile.frequencyPenalty } : {}),
+    ...(profile.seed !== void 0 ? { seed: profile.seed } : {}),
+    ...(maxOutputTokens !== void 0 ? { maxOutputTokens } : {}),
+    ...(options.stop !== void 0 ? { stopSequences: options.stop } : {}),
+    ...(tools !== void 0 ? { tools } : {}),
+    ...(Object.keys(providerOptions["openai-compatible"] ?? {}).length > 0
+      ? { providerOptions }
+      : {}),
+  };
+}
+
+export async function serializeCallOptions(
+  options: GenerateOptions,
+  profile: ResolvedProviderProfile,
+  model: ResolvedModelProfile | undefined,
+): Promise<OpenAICompatibleCallOptions> {
+  const system =
+    options.system === void 0 ? [] : [{ role: "system" as const, content: options.system }];
+  const prompt = await serializePrompt(options.messages, void 0);
+  return callOptionsWithPrompt(options, profile, model, [...system, ...prompt]);
+}
+
+export async function serializeCallOptionsWithImages(
+  options: GenerateOptions,
+  profile: ResolvedProviderProfile,
+  model: ResolvedModelProfile | undefined,
+  images: { attachments: AttachmentStore; maxRequestImageBytes: number; signal?: AbortSignal },
+): Promise<OpenAICompatibleCallOptions> {
+  const requestMessages = offloadRequestImagesWithPolicy(options.messages, {
+    representation: "raw",
+    maxBytes: images.maxRequestImageBytes,
+    placeholder: (ref) => textOnlyImageText(ref),
+  });
+  const resolveImage = (block: Extract<ContentBlock, { type: "image" }>, signal?: AbortSignal) =>
+    imagePart(block, images.attachments, signal);
+  const system =
+    options.system === void 0 ? [] : [{ role: "system" as const, content: options.system }];
+  const prompt = await serializePrompt(requestMessages, resolveImage, images.signal);
+  return callOptionsWithPrompt(options, profile, model, [...system, ...prompt]);
+}

package/src/translate.ts

@@ -0,0 +1,195 @@
+import { EMPTY_RESPONSE_CODE, ToolCallId, LlmError } from "@deepseek-ai/dsh-llm";
+import type { FinishReason, StreamChunk, TokenUsage } from "@deepseek-ai/dsh-llm";
+import type {
+  LanguageModelV4FinishReason,
+  LanguageModelV4StreamPart,
+  LanguageModelV4ToolCall,
+  LanguageModelV4Usage,
+} from "@ai-sdk/provider";
+
+export function mapFinishReason(reason: LanguageModelV4FinishReason): FinishReason {
+  switch (reason.unified) {
+    case "stop":
+      return { kind: "stop" };
+    case "tool-calls":
+      return { kind: "tool-calls" };
+    case "length":
+      return { kind: "max-tokens" };
+    default:
+      return {
+        kind: "error",
+        failure: {
+          message: `model stopped: ${reason.raw ?? reason.unified}`,
+          code: (reason.raw ?? reason.unified).toUpperCase(),
+        },
+      };
+  }
+}
+
+export function mapUsage(usage: LanguageModelV4Usage): TokenUsage {
+  const cacheRead = usage.inputTokens.cacheRead;
+  const reasoning = usage.outputTokens.reasoning;
+  return {
+    inputTokens: usage.inputTokens.noCache ?? usage.inputTokens.total ?? 0,
+    outputTokens: usage.outputTokens.total ?? 0,
+    ...(cacheRead !== void 0 && cacheRead > 0 ? { cacheReadTokens: cacheRead } : {}),
+    ...(reasoning !== void 0 && reasoning > 0 ? { reasoningTokens: reasoning } : {}),
+  };
+}
+
+interface OpenBlock {
+  index: number;
+  kind: "text" | "reasoning" | "tool-call";
+  text: string;
+  callId?: string;
+  name?: string;
+}
+
+function closeBlock(block: OpenBlock): Extract<StreamChunk, { type: "block-end" }>["block"] {
+  switch (block.kind) {
+    case "text":
+      return { type: "text", text: block.text };
+    case "reasoning":
+      return { type: "reasoning", text: block.text };
+    case "tool-call":
+      return {
+        type: "tool-call",
+        id: ToolCallId(block.callId ?? ""),
+        name: block.name ?? "",
+        arguments: block.text,
+      };
+  }
+}
+
+export async function* translate(
+  stream: ReadableStream<LanguageModelV4StreamPart>,
+): AsyncGenerator<StreamChunk, void> {
+  let nextIndex = 0;
+  const textBlocks = new Map<string, OpenBlock>();
+  const reasoningBlocks = new Map<string, OpenBlock>();
+  const toolBlocks = new Map<string, OpenBlock>();
+  const toolQueue: OpenBlock[] = [];
+  const order: OpenBlock[] = [];
+  let pendingUsage: TokenUsage | undefined;
+  let pendingFinish: FinishReason | undefined;
+
+  const open = (kind: OpenBlock["kind"]): OpenBlock => {
+    const block: OpenBlock = { index: nextIndex++, kind, text: "" };
+    order.push(block);
+    return block;
+  };
+
+  for await (const part of stream) {
+    switch (part.type) {
+      case "stream-start":
+      case "response-metadata":
+      case "raw":
+        break;
+      case "text-start": {
+        const block = open("text");
+        textBlocks.set(part.id, block);
+        yield { type: "block-start", index: block.index, blockType: "text" };
+        break;
+      }
+      case "text-delta": {
+        const block = textBlocks.get(part.id);
+        if (block === void 0) break;
+        block.text += part.delta;
+        yield { type: "text-delta", index: block.index, text: part.delta };
+        break;
+      }
+      case "text-end":
+        break;
+      case "reasoning-start": {
+        const block = open("reasoning");
+        reasoningBlocks.set(part.id, block);
+        yield { type: "block-start", index: block.index, blockType: "reasoning" };
+        break;
+      }
+      case "reasoning-delta": {
+        const block = reasoningBlocks.get(part.id);
+        if (block === void 0) break;
+        block.text += part.delta;
+        yield { type: "reasoning-delta", index: block.index, text: part.delta };
+        break;
+      }
+      case "reasoning-end":
+        break;
+      case "tool-input-start": {
+        const block = open("tool-call");
+        if (part.toolName !== void 0) block.name = part.toolName;
+        toolBlocks.set(part.id, block);
+        toolQueue.push(block);
+        yield { type: "block-start", index: block.index, blockType: "tool-call" };
+        break;
+      }
+      case "tool-input-delta": {
+        const block = toolBlocks.get(part.id);
+        if (block === void 0) break;
+        block.text += part.delta;
+        yield {
+          type: "tool-call-delta",
+          index: block.index,
+          id: ToolCallId(block.callId ?? part.id),
+          ...(block.name !== void 0 ? { name: block.name } : {}),
+          argumentsDelta: part.delta,
+        };
+        break;
+      }
+      case "tool-input-end":
+        break;
+      case "tool-call": {
+        applyToolCall(part, toolQueue);
+        break;
+      }
+      case "tool-result":
+      case "tool-approval-request":
+      case "custom":
+      case "file":
+      case "reasoning-file":
+      case "source":
+        // Provider-executed tools and generated files are not part of this
+        // adapter's client-executed tool loop; nothing to emit.
+        break;
+      case "finish":
+        pendingUsage = mapUsage(part.usage);
+        pendingFinish = mapFinishReason(part.finishReason);
+        for (const block of order)
+          yield { type: "block-end", index: block.index, block: closeBlock(block) };
+        if (pendingUsage !== void 0) yield { type: "usage", usage: pendingUsage };
+        const reason = pendingFinish ?? { kind: "stop" as const };
+        yield {
+          type: "finish",
+          reason:
+            reason.kind === "stop" && order.length === 0
+              ? {
+                  kind: "error",
+                  failure: {
+                    message: "model returned a completed response with no content",
+                    code: EMPTY_RESPONSE_CODE,
+                  },
+                }
+              : reason,
+        };
+        return;
+      case "error": {
+        const error = part.error;
+        const cause = error instanceof Error ? error : void 0;
+        const message =
+          cause?.message ?? (typeof error === "string" ? error : "provider stream error");
+        throw new LlmError(`OpenAI-compatible stream failed: ${message}`, "TRANSPORT", { cause });
+      }
+    }
+  }
+  throw new LlmError("AI SDK stream ended without a finish part", "STREAM_CLOSED");
+}
+
+function applyToolCall(part: LanguageModelV4ToolCall, toolQueue: OpenBlock[]): void {
+  const block = toolQueue.shift();
+  if (block === void 0) return;
+  block.callId = part.toolCallId;
+  block.name = part.toolName;
+  // The provider emits the complete arguments on this part; the buffered
+  // deltas were a partial view.
+  block.text = part.input;
+}

package/lib/adapter.d.mts

@@ -1,137 +0,0 @@
-import { GenerateOptions, LlmAdapter, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, ModelModality, ResolvedRetryPolicy, StreamChunk } from "@deepseek-ai/dsh-llm";
-import { CredentialRef } from "@deepseek-ai/dsh-credentials";
-import { LanguageModelV4Usage } from "@ai-sdk/provider";
-import { AttachmentStore } from "@deepseek-ai/dsh-attachment";
-//#region src/adapter.d.ts
-/** Default maximum idle interval while an adapter stream read is outstanding. */
-declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300000;
-/** Default combined request/response context capacity for unconfigured models. */
-declare const DEFAULT_CONTEXT_WINDOW = 262144;
-/** Default per-request output-token cap for unconfigured models. */
-declare const DEFAULT_MAX_TOKENS = 32768;
-/** Default bound on accumulated base64 image payload per request. */
-declare const DEFAULT_MAX_REQUEST_IMAGE_BYTES: number;
-/** Code stamped on the idle-watchdog timeout reason. */
-declare const STREAM_IDLE_TIMEOUT_CODE = "LLM_STREAM_IDLE_TIMEOUT";
-/** Code stamped on the whole-request deadline timeout reason. */
-declare const REQUEST_TIMEOUT_CODE = "LLM_REQUEST_TIMEOUT";
-/** The provider options key the SDK forwards into the request body. */
-declare const PROVIDER_OPTIONS_KEY = "openai-compatible";
-/** Selectable reasoning effort levels for one provider route. */
-type ReasoningEffort = "off" | "low" | "high" | "max";
-/** One validated catalog model of a provider route. */
-interface ResolvedModelProfile {
-  id: string;
-  name?: string;
-  description?: string;
-  contextWindow?: number;
-  maxTokens?: number;
-  inputModalities: readonly ModelModality[];
-  /**
-   * Declared reasoning efforts: key = selectable level, value = wire
-   * `reasoning_effort` spelling. `false` rejects the capability outright;
-   * absent means the model carries no reasoning metadata. A `null` wire
-   * spelling (only legal for `off`) means "omit the field".
-   */
-  reasoningEfforts?: false | Partial<Record<ReasoningEffort, string | null>>;
-}
-/** One validated provider route profile, detached and ready for per-request reads. */
-interface ResolvedProviderProfile {
-  provider: string;
-  displayName: string;
-  /** Credential reference; absence means the route sends no authorization header. */
-  apiKeyEnv?: CredentialRef;
-  /** Required endpoint base; requests hit `${baseURL}/chat/completions`. */
-  baseURL: string;
-  headers?: Readonly<Record<string, string>>;
-  temperature?: number;
-  topP?: number;
-  topK?: number;
-  presencePenalty?: number;
-  frequencyPenalty?: number;
-  seed?: number;
-  /** Deployment default reasoning level; omission keeps the provider default. */
-  reasoning?: ReasoningEffort;
-  models: readonly ResolvedModelProfile[];
-  defaultContextWindow: number;
-  defaultMaxTokens: number;
-  maxRequestImageBytes: number;
-  streamIdleTimeoutMs: number;
-  /** Whole-request deadline in milliseconds; unset arms no overall timer. */
-  timeoutMs?: number;
-  retryPolicy: ResolvedRetryPolicy;
-}
-/** Constructor options for {@link OpenAICompatibleAdapter}: the hooks the plugin owns. */
-interface OpenAICompatibleAdapterOptions {
-  /** Current validated profiles by provider route; called once per operation. */
-  profiles: () => ReadonlyMap<string, ResolvedProviderProfile>;
-  /**
-   * Resolve the credential for one already-resolved profile; called once per
-   * stream call and frozen for that call. `undefined` means the route sends no
-   * authorization header (an unauthenticated endpoint such as local Ollama).
-   */
-  resolveApiKey: (provider: string, profile: ResolvedProviderProfile) => Promise<string | undefined>;
-  /** Resolve the harness anonymous user id for request attribution headers. */
-  resolveUserId: () => string;
-  /** Resolve the optional durable attachment service at request time. */
-  resolveAttachments?: () => AttachmentStore | undefined;
-}
-/** The wire usage shape the SDK converter receives (subset of the OpenAI shape). */
-interface WireUsageLike {
-  prompt_tokens?: number | null | undefined;
-  completion_tokens?: number | null | undefined;
-  prompt_tokens_details?: {
-    cached_tokens?: number | null | undefined;
-  } | null | undefined;
-  /** DeepSeek-dialect cache hits folded into prompt_tokens. */
-  prompt_cache_hit_tokens?: number | null | undefined;
-  completion_tokens_details?: {
-    reasoning_tokens?: number | null | undefined;
-  } | null | undefined;
-}
-/**
- * Convert provider token accounting into disjoint AI SDK usage. OpenAI's
- * `prompt_tokens_details.cached_tokens` and the DeepSeek dialect's
- * `prompt_cache_hit_tokens` both report cache reads folded into
- * `prompt_tokens`; the harness convention is disjoint counts, so cache reads
- * are split out regardless of which field the endpoint used.
- */
-declare function convertUsage(usage: WireUsageLike | null | undefined): LanguageModelV4Usage;
-/**
- * Map an HTTP status to a stable LlmError code.
- * @param status - status of a non-2xx provider response.
- * @param error - parsed provider error body, when available.
- * @returns the normalized harness error code.
- */
-declare function httpErrorCode(status: number, error?: {
-  code?: unknown;
-  type?: unknown;
-  message?: unknown;
-}): string;
-/**
- * Multi-provider adapter. Each operation reads the current profiles, so a
- * configuration change reaches the next request without a restart; the
- * underlying SDK provider instance is cached per resolved profile and rebuilt
- * when the profile object changes.
- */
-declare class OpenAICompatibleAdapter extends LlmAdapter {
-  private readonly config;
-  private readonly sdkProviders;
-  constructor(config: OpenAICompatibleAdapterOptions);
-  /** The profile for one route, or the not-owned failure. */
-  private profileOf;
-  /** The configured descriptor for one exact route/model pair; unlisted ids pass through. */
-  private modelOf;
-  /** The SDK chat model for one route/model, cached per resolved profile. */
-  private sdkModel;
-  providerInfo(provider: string): LlmProviderInfo;
-  providerRetryPolicy(provider: string): ResolvedRetryPolicy | undefined;
-  listModels(provider: string): Promise<readonly LlmModelInfo[]>;
-  resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
-  stream(options: GenerateOptions): AsyncGenerator<StreamChunk>;
-  /** Normalize an SDK/transport failure into a harness LlmError. */
-  private normalizeTransportError;
-}
-//#endregion
-export { DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_REQUEST_IMAGE_BYTES, DEFAULT_MAX_TOKENS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, OpenAICompatibleAdapter, OpenAICompatibleAdapterOptions, PROVIDER_OPTIONS_KEY, REQUEST_TIMEOUT_CODE, ReasoningEffort, ResolvedModelProfile, ResolvedProviderProfile, STREAM_IDLE_TIMEOUT_CODE, convertUsage, httpErrorCode };
-//# sourceMappingURL=adapter.d.mts.map

package/lib/adapter.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/adapter.ts"],"mappings":";;;;;;cA4Ca;;cAEA;;cAEA;;cAEA;;cAEA;;cAEA;;cAEA;;KAGD;;UAGK;EACf;EACA;EACA;EACA;EACA;EACA,0BAA0B;;;;;;;EAO1B,2BAA2B,QAAQ,OAAO;;;UAI3B;EACf;EACA;;EAEA,YAAY;;EAEZ;EACA,UAAU,SAAS;EAEnB;EACA;EACA;EACA;EACA;EACA;;EAEA,YAAY;EAEZ,iBAAiB;EACjB;EACA;EAEA;EACA;;EAEA;EACA,aAAa;;;UAIE;;EAEf,gBAAgB,oBAAoB;;;;;;EAMpC,gBACE,kBACA,SAAS,4BACN;;EAEL;;EAEA,2BAA2B;;;UAInB;EACR;EACA;EACA;IAA0B;;;EAE1B;EACA;IAA8B;;;;;;;;;;iBAUhB,aAAa,OAAO,mCAAmC;;;;;;;iBAqEvD,cACd,gBACA;EAAU;EAAgB;EAAgB;;;;;;;;cA2C/B,gCAAgC;mBAC1B;mBACA;EAEL,YAAA,QAAQ;;UAMZ;;UAWA;;UAQA;EAqBR,aAAa,mBAAmB;EAOhC,oBAAoB,mBAAmB;EAIvC,WAAW,mBAAmB,iBAAiB;EAK/C,aACE,kBACA,eACA,UAAU,cACT,QAAQ;EAeJ,OAAO,SAAS,kBAAkB,eAAe;;UAoHhD"}