@jaypie/llm 1.3.3 → 1.3.5

package/dist/esm/src/index.d.ts

@@ -0,0 +1,17 @@
+export { default as Llm } from "./Llm.js";
+export * as LLM from "./constants.js";
+export type { LlmFallbackConfig, LlmHistory, LlmInputContent, LlmInputContentFile, LlmInputContentImage, LlmInputContentText, LlmInputMessage, LlmMessageOptions, LlmOperateInput, LlmOperateInputContent, LlmOperateInputFile, LlmOperateInputImage, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProvider, } from "./types/LlmProvider.interface.js";
+export { LlmMessageRole, LlmMessageType, } from "./types/LlmProvider.interface.js";
+export { isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, } from "./types/LlmOperateInput.guards.js";
+export type { LlmTool } from "./types/LlmTool.interface.js";
+export type { LlmStreamChunk, LlmStreamChunkDone, LlmStreamChunkError, LlmStreamChunkText, LlmStreamChunkToolCall, LlmStreamChunkToolResult, } from "./types/LlmStreamChunk.interface.js";
+export { LlmStreamChunkType } from "./types/LlmStreamChunk.interface.js";
+export { JaypieToolkit, toolkit, Toolkit, tools } from "./tools/index.js";
+export { extractReasoning } from "./util/extractReasoning.js";
+export { jsonSchemaToNaturalSchema, naturalSchemaToJsonSchema, } from "./util/jsonSchema.js";
+export { BedrockProvider } from "./providers/bedrock/index.js";
+/** @deprecated Use GoogleProvider — "Google" is the provider; Gemini is the model family */
+export { GoogleProvider as GeminiProvider } from "./providers/google/index.js";
+export { GoogleProvider } from "./providers/google/index.js";
+export { OpenRouterProvider } from "./providers/openrouter/index.js";
+export { XaiProvider } from "./providers/xai/index.js";

package/dist/esm/{operate → src/operate}/adapters/AnthropicAdapter.d.ts

@@ -1,10 +1,10 @@
-import type { Anthropic } from "@anthropic-ai/sdk";
 import { JsonObject, NaturalSchema } from "@jaypie/types";
 import { z } from "zod/v4";
 import { Toolkit } from "../../tools/Toolkit.class.js";
 import { LlmHistory, LlmOperateOptions, LlmUsageItem } from "../../types/LlmProvider.interface.js";
 import { LlmStreamChunk } from "../../types/LlmStreamChunk.interface.js";
 import { ClassifiedError, OperateRequest, ParsedResponse, ProviderToolDefinition, StandardToolCall, StandardToolResult } from "../types.js";
+import { Anthropic } from "../../providers/anthropic/types.js";
 import { BaseProviderAdapter } from "./ProviderAdapter.interface.js";
 /**
  * Local extension of the SDK's `MessageCreateParams` to carry

package/dist/{cjs → esm/src}/operate/adapters/OpenRouterAdapter.d.ts

@@ -129,7 +129,14 @@ export declare class OpenRouterAdapter extends BaseProviderAdapter {
      * camelCase shape, forwarding only the fields we care about (the SDK
      * silently strips unknown fields).
      */
