@jaypie/llm 1.3.3 → 1.3.5

package/dist/cjs/index.cjs

@@ -5,8 +5,6 @@ var log$1 = require('@jaypie/logger');
 var v4 = require('zod/v4');
 var kit = require('@jaypie/kit');
 var RandomLib = require('random');
-var openai = require('openai');
-var zod = require('openai/helpers/zod');
 var module$1 = require('module');
 var url = require('url');
 var pdfLib = require('pdf-lib');
@@ -770,6 +768,119 @@ function formatOperateInput(input, options) {
     return [input];
 }
 
+// Keywords a JSON Schema object node can carry that Natural Schema has no
+// representation for. Anything present here (or any other unrecognized key)
+// is dropped silently and logged, never thrown.
+const LOSSY_OBJECT_KEYWORDS = [
+    "$defs",
+    "$id",
+    "$ref",
+    "$schema",
+    "additionalProperties",
+    "const",
+    "default",
+    "description",
+    "format",
+    "maxLength",
+    "maximum",
+    "minLength",
+    "minimum",
+    "multipleOf",
+    "nullable",
+    "allOf",
+    "anyOf",
+    "oneOf",
+    "pattern",
+];
+const KNOWN_KEYWORDS = new Set([
+    "type",
+    "properties",
+    "required",
+    "items",
+    "enum",
+    ...LOSSY_OBJECT_KEYWORDS,
+]);
+/**
+ * Duck-type check for a bare JSON Schema object node: `{ type: "object", properties: {...} }`.
+ * Does not require the OpenAI-style `{ type: "json_schema", ... }` envelope.
+ */
+function isJsonSchema$1(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const schema = value;
+    return (schema.type === "object" &&
+        typeof schema.properties === "object" &&
+        schema.properties !== null &&
+        !Array.isArray(schema.properties));
+}
+/**
+ * Convert a Natural Schema to JSON Schema. Lossless: Natural Schema is a
+ * strict subset of what JSON Schema can express.
+ */
+function naturalSchemaToJsonSchema(schema) {
+    return v4.z.toJSONSchema(naturalZodSchema(schema));
+}
+function logDroppedKeywords(schema, path) {
+    for (const key of Object.keys(schema)) {
+        if (!KNOWN_KEYWORDS.has(key)) {
+            log$1.debug(`[jsonSchemaToNaturalSchema] Dropping unrecognized keyword "${key}" at "${path}"`);
+        }
+        else if (LOSSY_OBJECT_KEYWORDS.includes(key) &&
+            schema[key] !== undefined) {
+            log$1.debug(`[jsonSchemaToNaturalSchema] Dropping unsupported keyword "${key}" at "${path}"`);
+        }
+    }
+}
+function convertNode(schema, path) {
+    logDroppedKeywords(schema, path);
+    if (Array.isArray(schema.enum)) {
+        return schema.enum;
+    }
+    switch (schema.type) {
+        case "string":
+            return String;
+        case "number":
+        case "integer":
+            return Number;
+        case "boolean":
+            return Boolean;
+        case "array": {
+            const items = schema.items;
+            if (typeof items !== "object" || items === null || Array.isArray(items)) {
+                return Array;
+            }
+            return [convertNode(items, `${path}[]`)];
+        }
+        case "object": {
+            const properties = schema.properties;
+            if (!properties || Object.keys(properties).length === 0) {
+                return Object;
+            }
+            const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+            const result = {};
+            for (const [key, value] of Object.entries(properties)) {
+                if (!required.has(key)) {
+                    log$1.debug(`[jsonSchemaToNaturalSchema] Field "${path}.${key}" is optional; Natural Schema has no optional marker — treating as required`);
+                }
+                result[key] = convertNode(value, `${path}.${key}`);
+            }
+            return result;
+        }
+        default:
+            log$1.debug(`[jsonSchemaToNaturalSchema] Unsupported type "${String(schema.type)}" at "${path}"; defaulting to Object`);
+            return Object;
+    }
+}
+/**
+ * Convert a JSON Schema object node to Natural Schema. Lossy: constraints,
+ * descriptions, defaults, unions, and optionality have no Natural Schema
+ * representation. Dropped keywords are logged at debug level, never thrown.
+ */
+function jsonSchemaToNaturalSchema(schema) {
+    return convertNode(schema, "$");
+}
+
 /**
  * Converts a JSON Schema (Draft 2020-12) object to the OpenAPI 3.0 schema subset
  * that Gemini's `responseSchema` accepts. This constrains generation (not just validation)
@@ -1088,6 +1199,45 @@ function repairFormatKeys({ content, format, }) {
     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
@@ -1615,7 +1765,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
             ? [...request.tools]
             : [];
         if (useFallbackStructuredOutput && request.format) {
-            log$1.warn(`[AnthropicAdapter] Using legacy structured_output tool fallback for model ${anthropicRequest.model}; native output_config previously rejected for this model.`);
+            log$1.log.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, " +
@@ -1679,11 +1829,13 @@ class AnthropicAdapter extends BaseProviderAdapter {
     }
     formatOutputSchema(schema) {
         let jsonSchema;
-        // Check if schema is already a JsonObject with type "json_schema"
-        if (typeof schema === "object" &&
+        // Check if schema is already a JsonObject — either the OpenAI-style
+        // `{ type: "json_schema", ... }` envelope or a bare `{ type: "object", properties }` node
+        if ((typeof schema === "object" &&
             schema !== null &&
             !Array.isArray(schema) &&
-            schema.type === "json_schema") {
+            schema.type === "json_schema") ||
+            isJsonSchema$1(schema)) {
             jsonSchema = structuredClone(schema);
             jsonSchema.type = "object"; // Validator does not recognize "json_schema"
         }
@@ -1730,7 +1882,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
             if (wantsStructuredOutput && isStructuredOutputUnsupportedError$1(error)) {
                 const model = anthropicRequest.model;
                 this.rememberModelRejectsStructuredOutput(model);
-                log$1.warn(`[AnthropicAdapter] Model ${model} rejected native output_config; falling back to legacy structured_output tool emulation.`);
+                log$1.log.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));
             }
@@ -2345,6 +2497,10 @@ class BedrockAdapter extends BaseProviderAdapter {
         }));
     }
     formatOutputSchema(schema) {
+        // Bare JSON Schema node: `{ type: "object", properties: {...} }`
+        if (isJsonSchema$1(schema)) {
+            return structuredClone(schema);
+        }
         const zodSchema = schema instanceof v4.z.ZodType
             ? schema
             : naturalZodSchema(schema);
@@ -2793,7 +2949,7 @@ class GoogleAdapter extends BaseProviderAdapter {
             ? [...request.tools]
             : [];
         if (request.format && hasUserTools && !useNativeCombo) {
-            log$1.warn(`[GoogleAdapter] Using legacy structured_output tool fallback for model ${geminiRequest.model}; native responseJsonSchema + tools combo is only available on Gemini 3.`);
+            log$1.log.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, " +
@@ -2881,11 +3037,13 @@ class GoogleAdapter extends BaseProviderAdapter {
     }
     formatOutputSchema(schema) {
         let jsonSchema;
-        // Check if schema is already a JsonObject with type "json_schema"
-        if (typeof schema === "object" &&
+        // Check if schema is already a JsonObject — either the OpenAI-style
+        // `{ type: "json_schema", ... }` envelope or a bare `{ type: "object", properties }` node
+        if ((typeof schema === "object" &&
             schema !== null &&
             !Array.isArray(schema) &&
-            schema.type === "json_schema") {
+            schema.type === "json_schema") ||
+            isJsonSchema$1(schema)) {
             jsonSchema = structuredClone(schema);
             jsonSchema.type = "object";
         }
@@ -2924,7 +3082,7 @@ class GoogleAdapter extends BaseProviderAdapter {
             if (wantsNativeCombo && isStructuredOutputComboUnsupportedError(error)) {
                 const model = geminiRequest.model;
                 this.rememberModelRejectsStructuredOutputCombo(model);
-                log$1.warn(`[GoogleAdapter] Model ${model} rejected native responseJsonSchema + tools combo; falling back to legacy structured_output tool emulation.`);
+                log$1.log.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,
@@ -3508,6 +3666,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: v4.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.)
@@ -3524,19 +3882,19 @@ function isReasoningModel(model) {
 // Constants
 //
 const RETRYABLE_ERROR_TYPES = [
-    openai.APIConnectionError,
-    openai.APIConnectionTimeoutError,
-    openai.InternalServerError,
+    APIConnectionError,
+    APIConnectionTimeoutError,
+    InternalServerError$1,
 ];
 const NOT_RETRYABLE_ERROR_TYPES = [
-    openai.APIUserAbortError,
-    openai.AuthenticationError,
-    openai.BadRequestError,
-    openai.ConflictError,
-    openai.NotFoundError,
-    openai.PermissionDeniedError,
-    openai.RateLimitError,
-    openai.UnprocessableEntityError,
+    APIUserAbortError,
+    AuthenticationError$1,
+    BadRequestError$1,
+    ConflictError,
+    NotFoundError$1,
+    PermissionDeniedError$1,
+    RateLimitError$1,
+    UnprocessableEntityError,
 ];
 // Models known not to accept `temperature`.
 // Patterns (not exact names) so dated variants and future releases are covered
@@ -3549,7 +3907,7 @@ const MODELS_WITHOUT_TEMPERATURE$1 = [
 function isTemperatureDeprecationError$1(error) {
     if (!error || typeof error !== "object")
         return false;
-    if (!(error instanceof openai.BadRequestError) &&
+    if (!(error instanceof BadRequestError$1) &&
         error.status !== 400) {
         return false;
     }
@@ -3652,21 +4010,35 @@ class OpenAiAdapter extends BaseProviderAdapter {
             schema.type === "json_schema") {
             return schema;
         }
-        // Convert NaturalSchema to Zod schema if needed
-        const zodSchema = schema instanceof v4.z.ZodType
-            ? schema
-            : naturalZodSchema(schema);
-        const responseFormat = zod.zodResponseFormat(zodSchema, "response");
-        // 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 = {
-            ...v4.z.toJSONSchema(zodSchema),
-        };
-        delete jsonSchema.$schema;
+        // Bare JSON Schema node: `{ type: "object", properties: {...} }`
+        // Skip the zod round-trip and use it directly (still needs the
+        // additionalProperties + envelope treatment below).
+        let jsonSchema;
+        let name = "response";
+        let strict = true;
+        if (isJsonSchema$1(schema)) {
+            jsonSchema = { ...structuredClone(schema) };
+            delete jsonSchema.$schema;
+        }
+        else {
+            // Convert NaturalSchema to Zod schema if needed
+            const zodSchema = schema instanceof v4.z.ZodType
+                ? schema
+                : naturalZodSchema(schema);
+            const responseFormat = zodResponseFormat(zodSchema, "response");
+            // 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.
+            jsonSchema = {
+                ...v4.z.toJSONSchema(zodSchema),
+            };
+            delete jsonSchema.$schema;
+            name = responseFormat.json_schema.name;
+            strict = responseFormat.json_schema.strict;
+        }
         // OpenAI requires additionalProperties to be false on all objects
         const checks = [jsonSchema];
         while (checks.length > 0) {
@@ -3682,10 +4054,10 @@ class OpenAiAdapter extends BaseProviderAdapter {
             checks.shift();
         }
         return {
-            name: responseFormat.json_schema.name,
+            name,
             schema: jsonSchema,
-            strict: responseFormat.json_schema.strict,
-            type: responseFormat.type,
+            strict,
+            type: "json_schema",
         };
     }
     //
@@ -3903,7 +4275,7 @@ class OpenAiAdapter extends BaseProviderAdapter {
     //
     classifyError(error) {
         // Check for rate limit error
-        if (error instanceof openai.RateLimitError) {
+        if (error instanceof RateLimitError$1) {
             return {
                 error,
                 category: ErrorCategory.RateLimit,
@@ -4121,7 +4493,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;
 /**
@@ -4285,11 +4699,13 @@ class OpenRouterAdapter extends BaseProviderAdapter {
     }
     formatOutputSchema(schema) {
         let jsonSchema;
-        // Check if schema is already a JsonObject with type "json_schema"
-        if (typeof schema === "object" &&
+        // Check if schema is already a JsonObject — either the OpenAI-style
+        // `{ type: "json_schema", ... }` envelope or a bare `{ type: "object", properties }` node
+        if ((typeof schema === "object" &&
             schema !== null &&
             !Array.isArray(schema) &&
-            schema.type === "json_schema") {
+            schema.type === "json_schema") ||
+            isJsonSchema$1(schema)) {
             jsonSchema = structuredClone(schema);
             jsonSchema.type = "object"; // Normalize type
         }
@@ -4324,7 +4740,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;
             }
@@ -4341,7 +4757,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;
                 }
@@ -4354,7 +4770,7 @@ class OpenRouterAdapter extends BaseProviderAdapter {
                 this.rememberModelRejectsStructuredOutput(model);
                 log$1.log.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;
         }
@@ -4364,31 +4780,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
@@ -4420,15 +4823,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
@@ -4877,7 +5274,7 @@ const TRANSIENT_INGEST_MESSAGE_PATTERNS = [
     "failed to ingest inline file bytes",
 ];
 function isTransientIngestError(error) {
-    if (!(error instanceof openai.BadRequestError))
+    if (!(error instanceof BadRequestError$1))
         return false;
     const message = (error.message ?? "").toLowerCase();
     return TRANSIENT_INGEST_MESSAGE_PATTERNS.some((pattern) => message.includes(pattern));
@@ -5069,7 +5466,7 @@ const requireModule = typeof __filename !== "undefined"
     ? module$1.createRequire(url.pathToFileURL(__filename).href)
     : module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 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
@@ -5077,7 +5474,7 @@ let cachedSdk$4 = null;
  */
 function resolveLlmObs() {
     if (resolved) {
-        return cachedSdk$4;
+        return cachedSdk$1;
     }
     resolved = true;
     try {
@@ -5087,13 +5484,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;
 }
 //
 //
@@ -7007,19 +7404,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 errors.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.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 // Client initialization
@@ -7029,8 +7532,7 @@ async function initializeClient$5({ apiKey, } = {}) {
     if (!resolvedApiKey) {
         throw new errors.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;
 }
@@ -7130,6 +7632,7 @@ async function createStructuredCompletion$1(client, messages, model, responseSch
     [exports.LlmMessageRole.Assistant]: PROVIDER.ANTHROPIC.ROLE.ASSISTANT,
     [exports.LlmMessageRole.Developer]: PROVIDER.ANTHROPIC.ROLE.SYSTEM,
 });
+/* eslint-enable @typescript-eslint/no-namespace */
 
 // Main class implementation
 class AnthropicProvider {
@@ -7218,13 +7721,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 errors.ConfigurationError("@aws-sdk/client-bedrock-runtime is required but not installed. Run: npm install @aws-sdk/client-bedrock-runtime");
@@ -7234,7 +7737,7 @@ const getLogger$4 = () => log$1.log.lib({ lib: kit.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;
@@ -7299,19 +7802,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 errors.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.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 // Client initialization
@@ -7321,8 +7961,7 @@ async function initializeClient$3({ apiKey, } = {}) {
     if (!resolvedApiKey) {
         throw new errors.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;
 }
@@ -7471,7 +8110,7 @@ async function initializeClient$2({ apiKey, } = {}) {
     if (!resolvedApiKey) {
         throw new errors.ConfigurationError("The application could not resolve the requested keys");
     }
-    const client = new openai.OpenAI({ apiKey: resolvedApiKey });
+    const client = new OpenAIClient({ apiKey: resolvedApiKey });
     logger.trace("Initialized OpenAI client");
     return client;
 }
@@ -7513,7 +8152,7 @@ async function createStructuredCompletion(client, { messages, responseSchema, mo
     const zodSchema = responseSchema instanceof v4.z.ZodType
         ? responseSchema
         : naturalZodSchema(responseSchema);
-    const responseFormat = zod.zodResponseFormat(zodSchema, "response");
+    const responseFormat = zodResponseFormat(zodSchema, "response");
     const jsonSchema = v4.z.toJSONSchema(zodSchema);
     // Temporary hack because OpenAI requires additional_properties to be false on all objects
     const checks = [jsonSchema];
@@ -7530,23 +8169,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 {
@@ -7633,19 +8272,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 errors.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.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 // Client initialization
@@ -7655,8 +8414,7 @@ async function initializeClient$1({ apiKey, } = {}) {
     if (!resolvedApiKey) {
         throw new errors.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;
 }
@@ -7736,12 +8494,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
@@ -7804,7 +8563,7 @@ async function initializeClient({ apiKey, } = {}) {
     if (!resolvedApiKey) {
         throw new errors.ConfigurationError("The application could not resolve the requested keys");
     }
-    const client = new openai.OpenAI({
+    const client = new OpenAIClient({
         apiKey: resolvedApiKey,
         baseURL: PROVIDER.XAI.BASE_URL,
     });
@@ -8418,6 +9177,8 @@ exports.isLlmOperateInput = isLlmOperateInput;
 exports.isLlmOperateInputContent = isLlmOperateInputContent;
 exports.isLlmOperateInputFile = isLlmOperateInputFile;
 exports.isLlmOperateInputImage = isLlmOperateInputImage;
+exports.jsonSchemaToNaturalSchema = jsonSchemaToNaturalSchema;
+exports.naturalSchemaToJsonSchema = naturalSchemaToJsonSchema;
 exports.toolkit = toolkit;
 exports.tools = tools;
 //# sourceMappingURL=index.cjs.map