@jaypie/llm 1.3.2 → 1.3.4

package/dist/esm/index.js

@@ -3,8 +3,6 @@ import log$2, { log as log$1 } from '@jaypie/logger';
 import { z } from 'zod/v4';
 import { placeholders, JAYPIE, resolveValue, sleep } from '@jaypie/kit';
 import RandomLib from 'random';
-import { RateLimitError, APIConnectionError, APIConnectionTimeoutError, InternalServerError, APIUserAbortError, AuthenticationError, BadRequestError, ConflictError, NotFoundError, PermissionDeniedError, UnprocessableEntityError, OpenAI } from 'openai';
-import { zodResponseFormat } from 'openai/helpers/zod';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
 import { PDFDocument } from 'pdf-lib';
@@ -638,7 +636,7 @@ function naturalZodSchema(definition) {
 //
 // Helpers
 //
-function isPlainObject(value) {
+function isPlainObject$1(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
@@ -647,11 +645,11 @@ function isPlainObject(value) {
  * provider adapters perform in `formatOutputSchema`, but without any
  * provider-specific sanitization.
  */
-function formatToJsonSchema(format) {
+function formatToJsonSchema$1(format) {
     if (format instanceof z.ZodType) {
         return z.toJSONSchema(format);
     }
-    if (isPlainObject(format) && format.type === "json_schema") {
+    if (isPlainObject$1(format) && format.type === "json_schema") {
         const clone = structuredClone(format);
         clone.type = "object";
         return clone;
@@ -669,7 +667,7 @@ function formatToJsonSchema(format) {
  * properties and array items so nested declared arrays are also backfilled.
  */
 function fillFromSchema(schema, value) {
-    if (!isPlainObject(schema)) {
+    if (!isPlainObject$1(schema)) {
         return value;
     }
     const type = schema.type;
@@ -679,18 +677,18 @@ function fillFromSchema(schema, value) {
             return [];
         }
         const items = schema.items;
-        if (Array.isArray(value) && isPlainObject(items)) {
+        if (Array.isArray(value) && isPlainObject$1(items)) {
             return value.map((entry) => fillFromSchema(items, entry));
         }
         return value;
     }
     const isObject = type === "object" || (type === undefined && "properties" in schema);
     if (isObject) {
-        if (!isPlainObject(value)) {
+        if (!isPlainObject$1(value)) {
             return value;
         }
         const properties = schema.properties;
-        if (isPlainObject(properties)) {
+        if (isPlainObject$1(properties)) {
             for (const [key, propSchema] of Object.entries(properties)) {
                 value[key] = fillFromSchema(propSchema, value[key]);
             }
@@ -713,7 +711,7 @@ function fillFromSchema(schema, value) {
  * through untouched.
  */
 function fillFormatArrays({ content, format, }) {
-    const schema = formatToJsonSchema(format);
+    const schema = formatToJsonSchema$1(format);
     if (!schema) {
         return content;
     }
@@ -975,6 +973,155 @@ function random$1(defaultSeed) {
     return rngFn;
 }
 
+//
+//
+// Helpers
+//
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Convert a `format` declaration (Zod schema, NaturalSchema, or a JSON Schema
+ * JsonObject) into a plain JSON Schema we can walk. Mirrors the conversion the
+ * provider adapters perform in `formatOutputSchema`, but without any
+ * provider-specific sanitization.
+ */
+function formatToJsonSchema(format) {
+    if (format instanceof z.ZodType) {
+        return z.toJSONSchema(format);
+    }
+    if (isPlainObject(format) && format.type === "json_schema") {
+        const clone = structuredClone(format);
+        clone.type = "object";
+        return clone;
+    }
+    try {
+        return z.toJSONSchema(naturalZodSchema(format));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Strip a single pair of surrounding double quotes from a key, if present.
+ * `"Merchant Request"` -> `Merchant Request`; `Confidence` -> `Confidence`.
+ */
+function dequoteKey(key) {
+    if (key.length >= 2 && key.startsWith('"') && key.endsWith('"')) {
+        return key.slice(1, -1);
+    }
+    return key;
+}
+/**
+ * Walk a JSON Schema alongside a parsed value, renaming any object key whose
+ * de-quoted form matches a declared property name. Recurses into declared
+ * object properties and array items so nested corrupted keys are also repaired.
+ */
+function repairFromSchema(schema, value) {
+    if (!isPlainObject(schema)) {
+        return value;
+    }
+    const type = schema.type;
+    const isArray = type === "array" || (type === undefined && "items" in schema);
+    if (isArray) {
+        const items = schema.items;
+        if (Array.isArray(value) && isPlainObject(items)) {
+            return value.map((entry) => repairFromSchema(items, entry));
+        }
+        return value;
+    }
+    const isObject = type === "object" || (type === undefined && "properties" in schema);
+    if (isObject && isPlainObject(value)) {
+        const properties = schema.properties;
+        if (isPlainObject(properties)) {
+            const declared = new Set(Object.keys(properties));
+            // Repair keys: rename a quote-wrapped key to its declared form, unless
+            // the correct key is already present (then drop the corrupted duplicate).
+            for (const key of Object.keys(value)) {
+                if (declared.has(key)) {
+                    continue;
+                }
+                const repaired = dequoteKey(key);
+                if (repaired !== key && declared.has(repaired)) {
+                    if (!(repaired in value)) {
+                        value[repaired] = value[key];
+                    }
+                    delete value[key];
+                }
+            }
+            // Recurse into declared properties now that keys are aligned.
+            for (const [key, propSchema] of Object.entries(properties)) {
+                if (key in value) {
+                    value[key] = repairFromSchema(propSchema, value[key]);
+                }
+            }
+        }
+        return value;
+    }
+    return value;
+}
+//
+//
+// Main
+//
+/**
+ * Repair structured-output keys that a provider/model corrupted by wrapping
+ * them in literal double quotes (observed on OpenAI for multi-word `format`
+ * keys: `Merchant Request` returned as `"Merchant Request"`). A declared
+ * `format` is a schema contract: returned keys should match the declared names
+ * exactly. Any returned key whose de-quoted form matches a declared key is
+ * renamed back to the declared key.
+ *
+ * Only mutates a (cloned) structured object; strings and non-objects pass
+ * through untouched.
+ */
+function repairFormatKeys({ content, format, }) {
+    const schema = formatToJsonSchema(format);
+    if (!schema) {
+        return content;
+    }
+    return repairFromSchema(schema, structuredClone(content));
+}
+
+const DEFAULT_DONE_SENTINEL = "[DONE]";
+/**
+ * Parse a Server-Sent Events stream into decoded JSON chunks. Buffers across
+ * network reads, dispatches on newline-delimited `data:` lines, and stops at
+ * the done sentinel (OpenAI-style `[DONE]`; Gemini omits it and simply ends
+ * the stream). Comment lines (`: ...`, used for keep-alive) are ignored.
+ *
+ * Shared by the provider HTTP clients that replaced their vendor SDKs.
+ */
+async function* parseSseStream(body, { doneSentinel = DEFAULT_DONE_SENTINEL } = {}) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let newlineIndex;
+            while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.slice(0, newlineIndex).replace(/\r$/, "");
+                buffer = buffer.slice(newlineIndex + 1);
+                if (line === "" || line.startsWith(":"))
+                    continue;
+                if (!line.startsWith("data:"))
+                    continue;
+                const data = line.slice("data:".length).trim();
+                if (data === doneSentinel)
+                    return;
+                yield JSON.parse(data);
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+
 /**
  * Helper function to safely call a function that might throw
  * @param fn Function to call safely
@@ -1502,7 +1649,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
             ? [...request.tools]
             : [];
         if (useFallbackStructuredOutput && request.format) {
-            log$2.warn(`[AnthropicAdapter] Using legacy structured_output tool fallback for model ${anthropicRequest.model}; native output_config previously rejected for this model.`);
+            log$1.warn(`[AnthropicAdapter] Using legacy structured_output tool fallback for model ${anthropicRequest.model}; native output_config previously rejected for this model.`);
             allTools.push({
                 name: STRUCTURED_OUTPUT_TOOL_NAME$3,
                 description: "Output a structured JSON object, " +
@@ -1617,7 +1764,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
             if (wantsStructuredOutput && isStructuredOutputUnsupportedError$1(error)) {
                 const model = anthropicRequest.model;
                 this.rememberModelRejectsStructuredOutput(model);
-                log$2.warn(`[AnthropicAdapter] Model ${model} rejected native output_config; falling back to legacy structured_output tool emulation.`);
+                log$1.warn(`[AnthropicAdapter] Model ${model} rejected native output_config; falling back to legacy structured_output tool emulation.`);
                 const fallbackRequest = this.toFallbackStructuredOutputRequest(anthropicRequest);
                 return (await anthropic.messages.create(fallbackRequest, signal ? { signal } : undefined));
             }
@@ -2680,7 +2827,7 @@ class GoogleAdapter extends BaseProviderAdapter {
             ? [...request.tools]
             : [];
         if (request.format && hasUserTools && !useNativeCombo) {
-            log$2.warn(`[GoogleAdapter] Using legacy structured_output tool fallback for model ${geminiRequest.model}; native responseJsonSchema + tools combo is only available on Gemini 3.`);
+            log$1.warn(`[GoogleAdapter] Using legacy structured_output tool fallback for model ${geminiRequest.model}; native responseJsonSchema + tools combo is only available on Gemini 3.`);
             allTools.push({
                 name: STRUCTURED_OUTPUT_TOOL_NAME$1,
                 description: "Output a structured JSON object, " +
@@ -2811,7 +2958,7 @@ class GoogleAdapter extends BaseProviderAdapter {
             if (wantsNativeCombo && isStructuredOutputComboUnsupportedError(error)) {
                 const model = geminiRequest.model;
                 this.rememberModelRejectsStructuredOutputCombo(model);
-                log$2.warn(`[GoogleAdapter] Model ${model} rejected native responseJsonSchema + tools combo; falling back to legacy structured_output tool emulation.`);
+                log$1.warn(`[GoogleAdapter] Model ${model} rejected native responseJsonSchema + tools combo; falling back to legacy structured_output tool emulation.`);
                 const fallbackRequest = this.toFallbackStructuredOutputRequest(geminiRequest);
                 const response = await genAI.models.generateContent({
                     model: fallbackRequest.model,
@@ -3395,6 +3542,206 @@ class GoogleAdapter extends BaseProviderAdapter {
 // Export singleton instance
 const googleAdapter = new GoogleAdapter();
 
+//
+//
+// Constants
+//
+const OPENAI_BASE_URL = "https://api.openai.com/v1";
+//
+//
+// Errors
+//
+// The adapter's `classifyError` uses `instanceof` against these classes, so the
+// client throws them directly. Status → class mapping mirrors the SDK; the
+// non-HTTP classes (connection/abort) are thrown when `fetch` itself rejects.
+//
+class OpenAiApiError extends Error {
+    constructor(status, message, error) {
+        super(message);
+        this.name = this.constructor.name;
+        this.status = status;
+        this.error = error;
+    }
+}
+let BadRequestError$1 = class BadRequestError extends OpenAiApiError {
+};
+let AuthenticationError$1 = class AuthenticationError extends OpenAiApiError {
+};
+let PermissionDeniedError$1 = class PermissionDeniedError extends OpenAiApiError {
+};
+let NotFoundError$1 = class NotFoundError extends OpenAiApiError {
+};
+class ConflictError extends OpenAiApiError {
+}
+class UnprocessableEntityError extends OpenAiApiError {
+}
+let RateLimitError$1 = class RateLimitError extends OpenAiApiError {
+};
+let InternalServerError$1 = class InternalServerError extends OpenAiApiError {
+};
+class APIConnectionError extends OpenAiApiError {
+}
+class APIConnectionTimeoutError extends APIConnectionError {
+}
+class APIUserAbortError extends OpenAiApiError {
+}
+function errorForStatus$1(status, message, error) {
+    if (status === 400)
+        return new BadRequestError$1(status, message, error);
+    if (status === 401)
+        return new AuthenticationError$1(status, message, error);
+    if (status === 403)
+        return new PermissionDeniedError$1(status, message, error);
+    if (status === 404)
+        return new NotFoundError$1(status, message, error);
+    if (status === 409)
+        return new ConflictError(status, message, error);
+    if (status === 422) {
+        return new UnprocessableEntityError(status, message, error);
+    }
+    if (status === 429)
+        return new RateLimitError$1(status, message, error);
+    if (status >= 500)
+        return new InternalServerError$1(status, message, error);
+    return new OpenAiApiError(status, message, error);
+}
+//
+//
+// Main
+//
+/**
+ * Minimal `fetch`-based client for the OpenAI API. Replaces the `openai` SDK —
+ * the adapters and provider utilities only need the Responses API
+ * (`/responses`, streaming and non-streaming) for `operate`/`stream` and the
+ * Chat Completions API (`/chat/completions`, plus a `parse` helper for
+ * structured output) for `send`. Mirrors the SDK's `responses.create` and
+ * `chat.completions.create` / `chat.completions.parse` surface so call sites are
+ * unchanged. Also serves xAI via a custom `baseURL`.
+ */
+class OpenAIClient {
+    constructor({ apiKey, baseURL = OPENAI_BASE_URL }) {
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        this.responses = {
+            create: ((params, options) => params.stream
+                ? this.createResponseStream(params, options)
+                : this.createResponse(params, options)),
+        };
+        this.chat = {
+            completions: {
+                create: (params, options) => this.chatCompletion(params, options, { parse: false }),
+                parse: (params, options) => this.chatCompletion(params, options, { parse: true }),
+            },
+        };
+    }
+    headers(extra) {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+            ...extra,
+        };
+    }
+    async post(path, body, { signal } = {}, { stream = false } = {}) {
+        let response;
+        try {
+            response = await fetch(`${this.baseURL}${path}`, {
+                method: "POST",
+                headers: this.headers(stream ? { Accept: "text/event-stream" } : undefined),
+                body: JSON.stringify(body),
+                signal,
+            });
+        }
+        catch (cause) {
+            if (signal?.aborted) {
+                throw new APIUserAbortError(0, "Request was aborted");
+            }
+            const message = cause instanceof Error ? cause.message : "Connection error";
+            const error = new APIConnectionError(0, message);
+            error.cause = cause;
+            throw error;
+        }
+        if (!response.ok)
+            throw await this.toError(response);
+        return response;
+    }
+    async toError(response) {
+        let message = `OpenAI request failed with status ${response.status}`;
+        let error;
+        try {
+            const body = (await response.json());
+            if (body?.error?.message) {
+                message = body.error.message;
+                error = body.error;
+            }
+        }
+        catch {
+            // Non-JSON error body; keep the status-based message.
+        }
+        return errorForStatus$1(response.status, message, error);
+    }
+    async createResponse(params, options) {
+        const response = await this.post("/responses", params, options);
+        return (await response.json());
+    }
+    async createResponseStream(params, options) {
+        const response = await this.post("/responses", params, options, {
+            stream: true,
+        });
+        if (!response.body)
+            return (async function* () { })();
+        // The Responses API streams typed events and does not emit a `[DONE]`
+        // sentinel; the empty default sentinel never matches, so the stream ends
+        // when the connection closes.
+        return parseSseStream(response.body);
+    }
+    async chatCompletion(params, options, { parse }) {
+        const response = await this.post("/chat/completions", params, options);
+        const json = (await response.json());
+        // `chat.completions.parse` surfaces parsed JSON on each message; replicate
+        // the SDK by JSON-parsing the assistant content into `message.parsed`.
+        if (parse) {
+            const choices = json.choices;
+            if (Array.isArray(choices)) {
+                for (const choice of choices) {
+                    const message = choice.message;
+                    if (message &&
+                        typeof message.content === "string" &&
+                        !message.refusal) {
+                        try {
+                            message.parsed = JSON.parse(message.content);
+                        }
+                        catch {
+                            message.parsed = null;
+                        }
+                    }
+                }
+            }
+        }
+        return json;
+    }
+}
+
+//
+//
+// Main
+//
+/**
+ * Local replacement for `openai/helpers/zod`'s `zodResponseFormat`. Builds the
+ * `response_format` payload OpenAI's Chat Completions / Responses APIs expect
+ * from a Zod schema. The SDK always emits `strict: true`; callers re-derive or
+ * sanitize `schema` as needed (e.g. forcing `additionalProperties: false`).
+ */
+function zodResponseFormat(schema, name) {
+    return {
+        type: "json_schema",
+        json_schema: {
+            name,
+            strict: true,
+            schema: z.toJSONSchema(schema),
+        },
+    };
+}
+
 // Patterns for OpenAI reasoning models that support extended thinking
 const REASONING_MODEL_PATTERNS = [
     /^gpt-[5-9]/, // GPT-5 and above (gpt-5, gpt-5.1, gpt-5.2, gpt-6, etc.)
@@ -3413,16 +3760,16 @@ function isReasoningModel(model) {
 const RETRYABLE_ERROR_TYPES = [
     APIConnectionError,
     APIConnectionTimeoutError,
-    InternalServerError,
+    InternalServerError$1,
 ];
 const NOT_RETRYABLE_ERROR_TYPES = [
     APIUserAbortError,
-    AuthenticationError,
-    BadRequestError,
+    AuthenticationError$1,
+    BadRequestError$1,
     ConflictError,
-    NotFoundError,
-    PermissionDeniedError,
-    RateLimitError,
+    NotFoundError$1,
+    PermissionDeniedError$1,
+    RateLimitError$1,
     UnprocessableEntityError,
 ];
 // Models known not to accept `temperature`.
@@ -3436,7 +3783,7 @@ const MODELS_WITHOUT_TEMPERATURE$1 = [
 function isTemperatureDeprecationError$1(error) {
     if (!error || typeof error !== "object")
         return false;
-    if (!(error instanceof BadRequestError) &&
+    if (!(error instanceof BadRequestError$1) &&
         error.status !== 400) {
         return false;
     }
@@ -3544,7 +3891,16 @@ class OpenAiAdapter extends BaseProviderAdapter {
             ? schema
             : naturalZodSchema(schema);
         const responseFormat = zodResponseFormat(zodSchema, "response");
-        const jsonSchema = z.toJSONSchema(zodSchema);
+        // Re-spread to drop zod v4's non-enumerable `~standard` Standard-Schema
+        // interop marker, then strip `$schema`: OpenAI's strict json_schema subset
+        // does not recognize the draft-2020-12 `$schema` keyword, and shipping it
+        // can leave strict structured-output enforcement silently disabled (the
+        // model then free-forms, omitting required fields and corrupting keys).
+        // Mirrors the OpenRouter adapter's sanitization.
+        const jsonSchema = {
+            ...z.toJSONSchema(zodSchema),
+        };
+        delete jsonSchema.$schema;
         // OpenAI requires additionalProperties to be false on all objects
         const checks = [jsonSchema];
         while (checks.length > 0) {
@@ -3781,7 +4137,7 @@ class OpenAiAdapter extends BaseProviderAdapter {
     //
     classifyError(error) {
         // Check for rate limit error
-        if (error instanceof RateLimitError) {
+        if (error instanceof RateLimitError$1) {
             return {
                 error,
                 category: ErrorCategory.RateLimit,
@@ -3999,7 +4355,49 @@ function convertContentToOpenRouter(content) {
     }
     return parts;
 }
-// OpenRouter SDK error types based on HTTP status codes
+/**
+ * Convert internal content parts to the OpenAI-compatible wire shape. The
+ * internal representation uses camelCase keys (`imageUrl`, `fileData`) that the
+ * SDK accepted; the REST API wants snake_case (`image_url`, `file_data`).
+ */
+function contentToWire(content) {
+    if (content === null ||
+        content === undefined ||
+        typeof content === "string") {
+        return content;
+    }
+    return content.map((part) => {
+        if (part.type === "image_url") {
+            return { type: "image_url", image_url: part.imageUrl };
+        }
+        if (part.type === "file") {
+            return {
+                type: "file",
+                file: { filename: part.file.filename, file_data: part.file.fileData },
+            };
+        }
+        return part;
+    });
+}
+/**
+ * Serialize an internal message to the OpenAI-compatible wire shape, mapping
+ * camelCase tool fields (`toolCalls`, `toolCallId`) to snake_case. Tool-call
+ * objects are already wire-shaped (`{ id, type, function: { name, arguments } }`).
+ */
+function messageToWire(message) {
+    const wire = { role: message.role };
+    if (message.content !== undefined) {
+        wire.content = contentToWire(message.content);
+    }
+    if (message.toolCalls) {
+        wire.tool_calls = message.toolCalls;
+    }
+    if (message.toolCallId) {
+        wire.tool_call_id = message.toolCallId;
+    }
+    return wire;
+}
+// OpenRouter error types based on HTTP status codes
 const RETRYABLE_STATUS_CODES = [408, 500, 502, 503, 524, 529];
 const RATE_LIMIT_STATUS_CODE = 429;
 /**
@@ -4202,7 +4600,7 @@ class OpenRouterAdapter extends BaseProviderAdapter {
         const openRouterRequest = request;
         const wantsStructuredOutput = Boolean(openRouterRequest.response_format);
         try {
-            const response = (await openRouter.chat.send(this.toSdkChatParams(openRouterRequest), signal ? { signal } : undefined));
+            const response = (await openRouter.chatCompletion(this.toWireBody(openRouterRequest), signal ? { signal } : undefined));
             if (wantsStructuredOutput) {
                 response.__jaypieStructuredOutput = true;
             }
@@ -4219,7 +4617,7 @@ class OpenRouterAdapter extends BaseProviderAdapter {
                 this.rememberModelRejectsTemperature(openRouterRequest.model);
                 const retryRequest = { ...openRouterRequest };
                 delete retryRequest.temperature;
-                const response = (await openRouter.chat.send(this.toSdkChatParams(retryRequest), signal ? { signal } : undefined));
+                const response = (await openRouter.chatCompletion(this.toWireBody(retryRequest), signal ? { signal } : undefined));
                 if (wantsStructuredOutput) {
                     response.__jaypieStructuredOutput = true;
                 }
@@ -4232,7 +4630,7 @@ class OpenRouterAdapter extends BaseProviderAdapter {
                 this.rememberModelRejectsStructuredOutput(model);
                 log$1.warn(`[OpenRouterAdapter] Model ${model} rejected native response_format; falling back to legacy structured_output tool emulation.`);
                 const fallbackRequest = this.toFallbackStructuredOutputRequest(openRouterRequest);
-                return (await openRouter.chat.send(this.toSdkChatParams(fallbackRequest), signal ? { signal } : undefined));
+                return (await openRouter.chatCompletion(this.toWireBody(fallbackRequest), signal ? { signal } : undefined));
             }
             throw error;
         }
@@ -4242,31 +4640,18 @@ class OpenRouterAdapter extends BaseProviderAdapter {
      * camelCase shape, forwarding only the fields we care about (the SDK
      * silently strips unknown fields).
      */
-    toSdkChatParams(openRouterRequest) {
-        const params = {
-            model: openRouterRequest.model,
-            messages: openRouterRequest.messages,
-            tools: openRouterRequest.tools,
-            toolChoice: openRouterRequest.tool_choice,
-            user: openRouterRequest.user,
+    /**
+     * Serialize the internal request into the OpenAI-compatible wire body for
+     * OpenRouter's Chat Completions endpoint. Top-level fields (model, tools,
+     * tool_choice, response_format, user, temperature, and any providerOptions)
+     * are already wire-shaped (snake_case); only messages carry camelCase tool
+     * fields that must become snake_case on the wire.
+     */
+    toWireBody(openRouterRequest) {
+        return {
+            ...openRouterRequest,
+            messages: openRouterRequest.messages.map(messageToWire),
         };
-        if (openRouterRequest.response_format) {
-            const format = openRouterRequest.response_format;
-            if (format.type === "json_schema") {
-                params.responseFormat = {
-                    type: "json_schema",
-                    jsonSchema: format.json_schema,
-                };
-            }
-            else {
-                params.responseFormat = format;
-            }
-        }
-        const temperature = openRouterRequest.temperature;
-        if (temperature !== undefined) {
-            params.temperature = temperature;
-        }
-        return params;
     }
     /**
      * Rebuild a structured-output request without `response_format`, swapping in
@@ -4298,15 +4683,9 @@ class OpenRouterAdapter extends BaseProviderAdapter {
     async *executeStreamRequest(client, request, signal) {
         const openRouter = client;
         const openRouterRequest = request;
-        // Use chat.send with stream: true for streaming responses.
-        // Cast the result to AsyncIterable: when stream: true, the SDK returns a
-        // stream we can iterate, but the typed result is the union with the
-        // non-stream response.
-        const streamParams = {
-            ...this.toSdkChatParams(openRouterRequest),
-            stream: true,
-        };
-        const stream = (await openRouter.chat.send(streamParams, signal ? { signal } : undefined));
+        // streamChatCompletion adds `stream: true` + `stream_options.include_usage`
+        // and yields decoded SSE chunks in OpenAI-compatible (snake_case) shape.
+        const stream = openRouter.streamChatCompletion(this.toWireBody(openRouterRequest), signal ? { signal } : undefined);
         // Track current tool call being built
         let currentToolCall = null;
         // Track usage for final chunk
@@ -4755,7 +5134,7 @@ const TRANSIENT_INGEST_MESSAGE_PATTERNS = [
     "failed to ingest inline file bytes",
 ];
 function isTransientIngestError(error) {
-    if (!(error instanceof BadRequestError))
+    if (!(error instanceof BadRequestError$1))
         return false;
     const message = (error.message ?? "").toLowerCase();
     return TRANSIENT_INGEST_MESSAGE_PATTERNS.some((pattern) => message.includes(pattern));
@@ -4947,7 +5326,7 @@ const requireModule = typeof __filename !== "undefined"
     ? createRequire(pathToFileURL(__filename).href)
     : createRequire(import.meta.url);
 let resolved = false;
-let cachedSdk$4 = null;
+let cachedSdk$1 = null;
 /**
  * Lazily resolve the dd-trace `llmobs` SDK. Returns null (and never throws)
  * when dd-trace is absent or the SDK surface is unexpected. Cached after the
@@ -4955,7 +5334,7 @@ let cachedSdk$4 = null;
  */
 function resolveLlmObs() {
     if (resolved) {
-        return cachedSdk$4;
+        return cachedSdk$1;
     }
     resolved = true;
     try {
@@ -4965,13 +5344,13 @@ function resolveLlmObs() {
         if (llmobs &&
             typeof llmobs.trace === "function" &&
             typeof llmobs.annotate === "function") {
-            cachedSdk$4 = llmobs;
+            cachedSdk$1 = llmobs;
         }
     }
     catch {
-        cachedSdk$4 = null;
+        cachedSdk$1 = null;
     }
-    return cachedSdk$4;
+    return cachedSdk$1;
 }
 //
 //
@@ -6310,9 +6689,12 @@ class OperateLoop {
         return false; // Stop loop
     }
     /**
-     * Backfill declared array fields when a `format` is supplied. A declared
-     * `format` is a schema contract: an empty array field should surface as `[]`
-     * rather than be dropped by a provider/model that omits empty lists.
+     * Reconcile structured output against the declared `format` contract. A
+     * declared `format` is a schema contract: returned keys should match the
+     * declared names exactly and every declared array field should be present.
+     * First repairs keys a provider/model corrupted by wrapping them in literal
+     * double quotes (observed on OpenAI for multi-word keys), then backfills any
+     * declared array field a provider/model omitted, surfacing it as `[]`.
      */
     applyFormatArrayDefaults(content, options) {
         if (!options.format) {
@@ -6321,7 +6703,8 @@ class OperateLoop {
         if (typeof content !== "object" || content === null) {
             return content;
         }
-        return fillFormatArrays({ content, format: options.format });
+        const repaired = repairFormatKeys({ content, format: options.format });
+        return fillFormatArrays({ content: repaired, format: options.format });
     }
     /**
      * Sync the current input state from the updated provider request.
@@ -6881,19 +7264,125 @@ function createStreamLoop(config) {
     return new StreamLoop(config);
 }
 
-// SDK loader with caching
-let cachedSdk$3 = null;
-async function loadSdk$3() {
-    if (cachedSdk$3)
-        return cachedSdk$3;
-    try {
-        cachedSdk$3 = await import('@anthropic-ai/sdk');
-        return cachedSdk$3;
+//
+//
+// Constants
+//
+const ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
+const ANTHROPIC_VERSION = "2023-06-01";
+//
+//
+// Errors
+//
+// The adapter's `classifyError` keys off `error.constructor.name` (the SDK's
+// class names), so the client throws errors whose class names match. Status →
+// class mapping mirrors the SDK.
+//
+class AnthropicApiError extends Error {
+    constructor(status, message, error) {
+        super(message);
+        this.name = this.constructor.name;
+        this.status = status;
+        this.error = error;
     }
-    catch {
-        throw new ConfigurationError("@anthropic-ai/sdk is required but not installed. Run: npm install @anthropic-ai/sdk");
+}
+class BadRequestError extends AnthropicApiError {
+}
+class AuthenticationError extends AnthropicApiError {
+}
+class PermissionDeniedError extends AnthropicApiError {
+}
+class NotFoundError extends AnthropicApiError {
+}
+class RateLimitError extends AnthropicApiError {
+}
+class InternalServerError extends AnthropicApiError {
+}
+function errorForStatus(status, message, error) {
+    if (status === 400)
+        return new BadRequestError(status, message, error);
+    if (status === 401)
+        return new AuthenticationError(status, message, error);
+    if (status === 403)
+        return new PermissionDeniedError(status, message, error);
+    if (status === 404)
+        return new NotFoundError(status, message, error);
+    if (status === 429)
+        return new RateLimitError(status, message, error);
+    if (status >= 500)
+        return new InternalServerError(status, message, error);
+    return new AnthropicApiError(status, message, error);
+}
+//
+//
+// Main
+//
+/**
+ * Minimal `fetch`-based client for Anthropic's Messages API. Replaces
+ * `@anthropic-ai/sdk` — the adapter only needs `messages.create` (streaming and
+ * non-streaming), header auth, and HTTP errors whose class names drive
+ * `classifyError`. Internal request params are already Anthropic's wire shape,
+ * so they serialize verbatim. Exposes a `messages` facade mirroring the SDK so
+ * the adapter call sites are unchanged.
+ */
+class AnthropicClient {
+    constructor({ apiKey, baseURL = ANTHROPIC_BASE_URL, }) {
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        this.messages = {
+            create: ((params, options) => params.stream
+                ? this.createStream(params, options)
+                : this.createMessage(params, options)),
+        };
+    }
+    headers() {
+        return {
+            "anthropic-version": ANTHROPIC_VERSION,
+            "content-type": "application/json",
+            "x-api-key": this.apiKey,
+        };
+    }
+    async toError(response) {
+        let message = `Anthropic request failed with status ${response.status}`;
+        let error;
+        try {
+            const body = (await response.json());
+            if (body?.error?.message) {
+                message = body.error.message;
+                error = body.error;
+            }
+        }
+        catch {
+            // Non-JSON error body; keep the status-based message.
+        }
+        return errorForStatus(response.status, message, error);
+    }
+    async createMessage(params, { signal } = {}) {
+        const response = await fetch(`${this.baseURL}/messages`, {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify(params),
+            signal,
+        });
+        if (!response.ok)
+            throw await this.toError(response);
+        return (await response.json());
+    }
+    async createStream(params, { signal } = {}) {
+        const response = await fetch(`${this.baseURL}/messages`, {
+            method: "POST",
+            headers: { ...this.headers(), accept: "text/event-stream" },
+            body: JSON.stringify(params),
+            signal,
+        });
+        if (!response.ok)
+            throw await this.toError(response);
+        if (!response.body)
+            return (async function* () { })();
+        return parseSseStream(response.body);
     }
 }
+
 // Logger
 const getLogger$5 = () => log$1.lib({ lib: JAYPIE.LIB.LLM });
 // Client initialization
@@ -6903,8 +7392,7 @@ async function initializeClient$5({ apiKey, } = {}) {
     if (!resolvedApiKey) {
         throw new ConfigurationError("The application could not resolve the required API key: ANTHROPIC_API_KEY");
     }
-    const sdk = await loadSdk$3();
-    const client = new sdk.default({ apiKey: resolvedApiKey });
+    const client = new AnthropicClient({ apiKey: resolvedApiKey });
     logger.trace("Initialized Anthropic client");
     return client;
 }
@@ -7004,6 +7492,7 @@ async function createStructuredCompletion$1(client, messages, model, responseSch
     [LlmMessageRole.Assistant]: PROVIDER.ANTHROPIC.ROLE.ASSISTANT,
     [LlmMessageRole.Developer]: PROVIDER.ANTHROPIC.ROLE.SYSTEM,
 });
+/* eslint-enable @typescript-eslint/no-namespace */
 
 // Main class implementation
 class AnthropicProvider {
@@ -7092,13 +7581,13 @@ class AnthropicProvider {
     }
 }
 
-let cachedSdk$2 = null;
-async function loadSdk$2() {
-    if (cachedSdk$2)
-        return cachedSdk$2;
+let cachedSdk = null;
+async function loadSdk() {
+    if (cachedSdk)
+        return cachedSdk;
     try {
-        cachedSdk$2 = await import('@aws-sdk/client-bedrock-runtime');
-        return cachedSdk$2;
+        cachedSdk = await import('@aws-sdk/client-bedrock-runtime');
+        return cachedSdk;
     }
     catch {
         throw new ConfigurationError("@aws-sdk/client-bedrock-runtime is required but not installed. Run: npm install @aws-sdk/client-bedrock-runtime");
@@ -7108,7 +7597,7 @@ const getLogger$4 = () => log$1.lib({ lib: JAYPIE.LIB.LLM });
 async function initializeClient$4({ region, } = {}) {
     const logger = getLogger$4();
     const resolvedRegion = region || process.env.AWS_REGION || "us-east-1";
-    const sdk = await loadSdk$2();
+    const sdk = await loadSdk();
     const client = new sdk.BedrockRuntimeClient({ region: resolvedRegion });
     logger.trace("Initialized Bedrock client");
     return client;
@@ -7173,19 +7662,156 @@ class BedrockProvider {
     }
 }
 
-// SDK loader with caching
-let cachedSdk$1 = null;
-async function loadSdk$1() {
-    if (cachedSdk$1)
-        return cachedSdk$1;
-    try {
-        cachedSdk$1 = await import('@google/genai');
-        return cachedSdk$1;
+//
+//
+// Constants
+//
+const GOOGLE_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+// Config keys the REST API expects at the top level of the request body. Every
+// other key in the SDK-style `config` object belongs under `generationConfig`.
+const TOP_LEVEL_CONFIG_KEYS = new Set([
+    "systemInstruction",
+    "tools",
+    "toolConfig",
+    "safetySettings",
+    "cachedContent",
+]);
+/**
+ * HTTP error carrying the upstream status and parsed API message. The
+ * GoogleAdapter classifies errors by reading `.status` / `.code` and
+ * `.message`, so this shape keeps `classifyError` working unchanged after
+ * dropping the SDK.
+ */
+class GoogleHttpError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.name = "GoogleHttpError";
+        this.status = status;
+        this.code = status;
     }
-    catch {
-        throw new ConfigurationError("@google/genai is required but not installed. Run: npm install @google/genai");
+}
+//
+//
+// Helpers
+//
+/**
+ * Translate the SDK-style `{ model, contents, config }` request into the REST
+ * `generateContent` body. `systemInstruction` (a string) becomes a Content;
+ * top-level config keys pass through; all remaining config keys (temperature,
+ * responseMimeType, responseSchema, responseJsonSchema, ...) move under
+ * `generationConfig`.
+ */
+function toRestBody(params) {
+    const body = {
+        contents: params.contents,
+    };
+    const config = params.config;
+    if (!config)
+        return body;
+    const generationConfig = {};
+    for (const [key, value] of Object.entries(config)) {
+        if (value === undefined)
+            continue;
+        if (key === "systemInstruction") {
+            body.systemInstruction =
+                typeof value === "string"
+                    ? { parts: [{ text: value }] }
+                    : value;
+        }
+        else if (TOP_LEVEL_CONFIG_KEYS.has(key)) {
+            body[key] = value;
+        }
+        else {
+            generationConfig[key] = value;
+        }
+    }
+    if (Object.keys(generationConfig).length > 0) {
+        body.generationConfig = generationConfig;
+    }
+    return body;
+}
+/**
+ * Concatenate the non-thought text parts of the first candidate, matching the
+ * SDK's `response.text` convenience getter (consumed by `GoogleProvider.send`).
+ */
+function responseText(response) {
+    const parts = response.candidates?.[0]?.content?.parts;
+    if (!parts)
+        return undefined;
+    const text = parts
+        .filter((part) => part.text && !part.thought)
+        .map((part) => part.text)
+        .join("");
+    return text.length > 0 ? text : undefined;
+}
+//
+//
+// Main
+//
+/**
+ * Minimal `fetch`-based client for Google's Generative Language (Gemini) REST
+ * API. Replaces `@google/genai` — the adapter only needs `generateContent`
+ * (streaming and non-streaming), an api-key header, and HTTP error surfacing.
+ * Exposes a `models` facade mirroring the SDK so the adapter call sites are
+ * unchanged.
+ */
+class GoogleClient {
+    constructor({ apiKey, baseURL = GOOGLE_BASE_URL }) {
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        this.models = {
+            generateContent: (params, options) => this.generateContent(params, options),
+            generateContentStream: (params, options) => this.generateContentStream(params, options),
+        };
+    }
+    headers() {
+        return {
+            "Content-Type": "application/json",
+            "x-goog-api-key": this.apiKey,
+        };
+    }
+    async toError(response) {
+        let message = `Google request failed with status ${response.status}`;
+        try {
+            const body = (await response.json());
+            if (body?.error?.message)
+                message = body.error.message;
+        }
+        catch {
+            // Non-JSON error body; keep the status-based message.
+        }
+        return new GoogleHttpError(response.status, message);
+    }
+    async generateContent(params, { signal } = {}) {
+        const url = `${this.baseURL}/models/${params.model}:generateContent`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify(toRestBody(params)),
+            signal,
+        });
+        if (!response.ok)
+            throw await this.toError(response);
+        const json = (await response.json());
+        json.text = responseText(json);
+        return json;
+    }
+    async generateContentStream(params, { signal } = {}) {
+        const url = `${this.baseURL}/models/${params.model}:streamGenerateContent?alt=sse`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { ...this.headers(), Accept: "text/event-stream" },
+            body: JSON.stringify(toRestBody(params)),
+            signal,
+        });
+        if (!response.ok)
+            throw await this.toError(response);
+        if (!response.body)
+            return (async function* () { })();
+        return parseSseStream(response.body);
     }
 }
+
 // Logger
 const getLogger$3 = () => log$1.lib({ lib: JAYPIE.LIB.LLM });
 // Client initialization
@@ -7195,8 +7821,7 @@ async function initializeClient$3({ apiKey, } = {}) {
     if (!resolvedApiKey) {
         throw new ConfigurationError("The application could not resolve the requested keys");
     }
-    const sdk = await loadSdk$1();
-    const client = new sdk.GoogleGenAI({ apiKey: resolvedApiKey });
+    const client = new GoogleClient({ apiKey: resolvedApiKey });
     logger.trace("Initialized Gemini client");
     return client;
 }
@@ -7345,7 +7970,7 @@ async function initializeClient$2({ apiKey, } = {}) {
     if (!resolvedApiKey) {
         throw new ConfigurationError("The application could not resolve the requested keys");
     }
-    const client = new OpenAI({ apiKey: resolvedApiKey });
+    const client = new OpenAIClient({ apiKey: resolvedApiKey });
     logger.trace("Initialized OpenAI client");
     return client;
 }
@@ -7404,23 +8029,23 @@ async function createStructuredCompletion(client, { messages, responseSchema, mo
         checks.shift();
     }
     responseFormat.json_schema.schema = jsonSchema;
-    const completion = await client.chat.completions.parse({
+    const completion = (await client.chat.completions.parse({
         messages,
         model,
         response_format: responseFormat,
-    });
+    }));
     logger.var({ assistantReply: completion.choices[0].message.parsed });
     return completion.choices[0].message.parsed;
 }
 async function createTextCompletion(client, { messages, model, }) {
     const logger = getLogger$2();
     logger.trace("Using text output (unstructured)");
-    const completion = await client.chat.completions.create({
+    const completion = (await client.chat.completions.create({
         messages,
         model,
-    });
-    logger.trace(`Assistant reply: ${completion.choices[0]?.message?.content?.length} characters`);
-    return completion.choices[0]?.message?.content || "";
+    }));
+    logger.trace(`Assistant reply: ${completion.choices?.[0]?.message?.content?.length} characters`);
+    return completion.choices?.[0]?.message?.content || "";
 }
 
 class OpenAiProvider {
@@ -7507,19 +8132,139 @@ class OpenAiProvider {
     }
 }
 
-// SDK loader with caching
-let cachedSdk = null;
-async function loadSdk() {
-    if (cachedSdk)
-        return cachedSdk;
-    try {
-        cachedSdk = await import('@openrouter/sdk');
-        return cachedSdk;
+//
+//
+// Constants
+//
+const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+/**
+ * HTTP error carrying the upstream status and parsed API message. The
+ * OpenRouterAdapter classifies errors by reading `.status` / `.statusCode` and
+ * `.message` / `.error.message`, so this shape keeps `classifyError`,
+ * `isTemperatureDeprecationError`, and `isStructuredOutputUnsupportedError`
+ * working unchanged after dropping the SDK.
+ */
+class OpenRouterHttpError extends Error {
+    constructor(status, message, error) {
+        super(message);
+        this.name = "OpenRouterHttpError";
+        this.status = status;
+        this.statusCode = status;
+        this.error = error;
     }
-    catch {
-        throw new ConfigurationError("@openrouter/sdk is required but not installed. Run: npm install @openrouter/sdk");
+}
+//
+//
+// Helpers
+//
+/**
+ * Normalize the snake_case wire response into the camelCase shape the adapter
+ * readers expect (the SDK previously returned camelCase). Only protocol fields
+ * are touched — user content (schema property names, tool argument JSON) is
+ * left untouched.
+ */
+function normalizeResponse(json) {
+    const choices = json.choices;
+    if (Array.isArray(choices)) {
+        for (const choice of choices) {
+            if (choice.finish_reason !== undefined &&
+                choice.finishReason === undefined) {
+                choice.finishReason = choice.finish_reason;
+            }
+            const message = choice.message;
+            if (message?.tool_calls !== undefined &&
+                message.toolCalls === undefined) {
+                message.toolCalls = message.tool_calls;
+            }
+        }
+    }
+    const usage = json.usage;
+    if (usage) {
+        if (usage.promptTokens === undefined)
+            usage.promptTokens = usage.prompt_tokens;
+        if (usage.completionTokens === undefined) {
+            usage.completionTokens = usage.completion_tokens;
+        }
+        if (usage.totalTokens === undefined)
+            usage.totalTokens = usage.total_tokens;
+        const details = usage.completion_tokens_details;
+        if (details?.reasoning_tokens !== undefined &&
+            !usage.completionTokensDetails) {
+            usage.completionTokensDetails = {
+                reasoningTokens: details.reasoning_tokens,
+            };
+        }
+    }
+    return json;
+}
+//
+//
+// Main
+//
+/**
+ * Minimal `fetch`-based client for OpenRouter's OpenAI-compatible Chat
+ * Completions endpoint. Replaces `@openrouter/sdk` — the adapter only needs a
+ * single POST (streaming and non-streaming), header auth, and HTTP error
+ * surfacing.
+ */
+class OpenRouterClient {
+    constructor({ apiKey, baseURL = OPENROUTER_BASE_URL, }) {
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+    }
+    headers() {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+        };
+    }
+    async toError(response) {
+        let message = `OpenRouter request failed with status ${response.status}`;
+        let error;
+        try {
+            const body = (await response.json());
+            if (body?.error?.message) {
+                message = body.error.message;
+                error = body.error;
+            }
+        }
+        catch {
+            // Non-JSON error body; keep the status-based message.
+        }
+        return new OpenRouterHttpError(response.status, message, error);
+    }
+    async chatCompletion(body, { signal } = {}) {
+        const response = await fetch(`${this.baseURL}/chat/completions`, {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify(body),
+            signal,
+        });
+        if (!response.ok)
+            throw await this.toError(response);
+        const json = (await response.json());
+        return normalizeResponse(json);
+    }
+    async *streamChatCompletion(body, { signal } = {}) {
+        const response = await fetch(`${this.baseURL}/chat/completions`, {
+            method: "POST",
+            headers: { ...this.headers(), Accept: "text/event-stream" },
+            // OpenAI-style streams only include usage when explicitly requested.
+            body: JSON.stringify({
+                ...body,
+                stream: true,
+                stream_options: { include_usage: true },
+            }),
+            signal,
+        });
+        if (!response.ok)
+            throw await this.toError(response);
+        if (!response.body)
+            return;
+        yield* parseSseStream(response.body);
     }
 }
+
 // Logger
 const getLogger$1 = () => log$1.lib({ lib: JAYPIE.LIB.LLM });
 // Client initialization
@@ -7529,8 +8274,7 @@ async function initializeClient$1({ apiKey, } = {}) {
     if (!resolvedApiKey) {
         throw new ConfigurationError("The application could not resolve the requested keys");
     }
-    const sdk = await loadSdk();
-    const client = new sdk.OpenRouter({ apiKey: resolvedApiKey });
+    const client = new OpenRouterClient({ apiKey: resolvedApiKey });
     logger.trace("Initialized OpenRouter client");
     return client;
 }
@@ -7610,12 +8354,13 @@ class OpenRouterProvider {
         const client = await this.getClient();
         const messages = prepareMessages(message, options);
         const modelToUse = options?.model || this.model;
-        // Build the request
-        const response = await client.chat.send({
+        // OpenAI-compatible Chat Completions body; messages are already wire-shaped.
+        const response = await client.chatCompletion({
             model: modelToUse,
-            messages: messages,
+            messages,
         });
-        const rawContent = response.choices?.[0]?.message?.content;
+        const choices = response.choices;
+        const rawContent = choices?.[0]?.message?.content;
         // Extract text content - content could be string or array of content items
         const content = typeof rawContent === "string"
             ? rawContent
@@ -7678,7 +8423,7 @@ async function initializeClient({ apiKey, } = {}) {
     if (!resolvedApiKey) {
         throw new ConfigurationError("The application could not resolve the requested keys");
     }
-    const client = new OpenAI({
+    const client = new OpenAIClient({
         apiKey: resolvedApiKey,
         baseURL: PROVIDER.XAI.BASE_URL,
     });