-    private toSdkChatParams;
+    /**
+     * 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.
+     */
+    private toWireBody;
     /**
      * Rebuild a structured-output request without `response_format`, swapping in
      * the legacy fake-tool emulation. Used as a runtime fallback when a model

package/dist/esm/src/providers/anthropic/client.d.ts

@@ -0,0 +1,54 @@
+import { Anthropic } from "./types.js";
+export declare class AnthropicApiError extends Error {
+    readonly status: number;
+    readonly error?: {
+        message?: string;
+    };
+    constructor(status: number, message: string, error?: {
+        message?: string;
+    });
+}
+export declare class BadRequestError extends AnthropicApiError {
+}
+export declare class AuthenticationError extends AnthropicApiError {
+}
+export declare class PermissionDeniedError extends AnthropicApiError {
+}
+export declare class NotFoundError extends AnthropicApiError {
+}
+export declare class RateLimitError extends AnthropicApiError {
+}
+export declare class InternalServerError extends AnthropicApiError {
+}
+export declare class APIConnectionError extends AnthropicApiError {
+}
+export interface AnthropicClientOptions {
+    apiKey: string;
+    baseURL?: string;
+}
+export interface CreateOptions {
+    signal?: AbortSignal;
+}
+interface MessagesApi {
+    create(params: Anthropic.MessageCreateParamsStreaming, options?: CreateOptions): Promise<AsyncIterable<Anthropic.MessageStreamEvent>>;
+    create(params: Anthropic.MessageCreateParams, options?: CreateOptions): Promise<Anthropic.Message>;
+}
+/**
+ * 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.
+ */
+export declare class AnthropicClient {
+    private readonly apiKey;
+    private readonly baseURL;
+    readonly messages: MessagesApi;
+    constructor({ apiKey, baseURL, }: AnthropicClientOptions);
+    private headers;
+    private toError;
+    private createMessage;
+    private createStream;
+}
+export {};

package/dist/esm/src/providers/anthropic/types.d.ts

@@ -0,0 +1,129 @@
+import { JsonObject } from "@jaypie/types";
+import { LlmMessageRole } from "../../types/LlmProvider.interface.js";
+export declare const ROLE_MAP: Record<LlmMessageRole, string>;
+export declare namespace Anthropic {
+    interface TextBlock {
+        type: "text";
+        text: string;
+    }
+    interface ToolUseBlock {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input: unknown;
+    }
+    interface ThinkingBlock {
+        type: "thinking";
+        thinking: string;
+        signature?: string;
+    }
+    type ContentBlock = TextBlock | ToolUseBlock | ThinkingBlock;
+    interface Base64ImageSource {
+        type: "base64";
+        media_type: string;
+        data: string;
+    }
+    interface Base64PDFSource {
+        type: "base64";
+        media_type: string;
+        data: string;
+    }
+    interface ToolResultBlockParam {
+        type: "tool_result";
+        tool_use_id: string;
+        content: string;
+    }
+    type ContentBlockParam = {
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        source: Base64ImageSource | {
+            type: "url";
+            url: string;
+        };
+    } | {
+        type: "document";
+        source: Base64PDFSource | {
+            type: "url";
+            url: string;
+        };
+    } | ToolUseBlock | ToolResultBlockParam;
+    interface MessageParam {
+        role: "user" | "assistant";
+        content: string | ContentBlockParam[];
+    }
+    namespace Messages {
+        namespace Tool {
+            type InputSchema = JsonObject;
+        }
+    }
+    interface Tool {
+        name: string;
+        description?: string;
+        input_schema: Messages.Tool.InputSchema;
+        type?: "custom";
+    }
+    interface Usage {
+        input_tokens: number;
+        output_tokens: number;
+        thinking_tokens?: number;
+    }
+    interface MessageCreateParams {
+        model: string;
+        messages: MessageParam[];
+        max_tokens: number;
+        system?: string;
+        tools?: Tool[];
+        tool_choice?: {
+            type: "auto" | "any" | "tool";
+            name?: string;
+        };
+        temperature?: number;
+        stream?: boolean;
+        [key: string]: unknown;
+    }
+    type MessageCreateParamsStreaming = MessageCreateParams & {
+        stream: true;
+    };
+    interface Message {
+        id: string;
+        type: "message";
+        role: "assistant";
+        model: string;
+        content: ContentBlock[];
+        stop_reason: string | null;
+        stop_sequence?: string | null;
+        usage: Usage;
+    }
+    type ContentBlockDelta = {
+        type: "text_delta";
+        text: string;
+    } | {
+        type: "input_json_delta";
+        partial_json: string;
+    };
+    type MessageStreamEvent = {
+        type: "message_start";
+        message: Message;
+    } | {
+        type: "content_block_start";
+        index: number;
+        content_block: ContentBlock;
+    } | {
+        type: "content_block_delta";
+        index: number;
+        delta: ContentBlockDelta;
+    } | {
+        type: "content_block_stop";
+        index: number;
+    } | {
+        type: "message_delta";
+        delta: Record<string, unknown>;
+        usage: Usage;
+    } | {
+        type: "message_stop";
+    } | {
+        type: "ping";
+    };
+}

package/dist/{cjs → esm/src}/providers/anthropic/utils.d.ts

@@ -1,15 +1,15 @@
 import { createLogger } from "@jaypie/logger";
-import type Anthropic from "@anthropic-ai/sdk";
 import { LlmMessageOptions } from "../../types/LlmProvider.interface.js";
 import { z } from "zod/v4";
 import { JsonObject, NaturalSchema } from "@jaypie/types";
-export declare function loadSdk(): Promise<typeof import("@anthropic-ai/sdk")>;
+import { AnthropicClient } from "./client.js";
+import type { Anthropic } from "./types.js";
 export declare const getLogger: () => ReturnType<typeof createLogger>;
 export declare function initializeClient({ apiKey, }?: {
     apiKey?: string;
-}): Promise<Anthropic>;
+}): Promise<AnthropicClient>;
 export declare function formatSystemMessage(systemPrompt: string, { data, placeholders }?: Pick<LlmMessageOptions, "data" | "placeholders">): string;
 export declare function formatUserMessage(message: string, { data, placeholders }?: Pick<LlmMessageOptions, "data" | "placeholders">): Anthropic.MessageParam;
 export declare function prepareMessages(message: string, { data, placeholders }?: LlmMessageOptions): Anthropic.MessageParam[];
-export declare function createTextCompletion(client: Anthropic, messages: Anthropic.MessageParam[], model: string, systemMessage?: string): Promise<string>;
-export declare function createStructuredCompletion(client: Anthropic, messages: Anthropic.MessageParam[], model: string, responseSchema: z.ZodType | NaturalSchema, systemMessage?: string): Promise<JsonObject>;
+export declare function createTextCompletion(client: AnthropicClient, messages: Anthropic.MessageParam[], model: string, systemMessage?: string): Promise<string>;
+export declare function createStructuredCompletion(client: AnthropicClient, messages: Anthropic.MessageParam[], model: string, responseSchema: z.ZodType | NaturalSchema, systemMessage?: string): Promise<JsonObject>;

package/dist/esm/src/providers/google/client.d.ts

@@ -0,0 +1,44 @@
+import { GeminiContent, GeminiGenerateContentConfig, GeminiRawResponse } from "./types.js";
+export interface GoogleClientOptions {
+    apiKey: string;
+    baseURL?: string;
+}
+export interface GenerateContentParams {
+    model: string;
+    contents: GeminiContent[];
+    config?: GeminiGenerateContentConfig;
+}
+export interface GenerateContentOptions {
+    signal?: AbortSignal;
+}
+/**
+ * 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.
+ */
+export declare class GoogleHttpError extends Error {
+    readonly status: number;
+    readonly code: number;
+    constructor(status: number, message: string);
+}
+/**
+ * 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.
+ */
+export declare class GoogleClient {
+    private readonly apiKey;
+    private readonly baseURL;
+    readonly models: {
+        generateContent: (params: GenerateContentParams, options?: GenerateContentOptions) => Promise<GeminiRawResponse>;
+        generateContentStream: (params: GenerateContentParams, options?: GenerateContentOptions) => Promise<AsyncIterable<GeminiRawResponse>>;
+    };
+    constructor({ apiKey, baseURL }: GoogleClientOptions);
+    private headers;
+    private toError;
+    private generateContent;
+    private generateContentStream;
+}

package/dist/esm/{providers → src/providers}/google/utils.d.ts

@@ -1,11 +1,10 @@
 import { createLogger } from "@jaypie/logger";
-import type { GoogleGenAI } from "@google/genai";
 import { LlmMessageOptions } from "../../types/LlmProvider.interface.js";
-export declare function loadSdk(): Promise<typeof import("@google/genai")>;
+import { GoogleClient } from "./client.js";
 export declare const getLogger: () => ReturnType<typeof createLogger>;
 export declare function initializeClient({ apiKey, }?: {
     apiKey?: string;
-}): Promise<GoogleGenAI>;
+}): Promise<GoogleClient>;
 export interface ChatMessage {
     role: "user" | "model";
     content: string;

package/dist/esm/src/providers/openai/client.d.ts

@@ -0,0 +1,74 @@
+import { JsonObject } from "@jaypie/types";
+export declare class OpenAiApiError extends Error {
+    readonly status: number;
+    readonly error?: {
+        message?: string;
+    };
+    constructor(status: number, message: string, error?: {
+        message?: string;
+    });
+}
+export declare class BadRequestError extends OpenAiApiError {
+}
+export declare class AuthenticationError extends OpenAiApiError {
+}
+export declare class PermissionDeniedError extends OpenAiApiError {
+}
+export declare class NotFoundError extends OpenAiApiError {
+}
+export declare class ConflictError extends OpenAiApiError {
+}
+export declare class UnprocessableEntityError extends OpenAiApiError {
+}
+export declare class RateLimitError extends OpenAiApiError {
+}
+export declare class InternalServerError extends OpenAiApiError {
+}
+export declare class APIConnectionError extends OpenAiApiError {
+}
+export declare class APIConnectionTimeoutError extends APIConnectionError {
+}
+export declare class APIUserAbortError extends OpenAiApiError {
+}
+export interface OpenAIClientOptions {
+    apiKey: string;
+    baseURL?: string;
+}
+export interface RequestOptions {
+    signal?: AbortSignal;
+}
+interface ResponsesApi {
+    create(params: Record<string, unknown> & {
+        stream: true;
+    }, options?: RequestOptions): Promise<AsyncIterable<Record<string, unknown>>>;
+    create(params: Record<string, unknown>, options?: RequestOptions): Promise<JsonObject>;
+}
+interface ChatCompletionsApi {
+    create(params: Record<string, unknown>, options?: RequestOptions): Promise<JsonObject>;
+    parse(params: Record<string, unknown>, options?: RequestOptions): Promise<JsonObject>;
+}
+/**
+ * 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`.
+ */
+export declare class OpenAIClient {
+    private readonly apiKey;
+    private readonly baseURL;
+    readonly responses: ResponsesApi;
+    readonly chat: {
+        completions: ChatCompletionsApi;
+    };
+    constructor({ apiKey, baseURL }: OpenAIClientOptions);
+    private headers;
+    private post;
+    private toError;
+    private createResponse;
+    private createResponseStream;
+    private chatCompletion;
+}
+export {};

package/dist/esm/src/providers/openai/responseFormat.d.ts

@@ -0,0 +1,17 @@
+import { JsonObject } from "@jaypie/types";
+import { z } from "zod/v4";
+export interface JsonSchemaResponseFormat {
+    type: "json_schema";
+    json_schema: {
+        name: string;
+        strict: boolean;
+        schema: JsonObject;
+    };
+}
+/**
+ * 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`).
+ */
+export declare function zodResponseFormat(schema: z.ZodType, name: string): JsonSchemaResponseFormat;

package/dist/{cjs → esm/src}/providers/openai/utils.d.ts

@@ -1,12 +1,12 @@
 import { createLogger } from "@jaypie/logger";
 import { JsonObject, NaturalSchema } from "@jaypie/types";
-import { OpenAI } from "openai";
 import { z } from "zod/v4";
 import { LlmMessageOptions } from "../../types/LlmProvider.interface.js";
+import { OpenAIClient } from "./client.js";
 export declare const getLogger: () => ReturnType<typeof createLogger>;
 export declare function initializeClient({ apiKey, }?: {
     apiKey?: string;
-}): Promise<OpenAI>;
+}): Promise<OpenAIClient>;
 export interface ChatMessage {
     role: "user" | "developer";
     content: string;
@@ -14,12 +14,12 @@ export interface ChatMessage {
 export declare function formatSystemMessage(systemPrompt: string, { data, placeholders }?: Pick<LlmMessageOptions, "data" | "placeholders">): ChatMessage;
 export declare function formatUserMessage(message: string, { data, placeholders }?: Pick<LlmMessageOptions, "data" | "placeholders">): ChatMessage;
 export declare function prepareMessages(message: string, { system, data, placeholders }?: LlmMessageOptions): ChatMessage[];
-export declare function createStructuredCompletion(client: OpenAI, { messages, responseSchema, model, }: {
+export declare function createStructuredCompletion(client: OpenAIClient, { messages, responseSchema, model, }: {
     messages: ChatMessage[];
     responseSchema: z.ZodType | NaturalSchema;
     model: string;
 }): Promise<JsonObject>;
-export declare function createTextCompletion(client: OpenAI, { messages, model, }: {
+export declare function createTextCompletion(client: OpenAIClient, { messages, model, }: {
     messages: ChatMessage[];
     model: string;
 }): Promise<string>;

package/dist/esm/src/providers/openrouter/client.d.ts

@@ -0,0 +1,40 @@
+import { JsonObject } from "@jaypie/types";
+export interface OpenRouterClientOptions {
+    apiKey: string;
+    baseURL?: string;
+}
+export interface ChatCompletionOptions {
+    signal?: AbortSignal;
+}
+/**
+ * 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.
+ */
+export declare class OpenRouterHttpError extends Error {
+    readonly status: number;
+    readonly statusCode: number;
+    readonly error?: {
+        message?: string;
+    };
+    constructor(status: number, message: string, error?: {
+        message?: string;
+    });
+}
+/**
+ * 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.
+ */
+export declare class OpenRouterClient {
+    private readonly apiKey;
+    private readonly baseURL;
+    constructor({ apiKey, baseURL, }: OpenRouterClientOptions);
+    private headers;
+    private toError;
+    chatCompletion(body: Record<string, unknown>, { signal }?: ChatCompletionOptions): Promise<JsonObject>;
+    streamChatCompletion(body: Record<string, unknown>, { signal }?: ChatCompletionOptions): AsyncIterable<JsonObject>;
+}

package/dist/{cjs → esm/src}/providers/openrouter/utils.d.ts

@@ -1,11 +1,10 @@
 import { createLogger } from "@jaypie/logger";
-import type { OpenRouter } from "@openrouter/sdk";
 import { LlmMessageOptions } from "../../types/LlmProvider.interface.js";
-export declare function loadSdk(): Promise<typeof import("@openrouter/sdk")>;
+import { OpenRouterClient } from "./client.js";
 export declare const getLogger: () => ReturnType<typeof createLogger>;
 export declare function initializeClient({ apiKey, }?: {
     apiKey?: string;
-}): Promise<OpenRouter>;
+}): Promise<OpenRouterClient>;
 export declare function getDefaultModel(): string;
 export interface ChatMessage {
     role: "system" | "user" | "assistant";

package/dist/esm/{providers → src/providers}/xai/utils.d.ts

@@ -1,6 +1,6 @@
 import { createLogger } from "@jaypie/logger";
-import { OpenAI } from "openai";
+import { OpenAIClient } from "../openai/client.js";
 export declare const getLogger: () => ReturnType<typeof createLogger>;
 export declare function initializeClient({ apiKey, }?: {
     apiKey?: string;
-}): Promise<OpenAI>;
+}): Promise<OpenAIClient>;

package/dist/esm/{util → src/util}/index.d.ts

@@ -3,10 +3,12 @@ export * from "./extractReasoning.js";
 export * from "./fillFormatArrays.js";
 export * from "./formatOperateInput.js";
 export * from "./formatOperateMessage.js";
+export * from "./jsonSchema.js";
 export * from "./jsonSchemaToOpenApi3.js";
 export * from "./logger.js";
 export * from "./maxTurnsFromOptions.js";
 export * from "./naturalZodSchema.js";
 export * from "./random.js";
 export * from "./repairFormatKeys.js";
+export * from "./sse.js";
 export * from "./tryParseNumber.js";

package/dist/esm/src/util/jsonSchema.d.ts

@@ -0,0 +1,17 @@
+import { JsonObject, NaturalSchema } from "@jaypie/types";
+/**
+ * Duck-type check for a bare JSON Schema object node: `{ type: "object", properties: {...} }`.
+ * Does not require the OpenAI-style `{ type: "json_schema", ... }` envelope.
+ */
+export declare function isJsonSchema(value: unknown): value is JsonObject;
+/**
+ * Convert a Natural Schema to JSON Schema. Lossless: Natural Schema is a
+ * strict subset of what JSON Schema can express.
+ */
+export declare function naturalSchemaToJsonSchema(schema: NaturalSchema): JsonObject;
+/**
+ * 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.
+ */
+export declare function jsonSchemaToNaturalSchema(schema: JsonObject): NaturalSchema;

package/dist/esm/src/util/sse.d.ts

@@ -0,0 +1,12 @@
+import { JsonObject } from "@jaypie/types";
+/**
+ * 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.
+ */
+export declare function parseSseStream(body: ReadableStream<Uint8Array>, { doneSentinel }?: {
+    doneSentinel?: string;
+}): AsyncIterable<JsonObject>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaypie/llm",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "Large language model utilities",
   "repository": {
     "type": "git",
@@ -41,41 +41,26 @@
   "dependencies": {
     "@jaypie/aws": "*",
     "@jaypie/errors": "*",
-    "openai": "^6.9.1",
     "openmeteo": "^1.2.1",
     "pdf-lib": "^1.17.1",
     "random": "^5.3.0",
-    "z-schema": "^6.0.2",
     "zod": "^4.1.13"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.71.0",
     "@aws-sdk/client-bedrock-runtime": "^3.1045.0",
-    "@google/genai": "^1.30.0",
     "@jaypie/types": "*",
-    "@openrouter/sdk": "^0.1.27",
+    "@types/node": "^22.13.1",
+    "dotenv": "^17.4.2",
     "rollup-plugin-dts": "^6.1.1"
   },
   "peerDependencies": {
-    "@anthropic-ai/sdk": "^0.71.0",
     "@aws-sdk/client-bedrock-runtime": "^3.1045.0",
-    "@google/genai": "^1.30.0",
     "@jaypie/kit": "*",
-    "@jaypie/logger": "*",
-    "@openrouter/sdk": "^0.1.27"
+    "@jaypie/logger": "*"
   },
   "peerDependenciesMeta": {
-    "@anthropic-ai/sdk": {
-      "optional": true
-    },
     "@aws-sdk/client-bedrock-runtime": {
       "optional": true
-    },
-    "@google/genai": {
-      "optional": true
-    },
-    "@openrouter/sdk": {
-      "optional": true
     }
   },
   "publishConfig": {

package/dist/cjs/providers/anthropic/types.d.ts

@@ -1,2 +0,0 @@
-import { LlmMessageRole } from "../../types/LlmProvider.interface.js";
-export declare const ROLE_MAP: Record<LlmMessageRole, string>;

package/dist/esm/providers/anthropic/types.d.ts

@@ -1,2 +0,0 @@
-import { LlmMessageRole } from "../../types/LlmProvider.interface.js";
-export declare const ROLE_MAP: Record<LlmMessageRole, string>;