@diabolicallabs/llm-client 0.1.0

package/README.md

@@ -0,0 +1,120 @@
+# @diabolicallabs/llm-client
+
+Unified LLM API across Anthropic, OpenAI, Google Gemini, and DeepSeek. Single interface for completion, streaming, and structured output. All provider errors are normalized into a consistent `LlmError` shape. © Diabolical Labs
+
+**Pre-1.0. APIs may change between minor versions.**
+
+## Status
+
+**Published — v0.1.0.** All four providers are implemented. A fifth provider (Perplexity) is a stub and will be implemented in a future release.
+
+## Install
+
+```bash
+# .npmrc must point @diabolicallabs scope at GitHub Packages
+pnpm add @diabolicallabs/llm-client
+```
+
+Consumer `.npmrc`:
+
+```
+@diabolicallabs:registry=https://npm.pkg.github.com
+//npm.pkg.github.com/:_authToken=${GITHUB_TOKEN}
+```
+
+## Usage
+
+```typescript
+import { createClient, createClientFromEnv } from '@diabolicallabs/llm-client';
+
+// From explicit config
+const client = createClient({
+  provider: 'anthropic',
+  model: 'claude-sonnet-4-6',
+  apiKey: process.env.ANTHROPIC_API_KEY!,
+});
+
+// From environment variables
+const client = createClientFromEnv('anthropic', 'claude-sonnet-4-6');
+
+// Non-streaming completion
+const response = await client.complete([
+  { role: 'user', content: 'Hello' },
+]);
+console.log(response.content, response.usage);
+
+// Streaming
+for await (const chunk of client.stream([{ role: 'user', content: 'Hello' }])) {
+  process.stdout.write(chunk.token);
+}
+
+// Structured output (Zod schema)
+import { z } from 'zod';
+const schema = z.object({ name: z.string(), score: z.number() });
+const result = await client.structured(messages, schema);
+// result.data is typed as { name: string; score: number }
+```
+
+## Provider universe
+
+| Provider | Status | Env var |
+|---|---|---|
+| `anthropic` | Implemented | `ANTHROPIC_API_KEY` |
+| `openai` | Implemented | `OPENAI_API_KEY` |
+| `google` | Implemented | `GOOGLE_AI_API_KEY` |
+| `deepseek` | Implemented | `DEEPSEEK_API_KEY` |
+| `perplexity` | Stub — throws `LlmError` | — |
+
+## API
+
+### `createClient(config: LlmClientConfig): LlmClient`
+
+Creates an `LlmClient` for the given provider.
+
+### `createClientFromEnv(provider, model, overrides?): LlmClient`
+
+Reads the API key from the environment automatically:
+- `anthropic` → `ANTHROPIC_API_KEY`
+- `openai` → `OPENAI_API_KEY`
+- `google` → `GOOGLE_AI_API_KEY`
+- `deepseek` → `DEEPSEEK_API_KEY`
+
+### `LlmClient` interface
+
+| Method | Description |
+|---|---|
+| `complete(messages, options?)` | Non-streaming completion. Returns `LlmResponse`. |
+| `stream(messages, options?)` | Streaming — async generator of `LlmStreamChunk`. Final chunk includes `usage`. |
+| `structured(messages, schema, options?)` | Structured output validated against a Zod schema. Returns `LlmStructuredResponse<T>`. |
+
+## Error handling
+
+All provider errors are normalized into `LlmError`:
+
+```typescript
+import { LlmError } from '@diabolicallabs/llm-client';
+
+try {
+  const response = await client.complete(messages);
+} catch (err) {
+  if (err instanceof LlmError) {
+    console.error(err.provider, err.statusCode, err.retryable);
+  }
+}
+```
+
+Retryable errors (429, 5xx, network failures) are retried automatically with exponential backoff and full jitter before throwing.
+
+## Token normalization
+
+All providers return `LlmUsage` in a consistent shape regardless of the underlying API's field names:
+
+```typescript
+interface LlmUsage {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  cacheCreationTokens?: number; // Anthropic prompt cache only
+  cacheReadTokens?: number;     // Anthropic prompt cache only
+}
+```

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Core type definitions for @diabolicallabs/llm-client.
+ * These are the stable public API surface — implementation is in Week 2.
+ * Types here match the spec in briefs/brief-platform.md §4.1 exactly.
+ */
+interface LlmMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+interface LlmClientConfig {
+    provider: 'anthropic' | 'openai' | 'gemini' | 'deepseek' | 'perplexity';
+    model: string;
+    apiKey: string;
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxTokens?: number;
+    temperature?: number;
+    timeoutMs?: number;
+}
+interface LlmUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+}
+interface LlmResponse {
+    content: string;
+    model: string;
+    usage: LlmUsage;
+    latencyMs: number;
+}
+interface LlmStreamChunk {
+    token: string;
+    usage?: LlmUsage;
+}
+declare class LlmError extends Error {
+    readonly name = "LlmError";
+    readonly provider: string;
+    readonly statusCode: number | undefined;
+    readonly retryable: boolean;
+    readonly cause: unknown;
+    constructor(opts: {
+        message: string;
+        provider: string;
+        statusCode?: number;
+        retryable: boolean;
+        cause?: unknown;
+    });
+}
+type LlmStructuredResponse<T> = {
+    data: T;
+    usage: LlmUsage;
+    latencyMs: number;
+};
+interface LlmClient {
+    readonly config: Readonly<LlmClientConfig>;
+    complete(messages: LlmMessage[], options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>): Promise<LlmResponse>;
+    stream(messages: LlmMessage[], options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>): AsyncGenerator<LlmStreamChunk>;
+    structured<T>(messages: LlmMessage[], schema: {
+        parse: (data: unknown) => T;
+    }, options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>): Promise<LlmStructuredResponse<T>>;
+}
+
+/**
+ * Factory functions for LlmClient.
+ *
+ * createClient — dispatches to the correct provider implementation.
+ * createClientFromEnv — convenience wrapper that reads API keys from env vars.
+ *
+ * Provider dispatch:
+ *   'anthropic'  → fully implemented (Week 2)
+ *   'openai'     → fully implemented (Week 2)
+ *   'gemini'     → fully implemented (Week 3)
+ *   'deepseek'   → fully implemented (Week 3)
+ *   'perplexity' → stub, throws "not yet implemented" (later week)
+ */
+
+/**
+ * Create an LlmClient for the given provider and config.
+ * Dispatches to the provider-specific implementation.
+ *
+ * Anthropic, OpenAI, Gemini, and DeepSeek are fully implemented.
+ * Perplexity is a type-registered stub that throws "not yet implemented".
+ */
+declare function createClient(config: LlmClientConfig): LlmClient;
+/**
+ * Convenience: create an LlmClient from environment variables.
+ *
+ * Reads API keys from the environment based on provider:
+ *   anthropic  → ANTHROPIC_API_KEY
+ *   openai     → OPENAI_API_KEY
+ *   gemini     → GOOGLE_AI_API_KEY
+ *   deepseek   → DEEPSEEK_API_KEY
+ *   perplexity → PERPLEXITY_API_KEY
+ *
+ * Throws LlmError if the required env var is not set.
+ */
+declare function createClientFromEnv(provider: LlmClientConfig['provider'], model: string, overrides?: Partial<Omit<LlmClientConfig, 'provider' | 'model' | 'apiKey'>>): LlmClient;
+
+export { type LlmClient, type LlmClientConfig, LlmError, type LlmMessage, type LlmResponse, type LlmStreamChunk, type LlmStructuredResponse, type LlmUsage, createClient, createClientFromEnv };

package/dist/index.js

@@ -0,0 +1,916 @@
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/types.ts
+var LlmError = class extends Error {
+  name = "LlmError";
+  provider;
+  statusCode;
+  retryable;
+  // `cause` is declared on Error in lib.es2022.error.d.ts as `cause?: unknown`
+  // We override it here to make it always present (not optional) after construction.
+  cause;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.provider = opts.provider;
+    this.statusCode = opts.statusCode;
+    this.retryable = opts.retryable;
+    this.cause = opts.cause;
+  }
+};
+
+// src/retry.ts
+var RETRYABLE_HTTP_STATUSES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "ETIMEDOUT", "ECONNABORTED"]);
+var NON_RETRYABLE_HTTP_STATUSES = /* @__PURE__ */ new Set([400, 401, 403, 404]);
+function isRetryableStatus(statusCode) {
+  if (RETRYABLE_HTTP_STATUSES.has(statusCode)) return true;
+  if (NON_RETRYABLE_HTTP_STATUSES.has(statusCode)) return false;
+  return statusCode >= 500;
+}
+function isRetryableErrorCode(code) {
+  return RETRYABLE_ERROR_CODES.has(code);
+}
+function computeBackoffMs(attempt, baseDelayMs) {
+  const ceiling = baseDelayMs * 2 ** attempt;
+  return Math.random() * ceiling;
+}
+async function withRetry(fn, opts) {
+  let lastError;
+  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+    try {
+      return await fn(attempt);
+    } catch (err) {
+      const llmErr = normalizeThrownError(err, opts.provider);
+      if (!llmErr.retryable || attempt === opts.maxRetries) {
+        throw llmErr;
+      }
+      lastError = llmErr;
+      const delayMs = computeBackoffMs(attempt, opts.baseDelayMs);
+      await sleep(delayMs);
+    }
+  }
+  throw lastError ?? new LlmError({
+    message: "Unexpected retry exhaustion",
+    provider: opts.provider,
+    retryable: false
+  });
+}
+function normalizeThrownError(err, provider) {
+  if (err instanceof LlmError) return err;
+  if (err instanceof Error) {
+    const errWithCode = err;
+    const statusCode = errWithCode.status ?? errWithCode.statusCode;
+    if (errWithCode.code !== void 0 && isRetryableErrorCode(errWithCode.code)) {
+      if (statusCode !== void 0) {
+        return new LlmError({
+          message: err.message,
+          provider,
+          statusCode,
+          retryable: true,
+          cause: err
+        });
+      }
+      return new LlmError({ message: err.message, provider, retryable: true, cause: err });
+    }
+    if (statusCode !== void 0) {
+      return new LlmError({
+        message: err.message,
+        provider,
+        statusCode,
+        retryable: isRetryableStatus(statusCode),
+        cause: err
+      });
+    }
+    return new LlmError({
+      message: err.message,
+      provider,
+      retryable: false,
+      cause: err
+    });
+  }
+  return new LlmError({
+    message: String(err),
+    provider,
+    retryable: false,
+    cause: err
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/providers/anthropic.ts
+var PROVIDER = "anthropic";
+function normalizeUsage(usage) {
+  const inputTokens = usage?.input_tokens ?? 0;
+  const outputTokens = usage?.output_tokens ?? 0;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    // cache_creation_input_tokens and cache_read_input_tokens are present on
+    // extended usage objects from prompt caching — cast to access them safely.
+    cacheCreationTokens: usage?.cache_creation_input_tokens,
+    cacheReadTokens: usage?.cache_read_input_tokens
+  };
+}
+function buildAnthropicMessages(messages) {
+  const systemMessages = messages.filter((m) => m.role === "system");
+  const conversationMessages = messages.filter((m) => m.role !== "system");
+  const system = systemMessages.length > 0 ? systemMessages.map((m) => m.content).join("\n") : void 0;
+  const anthropicMessages = conversationMessages.map((m) => ({
+    role: m.role,
+    content: m.content
+  }));
+  return { system, messages: anthropicMessages };
+}
+function normalizeAnthropicError(err) {
+  if (err instanceof LlmError) return err;
+  if (typeof Anthropic.APIConnectionError === "function" && err instanceof Anthropic.APIConnectionError) {
+    return new LlmError({
+      message: err.message,
+      provider: PROVIDER,
+      retryable: true,
+      cause: err
+    });
+  }
+  if (typeof Anthropic.APIError === "function" && err instanceof Anthropic.APIError) {
+    const status = err.status;
+    if (status !== void 0) {
+      const retryable = [429, 502, 503, 504].includes(status) || status >= 500;
+      return new LlmError({
+        message: err.message,
+        provider: PROVIDER,
+        statusCode: status,
+        retryable,
+        cause: err
+      });
+    }
+    return new LlmError({ message: err.message, provider: PROVIDER, retryable: false, cause: err });
+  }
+  return normalizeThrownError(err, PROVIDER);
+}
+function createAnthropicProvider(config) {
+  const client = new Anthropic({
+    apiKey: config.apiKey,
+    timeout: config.timeoutMs ?? 3e4,
+    maxRetries: 0
+    // We manage retries ourselves via withRetry
+  });
+  const retryOpts = {
+    maxRetries: config.maxRetries ?? 3,
+    baseDelayMs: config.baseDelayMs ?? 1e3,
+    provider: PROVIDER
+  };
+  async function complete(messages, options) {
+    const model = options?.model ?? config.model;
+    const { system, messages: anthropicMessages } = buildAnthropicMessages(messages);
+    const start = Date.now();
+    return withRetry(async () => {
+      try {
+        const params = {
+          model,
+          messages: anthropicMessages,
+          max_tokens: options?.maxTokens ?? config.maxTokens ?? 1024
+        };
+        if (system !== void 0) params.system = system;
+        const temperature = options?.temperature ?? config.temperature;
+        if (temperature !== void 0) {
+          params.temperature = temperature;
+        }
+        const response = await client.messages.create(params);
+        const content = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+        return {
+          content,
+          model: response.model,
+          usage: normalizeUsage(response.usage),
+          latencyMs: Date.now() - start
+        };
+      } catch (err) {
+        throw normalizeAnthropicError(err);
+      }
+    }, retryOpts);
+  }
+  async function* stream(messages, options) {
+    const model = options?.model ?? config.model;
+    const { system, messages: anthropicMessages } = buildAnthropicMessages(messages);
+    const params = {
+      model,
+      messages: anthropicMessages,
+      max_tokens: options?.maxTokens ?? config.maxTokens ?? 1024
+    };
+    if (system !== void 0) params.system = system;
+    const streamTemperature = options?.temperature ?? config.temperature;
+    if (streamTemperature !== void 0) {
+      params.temperature = streamTemperature;
+    }
+    let sdkStream;
+    try {
+      sdkStream = client.messages.stream(params);
+    } catch (err) {
+      throw normalizeAnthropicError(err);
+    }
+    let finalUsage;
+    try {
+      for await (const event of sdkStream) {
+        if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+          yield { token: event.delta.text };
+        } else if (event.type === "message_delta" && "usage" in event) {
+          const accum = await sdkStream.finalMessage();
+          finalUsage = normalizeUsage(accum.usage);
+        }
+      }
+    } catch (err) {
+      throw normalizeAnthropicError(err);
+    }
+    if (finalUsage !== void 0) {
+      yield { token: "", usage: finalUsage };
+    }
+  }
+  async function structured(messages, schema, options) {
+    const jsonSystemInstruction = {
+      role: "system",
+      content: "You must respond with valid JSON only. No explanations, no markdown code fences, no extra text. Your entire response must be valid JSON that can be parsed with JSON.parse()."
+    };
+    const augmentedMessages = [jsonSystemInstruction, ...messages];
+    const start = Date.now();
+    const response = await complete(augmentedMessages, options);
+    let parsed;
+    try {
+      const cleaned = response.content.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "").trim();
+      parsed = JSON.parse(cleaned);
+    } catch (err) {
+      throw new LlmError({
+        message: `Anthropic structured output: response is not valid JSON. Raw: ${response.content.slice(0, 200)}`,
+        provider: PROVIDER,
+        retryable: false,
+        cause: err
+      });
+    }
+    let data;
+    try {
+      data = schema.parse(parsed);
+    } catch (err) {
+      throw new LlmError({
+        message: `Anthropic structured output: response failed schema validation. ${String(err)}`,
+        provider: PROVIDER,
+        retryable: false,
+        cause: err
+      });
+    }
+    return {
+      data,
+      usage: response.usage,
+      latencyMs: Date.now() - start
+    };
+  }
+  return {
+    config,
+    complete,
+    stream,
+    structured
+  };
+}
+
+// src/providers/deepseek.ts
+import OpenAI from "openai";
+var PROVIDER2 = "deepseek";
+var DEEPSEEK_BASE_URL = "https://api.deepseek.com";
+function normalizeUsage2(usage) {
+  const inputTokens = usage?.prompt_tokens ?? 0;
+  const outputTokens = usage?.completion_tokens ?? 0;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: usage?.total_tokens ?? inputTokens + outputTokens
+  };
+}
+function buildMessages(messages) {
+  return messages.map((m) => ({
+    role: m.role,
+    content: m.content
+  }));
+}
+function normalizeDeepSeekError(err) {
+  if (err instanceof LlmError) return err;
+  if (typeof OpenAI.APIConnectionError === "function" && err instanceof OpenAI.APIConnectionError) {
+    return new LlmError({
+      message: err.message,
+      provider: PROVIDER2,
+      retryable: true,
+      cause: err
+    });
+  }
+  if (typeof OpenAI.APIError === "function" && err instanceof OpenAI.APIError) {
+    const status = err.status;
+    if (status !== void 0) {
+      const retryable = [429, 502, 503, 504].includes(status) || status >= 500;
+      return new LlmError({
+        message: err.message,
+        provider: PROVIDER2,
+        statusCode: status,
+        retryable,
+        cause: err
+      });
+    }
+    return new LlmError({ message: err.message, provider: PROVIDER2, retryable: false, cause: err });
+  }
+  return normalizeThrownError(err, PROVIDER2);
+}
+function createDeepSeekProvider(config) {
+  const client = new OpenAI({
+    apiKey: config.apiKey,
+    baseURL: DEEPSEEK_BASE_URL,
+    timeout: config.timeoutMs ?? 3e4,
+    maxRetries: 0
+    // Retries managed by withRetry
+  });
+  const retryOpts = {
+    maxRetries: config.maxRetries ?? 3,
+    baseDelayMs: config.baseDelayMs ?? 1e3,
+    provider: PROVIDER2
+  };
+  async function complete(messages, options) {
+    const model = options?.model ?? config.model;
+    const chatMessages = buildMessages(messages);
+    const start = Date.now();
+    return withRetry(async () => {
+      try {
+        const params = {
+          model,
+          messages: chatMessages,
+          stream: false
+        };
+        const maxTokens = options?.maxTokens ?? config.maxTokens;
+        if (maxTokens !== void 0) params.max_tokens = maxTokens;
+        const temperature = options?.temperature ?? config.temperature;
+        if (temperature !== void 0) params.temperature = temperature;
+        const response = await client.chat.completions.create(params);
+        const content = response.choices.map((c) => c.message.content ?? "").join("");
+        return {
+          content,
+          model: response.model,
+          usage: normalizeUsage2(response.usage),
+          latencyMs: Date.now() - start
+        };
+      } catch (err) {
+        throw normalizeDeepSeekError(err);
+      }
+    }, retryOpts);
+  }
+  async function* stream(messages, options) {
+    const model = options?.model ?? config.model;
+    const chatMessages = buildMessages(messages);
+    const params = {
+      model,
+      messages: chatMessages,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    const maxTokens = options?.maxTokens ?? config.maxTokens;
+    if (maxTokens !== void 0) params.max_tokens = maxTokens;
+    const temperature = options?.temperature ?? config.temperature;
+    if (temperature !== void 0) params.temperature = temperature;
+    let sdkStream;
+    try {
+      sdkStream = await client.chat.completions.create(params);
+    } catch (err) {
+      throw normalizeDeepSeekError(err);
+    }
+    let finalUsage;
+    try {
+      for await (const chunk of sdkStream) {
+        const delta = chunk.choices[0]?.delta.content;
+        if (delta !== void 0 && delta !== null && delta.length > 0) {
+          yield { token: delta };
+        }
+        if (chunk.usage !== void 0 && chunk.usage !== null) {
+          finalUsage = normalizeUsage2(chunk.usage);
+        }
+      }
+    } catch (err) {
+      throw normalizeDeepSeekError(err);
+    }
+    if (finalUsage !== void 0) {
+      yield { token: "", usage: finalUsage };
+    }
+  }
+  async function structured(messages, schema, options) {
+    const jsonSystemInstruction = {
+      role: "system",
+      content: "You must respond with valid JSON only. No explanations, no markdown code fences, no extra text. Your entire response must be valid JSON that can be parsed with JSON.parse()."
+    };
+    const augmentedMessages = [jsonSystemInstruction, ...messages];
+    const model = options?.model ?? config.model;
+    const chatMessages = buildMessages(augmentedMessages);
+    const start = Date.now();
+    const rawResponse = await withRetry(async () => {
+      try {
+        const params = {
+          model,
+          messages: chatMessages,
+          stream: false
+        };
+        const maxTokens = options?.maxTokens ?? config.maxTokens;
+        if (maxTokens !== void 0) params.max_tokens = maxTokens;
+        const temperature = options?.temperature ?? config.temperature;
+        if (temperature !== void 0) params.temperature = temperature;
+        return await client.chat.completions.create(params);
+      } catch (err) {
+        throw normalizeDeepSeekError(err);
+      }
+    }, retryOpts);
+    const rawContent = rawResponse.choices[0]?.message.content ?? "";
+    let parsed;
+    try {
+      const cleaned = rawContent.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "").trim();
+      parsed = JSON.parse(cleaned);
+    } catch (err) {
+      throw new LlmError({
+        message: `DeepSeek structured output: response is not valid JSON. Raw: ${rawContent.slice(0, 200)}`,
+        provider: PROVIDER2,
+        retryable: false,
+        cause: err
+      });
+    }
+    let data;
+    try {
+      data = schema.parse(parsed);
+    } catch (err) {
+      throw new LlmError({
+        message: `DeepSeek structured output: response failed schema validation. ${String(err)}`,
+        provider: PROVIDER2,
+        retryable: false,
+        cause: err
+      });
+    }
+    return {
+      data,
+      usage: normalizeUsage2(rawResponse.usage),
+      latencyMs: Date.now() - start
+    };
+  }
+  return {
+    config,
+    complete,
+    stream,
+    structured
+  };
+}
+
+// src/providers/gemini.ts
+import {
+  ApiError,
+  GoogleGenAI
+} from "@google/genai";
+var PROVIDER3 = "gemini";
+function normalizeUsage3(meta) {
+  const inputTokens = meta?.promptTokenCount ?? 0;
+  const outputTokens = meta?.candidatesTokenCount ?? 0;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: meta?.totalTokenCount ?? inputTokens + outputTokens
+  };
+}
+function buildGeminiContents(messages) {
+  const systemMessages = messages.filter((m) => m.role === "system");
+  const conversationMessages = messages.filter((m) => m.role !== "system");
+  const system = systemMessages.length > 0 ? systemMessages.map((m) => m.content).join("\n") : void 0;
+  const contents = conversationMessages.map((m) => ({
+    role: m.role === "assistant" ? "model" : "user",
+    parts: [{ text: m.content }]
+  }));
+  return { system, contents };
+}
+function normalizeGeminiError(err) {
+  if (err instanceof LlmError) return err;
+  if (err instanceof ApiError) {
+    const retryable = err.status === 429 || err.status >= 500;
+    return new LlmError({
+      message: err.message,
+      provider: PROVIDER3,
+      statusCode: err.status,
+      retryable,
+      cause: err
+    });
+  }
+  return normalizeThrownError(err, PROVIDER3);
+}
+function createGeminiProvider(config) {
+  const ai = new GoogleGenAI({
+    apiKey: config.apiKey,
+    httpOptions: {
+      timeout: config.timeoutMs ?? 3e4
+    }
+  });
+  const retryOpts = {
+    maxRetries: config.maxRetries ?? 3,
+    baseDelayMs: config.baseDelayMs ?? 1e3,
+    provider: PROVIDER3
+  };
+  async function complete(messages, options) {
+    const model = options?.model ?? config.model;
+    const { system, contents } = buildGeminiContents(messages);
+    const start = Date.now();
+    return withRetry(async () => {
+      try {
+        const geminiConfig = {};
+        if (system !== void 0) geminiConfig.systemInstruction = system;
+        const maxTokens = options?.maxTokens ?? config.maxTokens;
+        if (maxTokens !== void 0) geminiConfig.maxOutputTokens = maxTokens;
+        const temperature = options?.temperature ?? config.temperature;
+        if (temperature !== void 0) geminiConfig.temperature = temperature;
+        const response = await ai.models.generateContent({
+          model,
+          contents,
+          config: geminiConfig
+        });
+        return {
+          content: response.text ?? "",
+          model,
+          usage: normalizeUsage3(response.usageMetadata),
+          latencyMs: Date.now() - start
+        };
+      } catch (err) {
+        throw normalizeGeminiError(err);
+      }
+    }, retryOpts);
+  }
+  async function* stream(messages, options) {
+    const model = options?.model ?? config.model;
+    const { system, contents } = buildGeminiContents(messages);
+    const geminiConfig = {};
+    if (system !== void 0) geminiConfig.systemInstruction = system;
+    const maxTokens = options?.maxTokens ?? config.maxTokens;
+    if (maxTokens !== void 0) geminiConfig.maxOutputTokens = maxTokens;
+    const temperature = options?.temperature ?? config.temperature;
+    if (temperature !== void 0) geminiConfig.temperature = temperature;
+    let sdkStream;
+    try {
+      sdkStream = await ai.models.generateContentStream({
+        model,
+        contents,
+        config: geminiConfig
+      });
+    } catch (err) {
+      throw normalizeGeminiError(err);
+    }
+    let finalUsage;
+    try {
+      for await (const chunk of sdkStream) {
+        const text = chunk.text;
+        if (text !== void 0 && text.length > 0) {
+          yield { token: text };
+        }
+        if (chunk.usageMetadata !== void 0) {
+          finalUsage = normalizeUsage3(chunk.usageMetadata);
+        }
+      }
+    } catch (err) {
+      throw normalizeGeminiError(err);
+    }
+    if (finalUsage !== void 0) {
+      yield { token: "", usage: finalUsage };
+    }
+  }
+  async function structured(messages, schema, options) {
+    const augmentedMessages = [
+      {
+        role: "system",
+        content: "You must respond with valid JSON only. No explanations, no markdown code fences, no extra text. Your entire response must be valid JSON that can be parsed with JSON.parse()."
+      },
+      ...messages
+    ];
+    const model = options?.model ?? config.model;
+    const { system, contents } = buildGeminiContents(augmentedMessages);
+    const start = Date.now();
+    const rawResponse = await withRetry(async () => {
+      try {
+        const geminiConfig = {
+          // Instruct Gemini to return JSON directly
+          responseMimeType: "application/json"
+        };
+        if (system !== void 0) geminiConfig.systemInstruction = system;
+        const maxTokens = options?.maxTokens ?? config.maxTokens;
+        if (maxTokens !== void 0) geminiConfig.maxOutputTokens = maxTokens;
+        const temperature = options?.temperature ?? config.temperature;
+        if (temperature !== void 0) geminiConfig.temperature = temperature;
+        return await ai.models.generateContent({
+          model,
+          contents,
+          config: geminiConfig
+        });
+      } catch (err) {
+        throw normalizeGeminiError(err);
+      }
+    }, retryOpts);
+    const rawContent = rawResponse.text ?? "";
+    let parsed;
+    try {
+      const cleaned = rawContent.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "").trim();
+      parsed = JSON.parse(cleaned);
+    } catch (err) {
+      throw new LlmError({
+        message: `Gemini structured output: response is not valid JSON. Raw: ${rawContent.slice(0, 200)}`,
+        provider: PROVIDER3,
+        retryable: false,
+        cause: err
+      });
+    }
+    let data;
+    try {
+      data = schema.parse(parsed);
+    } catch (err) {
+      throw new LlmError({
+        message: `Gemini structured output: response failed schema validation. ${String(err)}`,
+        provider: PROVIDER3,
+        retryable: false,
+        cause: err
+      });
+    }
+    return {
+      data,
+      usage: normalizeUsage3(rawResponse.usageMetadata),
+      latencyMs: Date.now() - start
+    };
+  }
+  return {
+    config,
+    complete,
+    stream,
+    structured
+  };
+}
+
+// src/providers/openai.ts
+import OpenAI2 from "openai";
+var PROVIDER4 = "openai";
+function normalizeUsage4(usage) {
+  const inputTokens = usage?.prompt_tokens ?? 0;
+  const outputTokens = usage?.completion_tokens ?? 0;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: usage?.total_tokens ?? inputTokens + outputTokens
+  };
+}
+function buildOpenAIMessages(messages) {
+  return messages.map((m) => ({
+    role: m.role,
+    content: m.content
+  }));
+}
+function normalizeOpenAIError(err) {
+  if (err instanceof LlmError) return err;
+  if (typeof OpenAI2.APIConnectionError === "function" && err instanceof OpenAI2.APIConnectionError) {
+    return new LlmError({
+      message: err.message,
+      provider: PROVIDER4,
+      retryable: true,
+      cause: err
+    });
+  }
+  if (typeof OpenAI2.APIError === "function" && err instanceof OpenAI2.APIError) {
+    const status = err.status;
+    if (status !== void 0) {
+      const retryable = [429, 502, 503, 504].includes(status) || status >= 500;
+      return new LlmError({
+        message: err.message,
+        provider: PROVIDER4,
+        statusCode: status,
+        retryable,
+        cause: err
+      });
+    }
+    return new LlmError({ message: err.message, provider: PROVIDER4, retryable: false, cause: err });
+  }
+  return normalizeThrownError(err, PROVIDER4);
+}
+function createOpenAIProvider(config) {
+  const client = new OpenAI2({
+    apiKey: config.apiKey,
+    timeout: config.timeoutMs ?? 3e4,
+    maxRetries: 0
+    // We manage retries ourselves via withRetry
+  });
+  const retryOpts = {
+    maxRetries: config.maxRetries ?? 3,
+    baseDelayMs: config.baseDelayMs ?? 1e3,
+    provider: PROVIDER4
+  };
+  async function complete(messages, options) {
+    const model = options?.model ?? config.model;
+    const openAIMessages = buildOpenAIMessages(messages);
+    const start = Date.now();
+    return withRetry(async () => {
+      try {
+        const params = {
+          model,
+          messages: openAIMessages,
+          stream: false
+        };
+        const maxTokens = options?.maxTokens ?? config.maxTokens;
+        if (maxTokens !== void 0) params.max_tokens = maxTokens;
+        const temperature = options?.temperature ?? config.temperature;
+        if (temperature !== void 0) params.temperature = temperature;
+        const response = await client.chat.completions.create(params);
+        const content = response.choices.map((c) => c.message.content ?? "").join("");
+        return {
+          content,
+          model: response.model,
+          usage: normalizeUsage4(response.usage),
+          latencyMs: Date.now() - start
+        };
+      } catch (err) {
+        throw normalizeOpenAIError(err);
+      }
+    }, retryOpts);
+  }
+  async function* stream(messages, options) {
+    const model = options?.model ?? config.model;
+    const openAIMessages = buildOpenAIMessages(messages);
+    const params = {
+      model,
+      messages: openAIMessages,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    const maxTokens = options?.maxTokens ?? config.maxTokens;
+    if (maxTokens !== void 0) params.max_tokens = maxTokens;
+    const temperature = options?.temperature ?? config.temperature;
+    if (temperature !== void 0) params.temperature = temperature;
+    let sdkStream;
+    try {
+      sdkStream = await client.chat.completions.create(params);
+    } catch (err) {
+      throw normalizeOpenAIError(err);
+    }
+    let finalUsage;
+    try {
+      for await (const chunk of sdkStream) {
+        const delta = chunk.choices[0]?.delta.content;
+        if (delta !== void 0 && delta !== null && delta.length > 0) {
+          yield { token: delta };
+        }
+        if (chunk.usage !== void 0 && chunk.usage !== null) {
+          finalUsage = normalizeUsage4(chunk.usage);
+        }
+      }
+    } catch (err) {
+      throw normalizeOpenAIError(err);
+    }
+    if (finalUsage !== void 0) {
+      yield { token: "", usage: finalUsage };
+    }
+  }
+  async function structured(messages, schema, options) {
+    const jsonSystemInstruction = {
+      role: "system",
+      content: "You must respond with valid JSON only. No explanations, no markdown code fences, no extra text. Your entire response must be valid JSON that can be parsed with JSON.parse()."
+    };
+    const augmentedMessages = [jsonSystemInstruction, ...messages];
+    const model = options?.model ?? config.model;
+    const openAIMessages = buildOpenAIMessages(augmentedMessages);
+    const start = Date.now();
+    const rawResponse = await withRetry(async () => {
+      try {
+        const params = {
+          model,
+          messages: openAIMessages,
+          stream: false,
+          response_format: { type: "json_object" }
+        };
+        const maxTokens = options?.maxTokens ?? config.maxTokens;
+        if (maxTokens !== void 0) params.max_tokens = maxTokens;
+        const temperature = options?.temperature ?? config.temperature;
+        if (temperature !== void 0) params.temperature = temperature;
+        return await client.chat.completions.create(params);
+      } catch (err) {
+        throw normalizeOpenAIError(err);
+      }
+    }, retryOpts);
+    const rawContent = rawResponse.choices[0]?.message.content ?? "";
+    let parsed;
+    try {
+      parsed = JSON.parse(rawContent);
+    } catch (err) {
+      throw new LlmError({
+        message: `OpenAI structured output: response is not valid JSON. Raw: ${rawContent.slice(0, 200)}`,
+        provider: PROVIDER4,
+        retryable: false,
+        cause: err
+      });
+    }
+    let data;
+    try {
+      data = schema.parse(parsed);
+    } catch (err) {
+      throw new LlmError({
+        message: `OpenAI structured output: response failed schema validation. ${String(err)}`,
+        provider: PROVIDER4,
+        retryable: false,
+        cause: err
+      });
+    }
+    return {
+      data,
+      usage: normalizeUsage4(rawResponse.usage),
+      latencyMs: Date.now() - start
+    };
+  }
+  return {
+    config,
+    complete,
+    stream,
+    structured
+  };
+}
+
+// src/providers/stubs.ts
+function rejectingStream(err) {
+  const rejected = Promise.reject(err);
+  rejected.catch(() => void 0);
+  return {
+    next: () => rejected,
+    return: () => Promise.resolve({ value: void 0, done: true }),
+    throw: () => Promise.reject(err),
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    [Symbol.asyncDispose]: async () => void 0
+  };
+}
+function notImplemented(provider) {
+  const err = new LlmError({
+    message: `[dlabs-toolkit] Provider '${provider}' is not yet implemented. Anthropic, OpenAI, Gemini, and DeepSeek are available; Perplexity ships in a later week.`,
+    provider,
+    retryable: false
+  });
+  return {
+    get config() {
+      throw err;
+    },
+    complete: () => Promise.reject(err),
+    stream: () => rejectingStream(err),
+    structured: () => Promise.reject(err)
+  };
+}
+function createPerplexityProvider(config) {
+  void config;
+  return notImplemented("perplexity");
+}
+
+// src/client.ts
+function createClient(config) {
+  switch (config.provider) {
+    case "anthropic":
+      return createAnthropicProvider(config);
+    case "openai":
+      return createOpenAIProvider(config);
+    case "gemini":
+      return createGeminiProvider(config);
+    case "deepseek":
+      return createDeepSeekProvider(config);
+    case "perplexity":
+      return createPerplexityProvider(config);
+    default: {
+      const _exhaustive = config.provider;
+      throw new LlmError({
+        message: `[dlabs-toolkit] Unknown provider: ${String(_exhaustive)}`,
+        provider: String(_exhaustive),
+        retryable: false
+      });
+    }
+  }
+}
+function createClientFromEnv(provider, model, overrides) {
+  const apiKey = resolveApiKey(provider);
+  return createClient({ provider, model, apiKey, ...overrides });
+}
+function resolveApiKey(provider) {
+  const envVarMap = {
+    anthropic: "ANTHROPIC_API_KEY",
+    openai: "OPENAI_API_KEY",
+    gemini: "GOOGLE_AI_API_KEY",
+    deepseek: "DEEPSEEK_API_KEY",
+    perplexity: "PERPLEXITY_API_KEY"
+  };
+  const envVar = envVarMap[provider];
+  const apiKey = process.env[envVar];
+  if (apiKey === void 0 || apiKey.trim() === "") {
+    throw new LlmError({
+      message: `[dlabs-toolkit] ${envVar} is not set. Set this environment variable to use the ${provider} provider.`,
+      provider,
+      retryable: false
+    });
+  }
+  return apiKey;
+}
+export {
+  LlmError,
+  createClient,
+  createClientFromEnv
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/providers/anthropic.ts","../src/types.ts","../src/retry.ts","../src/providers/deepseek.ts","../src/providers/gemini.ts","../src/providers/openai.ts","../src/providers/stubs.ts","../src/client.ts"],"sourcesContent":["/**\n * Anthropic Claude provider for @diabolicallabs/llm-client.\n *\n * Implements: complete(), stream(), structured()\n *\n * Token normalization:\n *   Anthropic: input_tokens / output_tokens / cache_creation_input_tokens / cache_read_input_tokens\n *   → LlmUsage: inputTokens / outputTokens / totalTokens / cacheCreationTokens / cacheReadTokens\n *\n * Error mapping:\n *   APIStatusError.status → LlmError.statusCode + retryable flag\n *   APIConnectionError → retryable: true\n */\n\nimport Anthropic from '@anthropic-ai/sdk';\nimport { normalizeThrownError, withRetry } from '../retry.js';\nimport type {\n  LlmClient,\n  LlmClientConfig,\n  LlmMessage,\n  LlmResponse,\n  LlmStreamChunk,\n  LlmStructuredResponse,\n  LlmUsage,\n} from '../types.js';\nimport { LlmError } from '../types.js';\n\nconst PROVIDER = 'anthropic';\n\n/** Normalize Anthropic's usage object to LlmUsage. */\nfunction normalizeUsage(usage: Anthropic.Usage | undefined): LlmUsage {\n  const inputTokens = usage?.input_tokens ?? 0;\n  const outputTokens = usage?.output_tokens ?? 0;\n  return {\n    inputTokens,\n    outputTokens,\n    totalTokens: inputTokens + outputTokens,\n    // cache_creation_input_tokens and cache_read_input_tokens are present on\n    // extended usage objects from prompt caching — cast to access them safely.\n    cacheCreationTokens: (usage as Anthropic.Usage & { cache_creation_input_tokens?: number })\n      ?.cache_creation_input_tokens,\n    cacheReadTokens: (usage as Anthropic.Usage & { cache_read_input_tokens?: number })\n      ?.cache_read_input_tokens,\n  };\n}\n\n/** Convert LlmMessages to Anthropic's message format. Extracts system prompt. */\nfunction buildAnthropicMessages(messages: LlmMessage[]): {\n  system: string | undefined;\n  messages: Anthropic.MessageParam[];\n} {\n  const systemMessages = messages.filter((m) => m.role === 'system');\n  const conversationMessages = messages.filter((m) => m.role !== 'system');\n\n  const system =\n    systemMessages.length > 0 ? systemMessages.map((m) => m.content).join('\\n') : undefined;\n\n  const anthropicMessages: Anthropic.MessageParam[] = conversationMessages.map((m) => ({\n    role: m.role as 'user' | 'assistant',\n    content: m.content,\n  }));\n\n  return { system, messages: anthropicMessages };\n}\n\n/**\n * Normalize any Anthropic SDK error into LlmError.\n * Exported for direct unit testing of the normalization logic.\n */\nexport function normalizeAnthropicError(err: unknown): LlmError {\n  if (err instanceof LlmError) return err;\n\n  // Anthropic SDK v0.94+: uses Anthropic.APIError as the base class with a `.status` field.\n  // APIConnectionError is a subclass of APIError with status: undefined — check it first\n  // so network failures are always retryable regardless of the missing status code.\n  if (\n    typeof Anthropic.APIConnectionError === 'function' &&\n    err instanceof Anthropic.APIConnectionError\n  ) {\n    return new LlmError({\n      message: err.message,\n      provider: PROVIDER,\n      retryable: true,\n      cause: err,\n    });\n  }\n\n  // Catch all other APIError subclasses: RateLimitError (429), AuthenticationError (401),\n  // InternalServerError (500), etc. Retryability is determined by HTTP status code.\n  if (typeof Anthropic.APIError === 'function' && err instanceof Anthropic.APIError) {\n    const status: number | undefined = err.status;\n    if (status !== undefined) {\n      const retryable = [429, 502, 503, 504].includes(status) || status >= 500;\n      return new LlmError({\n        message: err.message,\n        provider: PROVIDER,\n        statusCode: status,\n        retryable,\n        cause: err,\n      });\n    }\n    return new LlmError({ message: err.message, provider: PROVIDER, retryable: false, cause: err });\n  }\n\n  return normalizeThrownError(err, PROVIDER);\n}\n\n/** Create the Anthropic provider implementation. */\nexport function createAnthropicProvider(config: LlmClientConfig): LlmClient {\n  const client = new Anthropic({\n    apiKey: config.apiKey,\n    timeout: config.timeoutMs ?? 30_000,\n    maxRetries: 0, // We manage retries ourselves via withRetry\n  });\n\n  const retryOpts = {\n    maxRetries: config.maxRetries ?? 3,\n    baseDelayMs: config.baseDelayMs ?? 1_000,\n    provider: PROVIDER,\n  };\n\n  async function complete(\n    messages: LlmMessage[],\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): Promise<LlmResponse> {\n    const model = options?.model ?? config.model;\n    const { system, messages: anthropicMessages } = buildAnthropicMessages(messages);\n\n    const start = Date.now();\n\n    return withRetry(async () => {\n      try {\n        const params: Anthropic.MessageCreateParamsNonStreaming = {\n          model,\n          messages: anthropicMessages,\n          max_tokens: options?.maxTokens ?? config.maxTokens ?? 1024,\n        };\n\n        if (system !== undefined) params.system = system;\n        const temperature = options?.temperature ?? config.temperature;\n        if (temperature !== undefined) {\n          params.temperature = temperature;\n        }\n\n        const response = await client.messages.create(params);\n\n        const content = response.content\n          .filter((block): block is Anthropic.TextBlock => block.type === 'text')\n          .map((block) => block.text)\n          .join('');\n\n        return {\n          content,\n          model: response.model,\n          usage: normalizeUsage(response.usage),\n          latencyMs: Date.now() - start,\n        };\n      } catch (err) {\n        throw normalizeAnthropicError(err);\n      }\n    }, retryOpts);\n  }\n\n  async function* stream(\n    messages: LlmMessage[],\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): AsyncGenerator<LlmStreamChunk> {\n    const model = options?.model ?? config.model;\n    const { system, messages: anthropicMessages } = buildAnthropicMessages(messages);\n\n    const params: Anthropic.MessageStreamParams = {\n      model,\n      messages: anthropicMessages,\n      max_tokens: options?.maxTokens ?? config.maxTokens ?? 1024,\n    };\n\n    if (system !== undefined) params.system = system;\n    const streamTemperature = options?.temperature ?? config.temperature;\n    if (streamTemperature !== undefined) {\n      params.temperature = streamTemperature;\n    }\n\n    let sdkStream: Awaited<ReturnType<typeof client.messages.stream>>;\n\n    try {\n      sdkStream = client.messages.stream(params);\n    } catch (err) {\n      throw normalizeAnthropicError(err);\n    }\n\n    // Accumulate usage — Anthropic sends it in the message_delta event at stream end\n    let finalUsage: LlmUsage | undefined;\n\n    try {\n      for await (const event of sdkStream) {\n        if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {\n          yield { token: event.delta.text };\n        } else if (event.type === 'message_delta' && 'usage' in event) {\n          // Merge input tokens from message_start with output tokens from message_delta\n          const accum = await sdkStream.finalMessage();\n          finalUsage = normalizeUsage(accum.usage);\n        }\n      }\n    } catch (err) {\n      // Propagate as a normalized LlmError regardless of whether streaming had started.\n      // Partial stream errors cannot be recovered from — the consumer must handle them.\n      throw normalizeAnthropicError(err);\n    }\n\n    // Yield usage on the final empty chunk\n    if (finalUsage !== undefined) {\n      yield { token: '', usage: finalUsage };\n    }\n  }\n\n  async function structured<T>(\n    messages: LlmMessage[],\n    schema: { parse: (data: unknown) => T },\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): Promise<LlmStructuredResponse<T>> {\n    // Anthropic JSON mode: append a system instruction to return only JSON.\n    // We inject this into the messages so the provider returns parseable output.\n    const jsonSystemInstruction: LlmMessage = {\n      role: 'system',\n      content:\n        'You must respond with valid JSON only. No explanations, no markdown code fences, no extra text. Your entire response must be valid JSON that can be parsed with JSON.parse().',\n    };\n\n    const augmentedMessages = [jsonSystemInstruction, ...messages];\n    const start = Date.now();\n\n    const response = await complete(augmentedMessages, options);\n\n    let parsed: unknown;\n    try {\n      // Strip markdown code fences if the model included them despite the instruction\n      const cleaned = response.content\n        .replace(/^```(?:json)?\\s*/i, '')\n        .replace(/\\s*```$/, '')\n        .trim();\n      parsed = JSON.parse(cleaned);\n    } catch (err) {\n      throw new LlmError({\n        message: `Anthropic structured output: response is not valid JSON. Raw: ${response.content.slice(0, 200)}`,\n        provider: PROVIDER,\n        retryable: false,\n        cause: err,\n      });\n    }\n\n    let data: T;\n    try {\n      data = schema.parse(parsed);\n    } catch (err) {\n      throw new LlmError({\n        message: `Anthropic structured output: response failed schema validation. ${String(err)}`,\n        provider: PROVIDER,\n        retryable: false,\n        cause: err,\n      });\n    }\n\n    return {\n      data,\n      usage: response.usage,\n      latencyMs: Date.now() - start,\n    };\n  }\n\n  return {\n    config,\n    complete,\n    stream,\n    structured,\n  };\n}\n","/**\n * Core type definitions for @diabolicallabs/llm-client.\n * These are the stable public API surface — implementation is in Week 2.\n * Types here match the spec in briefs/brief-platform.md §4.1 exactly.\n */\n\n// The canonical message format shared across all providers\nexport interface LlmMessage {\n  role: 'system' | 'user' | 'assistant';\n  content: string;\n}\n\n// Config passed to createClient\nexport interface LlmClientConfig {\n  // Full 5-provider union — gemini, deepseek, perplexity are type-only stubs in Week 2\n  provider: 'anthropic' | 'openai' | 'gemini' | 'deepseek' | 'perplexity';\n  model: string; // e.g. 'claude-sonnet-4-6', 'gpt-4o', 'gemini-2.5-flash'\n  apiKey: string;\n  maxRetries?: number; // default: 3\n  baseDelayMs?: number; // default: 1000 — exponential backoff base\n  maxTokens?: number; // provider default if omitted\n  temperature?: number; // provider default if omitted\n  timeoutMs?: number; // default: 30000\n}\n\n// Normalized token usage — same shape regardless of provider\nexport interface LlmUsage {\n  inputTokens: number;\n  outputTokens: number;\n  totalTokens: number;\n  cacheCreationTokens?: number; // Anthropic prompt cache write tokens\n  cacheReadTokens?: number; // Anthropic prompt cache read tokens\n}\n\n// Non-streaming response\nexport interface LlmResponse {\n  content: string;\n  model: string; // model ID actually used (may differ from requested)\n  usage: LlmUsage;\n  latencyMs: number;\n}\n\n// Streaming chunk\nexport interface LlmStreamChunk {\n  token: string;\n  usage?: LlmUsage; // present only on the final chunk\n}\n\n// Normalized error — wraps provider-specific errors\nexport class LlmError extends Error {\n  override readonly name = 'LlmError';\n  readonly provider: string;\n  readonly statusCode: number | undefined;\n  readonly retryable: boolean;\n  // `cause` is declared on Error in lib.es2022.error.d.ts as `cause?: unknown`\n  // We override it here to make it always present (not optional) after construction.\n  override readonly cause: unknown;\n\n  constructor(opts: {\n    message: string;\n    provider: string;\n    statusCode?: number;\n    retryable: boolean;\n    cause?: unknown;\n  }) {\n    super(opts.message, { cause: opts.cause });\n    this.provider = opts.provider;\n    this.statusCode = opts.statusCode;\n    this.retryable = opts.retryable;\n    this.cause = opts.cause;\n  }\n}\n\n// Structured output — Zod schema inference\nexport type LlmStructuredResponse<T> = {\n  data: T;\n  usage: LlmUsage;\n  latencyMs: number;\n};\n\n// The LlmClient interface — what consumers program against\nexport interface LlmClient {\n  readonly config: Readonly<LlmClientConfig>;\n\n  // Non-streaming completion\n  complete(\n    messages: LlmMessage[],\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): Promise<LlmResponse>;\n\n  // Streaming completion — async generator of chunks\n  stream(\n    messages: LlmMessage[],\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): AsyncGenerator<LlmStreamChunk>;\n\n  // Structured output — parses and validates the response against a Zod schema\n  // Forces JSON mode on providers that support it; falls back to parse-and-validate\n  structured<T>(\n    messages: LlmMessage[],\n    // Using a narrower interface than the full ZodType to avoid a hard zod dependency at types level\n    schema: { parse: (data: unknown) => T },\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): Promise<LlmStructuredResponse<T>>;\n}\n","/**\n * Exponential backoff with full jitter — shared across all providers.\n *\n * Formula: delay = random(0, baseDelayMs * 2^attempt)\n *\n * Retryable HTTP statuses: 429 (rate limit), 502/503/504 (server errors).\n * Retryable network codes: ECONNRESET, ETIMEDOUT.\n * Non-retryable: 400 (bad request), 401/403 (auth), 404.\n */\n\nimport { LlmError } from './types.js';\n\n// HTTP status codes that should trigger a retry\nconst RETRYABLE_HTTP_STATUSES = new Set([429, 502, 503, 504]);\n\n// Network error codes that should trigger a retry\nconst RETRYABLE_ERROR_CODES = new Set(['ECONNRESET', 'ETIMEDOUT', 'ECONNABORTED']);\n\n// HTTP status codes that should never retry (fail immediately)\nconst NON_RETRYABLE_HTTP_STATUSES = new Set([400, 401, 403, 404]);\n\n/** Determine if an HTTP status code is retryable. */\nexport function isRetryableStatus(statusCode: number): boolean {\n  if (RETRYABLE_HTTP_STATUSES.has(statusCode)) return true;\n  if (NON_RETRYABLE_HTTP_STATUSES.has(statusCode)) return false;\n  // Treat any 5xx not explicitly handled as retryable\n  return statusCode >= 500;\n}\n\n/** Determine if a network error code is retryable. */\nexport function isRetryableErrorCode(code: string): boolean {\n  return RETRYABLE_ERROR_CODES.has(code);\n}\n\n/** Compute the delay in ms for attempt N (0-indexed). Full jitter. */\nexport function computeBackoffMs(attempt: number, baseDelayMs: number): number {\n  const ceiling = baseDelayMs * 2 ** attempt;\n  return Math.random() * ceiling;\n}\n\nexport interface RetryOptions {\n  maxRetries: number;\n  baseDelayMs: number;\n  provider: string;\n}\n\n/**\n * Execute `fn` with retry logic. Wraps the result in structured error normalization.\n * `fn` receives the current attempt number (0-indexed).\n *\n * Throws LlmError after all retries are exhausted.\n */\nexport async function withRetry<T>(\n  fn: (attempt: number) => Promise<T>,\n  opts: RetryOptions\n): Promise<T> {\n  let lastError: LlmError | undefined;\n\n  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {\n    try {\n      return await fn(attempt);\n    } catch (err) {\n      const llmErr = normalizeThrownError(err, opts.provider);\n\n      if (!llmErr.retryable || attempt === opts.maxRetries) {\n        throw llmErr;\n      }\n\n      lastError = llmErr;\n      const delayMs = computeBackoffMs(attempt, opts.baseDelayMs);\n      await sleep(delayMs);\n    }\n  }\n\n  // This path is unreachable — the loop always throws or returns.\n  // TypeScript needs this for exhaustiveness.\n  throw (\n    lastError ??\n    new LlmError({\n      message: 'Unexpected retry exhaustion',\n      provider: opts.provider,\n      retryable: false,\n    })\n  );\n}\n\n/** Normalize any thrown value into an LlmError. */\nexport function normalizeThrownError(err: unknown, provider: string): LlmError {\n  if (err instanceof LlmError) return err;\n\n  if (err instanceof Error) {\n    const errWithCode = err as Error & { status?: number; statusCode?: number; code?: string };\n\n    const statusCode = errWithCode.status ?? errWithCode.statusCode;\n\n    // Check for retryable network error codes\n    if (errWithCode.code !== undefined && isRetryableErrorCode(errWithCode.code)) {\n      if (statusCode !== undefined) {\n        return new LlmError({\n          message: err.message,\n          provider,\n          statusCode,\n          retryable: true,\n          cause: err,\n        });\n      }\n      return new LlmError({ message: err.message, provider, retryable: true, cause: err });\n    }\n\n    // Check for retryable HTTP status codes\n    if (statusCode !== undefined) {\n      return new LlmError({\n        message: err.message,\n        provider,\n        statusCode,\n        retryable: isRetryableStatus(statusCode),\n        cause: err,\n      });\n    }\n\n    return new LlmError({\n      message: err.message,\n      provider,\n      retryable: false,\n      cause: err,\n    });\n  }\n\n  return new LlmError({\n    message: String(err),\n    provider,\n    retryable: false,\n    cause: err,\n  });\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n","/**\n * DeepSeek provider for @diabolicallabs/llm-client.\n *\n * DeepSeek's chat completions API is fully OpenAI-compatible, so this provider\n * uses the OpenAI SDK pointed at DeepSeek's base URL.\n *\n * API base URL: https://api.deepseek.com\n * Docs: https://platform.deepseek.com/api-docs/\n *\n * Implements: complete(), stream(), structured()\n *\n * Token normalization:\n *   DeepSeek returns standard OpenAI-format usage: prompt_tokens / completion_tokens / total_tokens\n *   → LlmUsage: inputTokens / outputTokens / totalTokens\n *\n * Error mapping:\n *   APIConnectionError → retryable: true\n *   APIError with status 429 / 5xx → retryable: true\n *   Other APIErrors → non-retryable\n *\n * Note: DeepSeek does not support the json_object response_format on all models.\n * structured() injects a system prompt and parses the raw response. If the model\n * includes markdown fences, they are stripped before parsing.\n */\n\nimport OpenAI from 'openai';\nimport { normalizeThrownError, withRetry } from '../retry.js';\nimport type {\n  LlmClient,\n  LlmClientConfig,\n  LlmMessage,\n  LlmResponse,\n  LlmStreamChunk,\n  LlmStructuredResponse,\n  LlmUsage,\n} from '../types.js';\nimport { LlmError } from '../types.js';\n\nconst PROVIDER = 'deepseek';\nconst DEEPSEEK_BASE_URL = 'https://api.deepseek.com';\n\n/** Normalize OpenAI-format usage object to LlmUsage. */\nfunction normalizeUsage(usage: OpenAI.CompletionUsage | undefined | null): LlmUsage {\n  const inputTokens = usage?.prompt_tokens ?? 0;\n  const outputTokens = usage?.completion_tokens ?? 0;\n  return {\n    inputTokens,\n    outputTokens,\n    totalTokens: usage?.total_tokens ?? inputTokens + outputTokens,\n  };\n}\n\n/** Convert LlmMessages to OpenAI-format chat message params (compatible with DeepSeek). */\nfunction buildMessages(messages: LlmMessage[]): OpenAI.Chat.ChatCompletionMessageParam[] {\n  return messages.map((m) => ({\n    role: m.role,\n    content: m.content,\n  }));\n}\n\n/**\n * Normalize any DeepSeek / OpenAI SDK error into LlmError.\n * Exported for direct unit testing of the normalization logic.\n *\n * Uses the same OpenAI SDK error hierarchy (APIConnectionError before APIError)\n * since the client is an OpenAI instance pointed at DeepSeek's API.\n */\nexport function normalizeDeepSeekError(err: unknown): LlmError {\n  if (err instanceof LlmError) return err;\n\n  // APIConnectionError is a subclass of APIError with status: undefined —\n  // check it first so network failures are always retryable.\n  if (typeof OpenAI.APIConnectionError === 'function' && err instanceof OpenAI.APIConnectionError) {\n    return new LlmError({\n      message: err.message,\n      provider: PROVIDER,\n      retryable: true,\n      cause: err,\n    });\n  }\n\n  // Catch all other APIError subclasses: RateLimitError (429), AuthenticationError (401), etc.\n  if (typeof OpenAI.APIError === 'function' && err instanceof OpenAI.APIError) {\n    const status: number | undefined = err.status;\n    if (status !== undefined) {\n      const retryable = [429, 502, 503, 504].includes(status) || status >= 500;\n      return new LlmError({\n        message: err.message,\n        provider: PROVIDER,\n        statusCode: status,\n        retryable,\n        cause: err,\n      });\n    }\n    return new LlmError({ message: err.message, provider: PROVIDER, retryable: false, cause: err });\n  }\n\n  return normalizeThrownError(err, PROVIDER);\n}\n\n/** Create the DeepSeek provider implementation. */\nexport function createDeepSeekProvider(config: LlmClientConfig): LlmClient {\n  // OpenAI SDK pointed at DeepSeek's OpenAI-compatible endpoint\n  const client = new OpenAI({\n    apiKey: config.apiKey,\n    baseURL: DEEPSEEK_BASE_URL,\n    timeout: config.timeoutMs ?? 30_000,\n    maxRetries: 0, // Retries managed by withRetry\n  });\n\n  const retryOpts = {\n    maxRetries: config.maxRetries ?? 3,\n    baseDelayMs: config.baseDelayMs ?? 1_000,\n    provider: PROVIDER,\n  };\n\n  async function complete(\n    messages: LlmMessage[],\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): Promise<LlmResponse> {\n    const model = options?.model ?? config.model;\n    const chatMessages = buildMessages(messages);\n    const start = Date.now();\n\n    return withRetry(async () => {\n      try {\n        const params: OpenAI.Chat.ChatCompletionCreateParamsNonStreaming = {\n          model,\n          messages: chatMessages,\n          stream: false,\n        };\n\n        const maxTokens = options?.maxTokens ?? config.maxTokens;\n        if (maxTokens !== undefined) params.max_tokens = maxTokens;\n\n        const temperature = options?.temperature ?? config.temperature;\n        if (temperature !== undefined) params.temperature = temperature;\n\n        const response = await client.chat.completions.create(params);\n        const content = response.choices.map((c) => c.message.content ?? '').join('');\n\n        return {\n          content,\n          model: response.model,\n          usage: normalizeUsage(response.usage),\n          latencyMs: Date.now() - start,\n        };\n      } catch (err) {\n        throw normalizeDeepSeekError(err);\n      }\n    }, retryOpts);\n  }\n\n  async function* stream(\n    messages: LlmMessage[],\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): AsyncGenerator<LlmStreamChunk> {\n    const model = options?.model ?? config.model;\n    const chatMessages = buildMessages(messages);\n\n    const params: OpenAI.Chat.ChatCompletionCreateParamsStreaming = {\n      model,\n      messages: chatMessages,\n      stream: true,\n      stream_options: { include_usage: true },\n    };\n\n    const maxTokens = options?.maxTokens ?? config.maxTokens;\n    if (maxTokens !== undefined) params.max_tokens = maxTokens;\n\n    const temperature = options?.temperature ?? config.temperature;\n    if (temperature !== undefined) params.temperature = temperature;\n\n    let sdkStream: Awaited<ReturnType<typeof client.chat.completions.create>>;\n\n    try {\n      sdkStream = await client.chat.completions.create(params);\n    } catch (err) {\n      throw normalizeDeepSeekError(err);\n    }\n\n    let finalUsage: LlmUsage | undefined;\n\n    try {\n      for await (const chunk of sdkStream) {\n        const delta = chunk.choices[0]?.delta.content;\n        if (delta !== undefined && delta !== null && delta.length > 0) {\n          yield { token: delta };\n        }\n\n        // Usage arrives in the final chunk when stream_options.include_usage is true\n        if (chunk.usage !== undefined && chunk.usage !== null) {\n          finalUsage = normalizeUsage(chunk.usage);\n        }\n      }\n    } catch (err) {\n      throw normalizeDeepSeekError(err);\n    }\n\n    if (finalUsage !== undefined) {\n      yield { token: '', usage: finalUsage };\n    }\n  }\n\n  async function structured<T>(\n    messages: LlmMessage[],\n    schema: { parse: (data: unknown) => T },\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): Promise<LlmStructuredResponse<T>> {\n    // Inject JSON-only system instruction. DeepSeek does not guarantee json_object\n    // response_format support across all models, so we rely on prompt-level enforcement.\n    const jsonSystemInstruction: LlmMessage = {\n      role: 'system',\n      content:\n        'You must respond with valid JSON only. No explanations, no markdown code fences, no extra text. Your entire response must be valid JSON that can be parsed with JSON.parse().',\n    };\n\n    const augmentedMessages = [jsonSystemInstruction, ...messages];\n    const model = options?.model ?? config.model;\n    const chatMessages = buildMessages(augmentedMessages);\n    const start = Date.now();\n\n    const rawResponse = await withRetry(async () => {\n      try {\n        const params: OpenAI.Chat.ChatCompletionCreateParamsNonStreaming = {\n          model,\n          messages: chatMessages,\n          stream: false,\n        };\n\n        const maxTokens = options?.maxTokens ?? config.maxTokens;\n        if (maxTokens !== undefined) params.max_tokens = maxTokens;\n\n        const temperature = options?.temperature ?? config.temperature;\n        if (temperature !== undefined) params.temperature = temperature;\n\n        return await client.chat.completions.create(params);\n      } catch (err) {\n        throw normalizeDeepSeekError(err);\n      }\n    }, retryOpts);\n\n    const rawContent = rawResponse.choices[0]?.message.content ?? '';\n\n    let parsed: unknown;\n    try {\n      // Strip markdown fences if the model included them despite the instruction\n      const cleaned = rawContent\n        .replace(/^```(?:json)?\\s*/i, '')\n        .replace(/\\s*```$/, '')\n        .trim();\n      parsed = JSON.parse(cleaned);\n    } catch (err) {\n      throw new LlmError({\n        message: `DeepSeek structured output: response is not valid JSON. Raw: ${rawContent.slice(0, 200)}`,\n        provider: PROVIDER,\n        retryable: false,\n        cause: err,\n      });\n    }\n\n    let data: T;\n    try {\n      data = schema.parse(parsed);\n    } catch (err) {\n      throw new LlmError({\n        message: `DeepSeek structured output: response failed schema validation. ${String(err)}`,\n        provider: PROVIDER,\n        retryable: false,\n        cause: err,\n      });\n    }\n\n    return {\n      data,\n      usage: normalizeUsage(rawResponse.usage),\n      latencyMs: Date.now() - start,\n    };\n  }\n\n  return {\n    config,\n    complete,\n    stream,\n    structured,\n  };\n}\n","/**\n * Google Gemini provider for @diabolicallabs/llm-client.\n *\n * Uses the @google/genai SDK (v1.x — not the deprecated @google/generative-ai).\n *\n * Implements: complete(), stream(), structured()\n *\n * Token normalization:\n *   Gemini: usageMetadata.promptTokenCount / candidatesTokenCount / totalTokenCount\n *   → LlmUsage: inputTokens / outputTokens / totalTokens\n *\n * Error mapping:\n *   ApiError (public SDK class, status: number always defined):\n *     retryable for 429 / 5xx\n *     non-retryable for 4xx (except 429)\n *   Other errors → normalizeThrownError (handles ECONNRESET / ETIMEDOUT as retryable)\n *\n * API notes:\n *   - System instructions are passed via config.systemInstruction (not mixed into contents)\n *   - Role mapping: 'user' → 'user', 'assistant' → 'model'\n *   - Streaming via ai.models.generateContentStream() returns AsyncGenerator<GenerateContentResponse>\n *   - Text is accessed via response.text getter on GenerateContentResponse\n *   - Structured output: responseMimeType: 'application/json' in GenerateContentConfig\n *\n * SDK error class note:\n *   The @google/genai public API exports only ApiError (lowercase 'a'), which has status: number.\n *   Internal APIError / APIConnectionError classes (uppercase) are NOT exported from the package\n *   root and must not be imported from internal dist paths.\n *   Network errors (ECONNRESET, ETIMEDOUT) arrive as plain Error objects caught by normalizeThrownError.\n */\n\nimport {\n  ApiError,\n  type Content,\n  type GenerateContentConfig,\n  type GenerateContentResponse,\n  type GenerateContentResponseUsageMetadata,\n  GoogleGenAI,\n} from '@google/genai';\nimport { normalizeThrownError, withRetry } from '../retry.js';\nimport type {\n  LlmClient,\n  LlmClientConfig,\n  LlmMessage,\n  LlmResponse,\n  LlmStreamChunk,\n  LlmStructuredResponse,\n  LlmUsage,\n} from '../types.js';\nimport { LlmError } from '../types.js';\n\nconst PROVIDER = 'gemini';\n\n/** Normalize Gemini's usageMetadata to LlmUsage. */\nfunction normalizeUsage(meta: GenerateContentResponseUsageMetadata | undefined): LlmUsage {\n  const inputTokens = meta?.promptTokenCount ?? 0;\n  const outputTokens = meta?.candidatesTokenCount ?? 0;\n  return {\n    inputTokens,\n    outputTokens,\n    totalTokens: meta?.totalTokenCount ?? inputTokens + outputTokens,\n  };\n}\n\n/**\n * Convert LlmMessages to Gemini's Content array format.\n * Extracts system message — Gemini treats system instructions separately from contents.\n * Role mapping: 'user' → 'user', 'assistant' → 'model' (Gemini API requires 'model').\n */\nfunction buildGeminiContents(messages: LlmMessage[]): {\n  system: string | undefined;\n  contents: Content[];\n} {\n  const systemMessages = messages.filter((m) => m.role === 'system');\n  const conversationMessages = messages.filter((m) => m.role !== 'system');\n\n  const system =\n    systemMessages.length > 0 ? systemMessages.map((m) => m.content).join('\\n') : undefined;\n\n  const contents: Content[] = conversationMessages.map((m) => ({\n    role: m.role === 'assistant' ? 'model' : 'user',\n    parts: [{ text: m.content }],\n  }));\n\n  return { system, contents };\n}\n\n/**\n * Normalize any Gemini SDK error into LlmError.\n * Exported for direct unit testing of the normalization logic.\n *\n * ApiError (public SDK class) always has status: number, so there is no undefined-status branch.\n * Network errors (no HTTP status) arrive as plain Error objects; normalizeThrownError\n * handles retryable error codes (ECONNRESET, ETIMEDOUT, etc.).\n */\nexport function normalizeGeminiError(err: unknown): LlmError {\n  if (err instanceof LlmError) return err;\n\n  // ApiError is the only publicly-exported SDK error class.\n  // status is always number (not undefined) per the ApiError type definition.\n  if (err instanceof ApiError) {\n    const retryable = err.status === 429 || err.status >= 500;\n    return new LlmError({\n      message: err.message,\n      provider: PROVIDER,\n      statusCode: err.status,\n      retryable,\n      cause: err,\n    });\n  }\n\n  // Network errors (ECONNRESET, ETIMEDOUT, etc.) arrive as plain Error objects.\n  // normalizeThrownError classifies retryable codes and handles the unknown-error case.\n  return normalizeThrownError(err, PROVIDER);\n}\n\n/** Create the Gemini provider implementation. */\nexport function createGeminiProvider(config: LlmClientConfig): LlmClient {\n  const ai = new GoogleGenAI({\n    apiKey: config.apiKey,\n    httpOptions: {\n      timeout: config.timeoutMs ?? 30_000,\n    },\n  });\n\n  const retryOpts = {\n    maxRetries: config.maxRetries ?? 3,\n    baseDelayMs: config.baseDelayMs ?? 1_000,\n    provider: PROVIDER,\n  };\n\n  async function complete(\n    messages: LlmMessage[],\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): Promise<LlmResponse> {\n    const model = options?.model ?? config.model;\n    const { system, contents } = buildGeminiContents(messages);\n    const start = Date.now();\n\n    return withRetry(async () => {\n      try {\n        // Build config object — always passed (empty object is valid GenerateContentConfig)\n        const geminiConfig: GenerateContentConfig = {};\n\n        if (system !== undefined) geminiConfig.systemInstruction = system;\n        const maxTokens = options?.maxTokens ?? config.maxTokens;\n        if (maxTokens !== undefined) geminiConfig.maxOutputTokens = maxTokens;\n        const temperature = options?.temperature ?? config.temperature;\n        if (temperature !== undefined) geminiConfig.temperature = temperature;\n\n        const response = await ai.models.generateContent({\n          model,\n          contents,\n          config: geminiConfig,\n        });\n\n        return {\n          content: response.text ?? '',\n          model,\n          usage: normalizeUsage(response.usageMetadata),\n          latencyMs: Date.now() - start,\n        };\n      } catch (err) {\n        throw normalizeGeminiError(err);\n      }\n    }, retryOpts);\n  }\n\n  async function* stream(\n    messages: LlmMessage[],\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): AsyncGenerator<LlmStreamChunk> {\n    const model = options?.model ?? config.model;\n    const { system, contents } = buildGeminiContents(messages);\n\n    // Build config — always passed (empty object is valid GenerateContentConfig)\n    const geminiConfig: GenerateContentConfig = {};\n    if (system !== undefined) geminiConfig.systemInstruction = system;\n    const maxTokens = options?.maxTokens ?? config.maxTokens;\n    if (maxTokens !== undefined) geminiConfig.maxOutputTokens = maxTokens;\n    const temperature = options?.temperature ?? config.temperature;\n    if (temperature !== undefined) geminiConfig.temperature = temperature;\n\n    let sdkStream: AsyncGenerator<GenerateContentResponse>;\n\n    try {\n      sdkStream = await ai.models.generateContentStream({\n        model,\n        contents,\n        config: geminiConfig,\n      });\n    } catch (err) {\n      throw normalizeGeminiError(err);\n    }\n\n    let finalUsage: LlmUsage | undefined;\n\n    try {\n      for await (const chunk of sdkStream) {\n        const text = chunk.text;\n        if (text !== undefined && text.length > 0) {\n          yield { token: text };\n        }\n        // Capture usage from each chunk — the final chunk has the complete totals\n        if (chunk.usageMetadata !== undefined) {\n          finalUsage = normalizeUsage(chunk.usageMetadata);\n        }\n      }\n    } catch (err) {\n      throw normalizeGeminiError(err);\n    }\n\n    if (finalUsage !== undefined) {\n      yield { token: '', usage: finalUsage };\n    }\n  }\n\n  async function structured<T>(\n    messages: LlmMessage[],\n    schema: { parse: (data: unknown) => T },\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): Promise<LlmStructuredResponse<T>> {\n    const augmentedMessages: LlmMessage[] = [\n      {\n        role: 'system',\n        content:\n          'You must respond with valid JSON only. No explanations, no markdown code fences, no extra text. Your entire response must be valid JSON that can be parsed with JSON.parse().',\n      },\n      ...messages,\n    ];\n\n    const model = options?.model ?? config.model;\n    const { system, contents } = buildGeminiContents(augmentedMessages);\n    const start = Date.now();\n\n    const rawResponse = await withRetry(async () => {\n      try {\n        const geminiConfig: GenerateContentConfig = {\n          // Instruct Gemini to return JSON directly\n          responseMimeType: 'application/json',\n        };\n\n        if (system !== undefined) geminiConfig.systemInstruction = system;\n        const maxTokens = options?.maxTokens ?? config.maxTokens;\n        if (maxTokens !== undefined) geminiConfig.maxOutputTokens = maxTokens;\n        const temperature = options?.temperature ?? config.temperature;\n        if (temperature !== undefined) geminiConfig.temperature = temperature;\n\n        return await ai.models.generateContent({\n          model,\n          contents,\n          config: geminiConfig,\n        });\n      } catch (err) {\n        throw normalizeGeminiError(err);\n      }\n    }, retryOpts);\n\n    const rawContent = rawResponse.text ?? '';\n\n    let parsed: unknown;\n    try {\n      // Strip markdown code fences if the model included them despite the instruction\n      const cleaned = rawContent\n        .replace(/^```(?:json)?\\s*/i, '')\n        .replace(/\\s*```$/, '')\n        .trim();\n      parsed = JSON.parse(cleaned);\n    } catch (err) {\n      throw new LlmError({\n        message: `Gemini structured output: response is not valid JSON. Raw: ${rawContent.slice(0, 200)}`,\n        provider: PROVIDER,\n        retryable: false,\n        cause: err,\n      });\n    }\n\n    let data: T;\n    try {\n      data = schema.parse(parsed);\n    } catch (err) {\n      throw new LlmError({\n        message: `Gemini structured output: response failed schema validation. ${String(err)}`,\n        provider: PROVIDER,\n        retryable: false,\n        cause: err,\n      });\n    }\n\n    return {\n      data,\n      usage: normalizeUsage(rawResponse.usageMetadata),\n      latencyMs: Date.now() - start,\n    };\n  }\n\n  return {\n    config,\n    complete,\n    stream,\n    structured,\n  };\n}\n","/**\n * OpenAI provider for @diabolicallabs/llm-client.\n *\n * Implements: complete(), stream(), structured()\n *\n * Token normalization:\n *   OpenAI: prompt_tokens / completion_tokens\n *   → LlmUsage: inputTokens / outputTokens / totalTokens\n *\n * Error mapping:\n *   APIStatusError.status → LlmError.statusCode + retryable flag\n *   APIConnectionError → retryable: true\n *\n * Structured output uses OpenAI's response_format: { type: 'json_object' }.\n * For strict schema enforcement, the schema is described in the system prompt.\n */\n\nimport OpenAI from 'openai';\nimport { normalizeThrownError, withRetry } from '../retry.js';\nimport type {\n  LlmClient,\n  LlmClientConfig,\n  LlmMessage,\n  LlmResponse,\n  LlmStreamChunk,\n  LlmStructuredResponse,\n  LlmUsage,\n} from '../types.js';\nimport { LlmError } from '../types.js';\n\nconst PROVIDER = 'openai';\n\n/** Normalize OpenAI's usage object to LlmUsage. */\nfunction normalizeUsage(usage: OpenAI.CompletionUsage | undefined | null): LlmUsage {\n  const inputTokens = usage?.prompt_tokens ?? 0;\n  const outputTokens = usage?.completion_tokens ?? 0;\n  return {\n    inputTokens,\n    outputTokens,\n    totalTokens: usage?.total_tokens ?? inputTokens + outputTokens,\n  };\n}\n\n/** Convert LlmMessages to OpenAI's chat message format. */\nfunction buildOpenAIMessages(messages: LlmMessage[]): OpenAI.Chat.ChatCompletionMessageParam[] {\n  return messages.map((m) => ({\n    role: m.role,\n    content: m.content,\n  }));\n}\n\n/**\n * Normalize any OpenAI SDK error into LlmError.\n * Exported for direct unit testing of the normalization logic.\n */\nexport function normalizeOpenAIError(err: unknown): LlmError {\n  if (err instanceof LlmError) return err;\n\n  // OpenAI SDK v6+: uses OpenAI.APIError as the base class with a `.status` field.\n  // APIConnectionError is a subclass of APIError with status: undefined — check it first\n  // so network failures are always retryable regardless of the missing status code.\n  if (typeof OpenAI.APIConnectionError === 'function' && err instanceof OpenAI.APIConnectionError) {\n    return new LlmError({\n      message: err.message,\n      provider: PROVIDER,\n      retryable: true,\n      cause: err,\n    });\n  }\n\n  // Catch all other APIError subclasses: RateLimitError (429), AuthenticationError (401),\n  // InternalServerError (500), etc. Retryability is determined by HTTP status code.\n  if (typeof OpenAI.APIError === 'function' && err instanceof OpenAI.APIError) {\n    const status: number | undefined = err.status;\n    if (status !== undefined) {\n      const retryable = [429, 502, 503, 504].includes(status) || status >= 500;\n      return new LlmError({\n        message: err.message,\n        provider: PROVIDER,\n        statusCode: status,\n        retryable,\n        cause: err,\n      });\n    }\n    return new LlmError({ message: err.message, provider: PROVIDER, retryable: false, cause: err });\n  }\n\n  return normalizeThrownError(err, PROVIDER);\n}\n\n/** Create the OpenAI provider implementation. */\nexport function createOpenAIProvider(config: LlmClientConfig): LlmClient {\n  const client = new OpenAI({\n    apiKey: config.apiKey,\n    timeout: config.timeoutMs ?? 30_000,\n    maxRetries: 0, // We manage retries ourselves via withRetry\n  });\n\n  const retryOpts = {\n    maxRetries: config.maxRetries ?? 3,\n    baseDelayMs: config.baseDelayMs ?? 1_000,\n    provider: PROVIDER,\n  };\n\n  async function complete(\n    messages: LlmMessage[],\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): Promise<LlmResponse> {\n    const model = options?.model ?? config.model;\n    const openAIMessages = buildOpenAIMessages(messages);\n    const start = Date.now();\n\n    return withRetry(async () => {\n      try {\n        const params: OpenAI.Chat.ChatCompletionCreateParamsNonStreaming = {\n          model,\n          messages: openAIMessages,\n          stream: false,\n        };\n\n        const maxTokens = options?.maxTokens ?? config.maxTokens;\n        if (maxTokens !== undefined) params.max_tokens = maxTokens;\n\n        const temperature = options?.temperature ?? config.temperature;\n        if (temperature !== undefined) params.temperature = temperature;\n\n        const response = await client.chat.completions.create(params);\n\n        const content = response.choices.map((c) => c.message.content ?? '').join('');\n\n        return {\n          content,\n          model: response.model,\n          usage: normalizeUsage(response.usage),\n          latencyMs: Date.now() - start,\n        };\n      } catch (err) {\n        throw normalizeOpenAIError(err);\n      }\n    }, retryOpts);\n  }\n\n  async function* stream(\n    messages: LlmMessage[],\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): AsyncGenerator<LlmStreamChunk> {\n    const model = options?.model ?? config.model;\n    const openAIMessages = buildOpenAIMessages(messages);\n\n    const params: OpenAI.Chat.ChatCompletionCreateParamsStreaming = {\n      model,\n      messages: openAIMessages,\n      stream: true,\n      stream_options: { include_usage: true },\n    };\n\n    const maxTokens = options?.maxTokens ?? config.maxTokens;\n    if (maxTokens !== undefined) params.max_tokens = maxTokens;\n\n    const temperature = options?.temperature ?? config.temperature;\n    if (temperature !== undefined) params.temperature = temperature;\n\n    let sdkStream: Awaited<ReturnType<typeof client.chat.completions.create>>;\n\n    try {\n      sdkStream = await client.chat.completions.create(params);\n    } catch (err) {\n      throw normalizeOpenAIError(err);\n    }\n\n    let finalUsage: LlmUsage | undefined;\n\n    try {\n      for await (const chunk of sdkStream) {\n        // Token chunks arrive in choices[0].delta.content\n        const delta = chunk.choices[0]?.delta.content;\n        if (delta !== undefined && delta !== null && delta.length > 0) {\n          yield { token: delta };\n        }\n\n        // Usage arrives in the final chunk (stream_options.include_usage must be true)\n        if (chunk.usage !== undefined && chunk.usage !== null) {\n          finalUsage = normalizeUsage(chunk.usage);\n        }\n      }\n    } catch (err) {\n      throw normalizeOpenAIError(err);\n    }\n\n    // Yield usage on the final sentinel chunk\n    if (finalUsage !== undefined) {\n      yield { token: '', usage: finalUsage };\n    }\n  }\n\n  async function structured<T>(\n    messages: LlmMessage[],\n    schema: { parse: (data: unknown) => T },\n    options?: Partial<Pick<LlmClientConfig, 'model' | 'maxTokens' | 'temperature'>>\n  ): Promise<LlmStructuredResponse<T>> {\n    // OpenAI JSON mode: response_format: { type: 'json_object' }\n    // The system prompt must instruct the model to output JSON — OpenAI requires this.\n    const jsonSystemInstruction: LlmMessage = {\n      role: 'system',\n      content:\n        'You must respond with valid JSON only. No explanations, no markdown code fences, no extra text. Your entire response must be valid JSON that can be parsed with JSON.parse().',\n    };\n\n    const augmentedMessages = [jsonSystemInstruction, ...messages];\n    const model = options?.model ?? config.model;\n    const openAIMessages = buildOpenAIMessages(augmentedMessages);\n    const start = Date.now();\n\n    const rawResponse = await withRetry(async () => {\n      try {\n        const params: OpenAI.Chat.ChatCompletionCreateParamsNonStreaming = {\n          model,\n          messages: openAIMessages,\n          stream: false,\n          response_format: { type: 'json_object' },\n        };\n\n        const maxTokens = options?.maxTokens ?? config.maxTokens;\n        if (maxTokens !== undefined) params.max_tokens = maxTokens;\n\n        const temperature = options?.temperature ?? config.temperature;\n        if (temperature !== undefined) params.temperature = temperature;\n\n        return await client.chat.completions.create(params);\n      } catch (err) {\n        throw normalizeOpenAIError(err);\n      }\n    }, retryOpts);\n\n    const rawContent = rawResponse.choices[0]?.message.content ?? '';\n\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(rawContent);\n    } catch (err) {\n      throw new LlmError({\n        message: `OpenAI structured output: response is not valid JSON. Raw: ${rawContent.slice(0, 200)}`,\n        provider: PROVIDER,\n        retryable: false,\n        cause: err,\n      });\n    }\n\n    let data: T;\n    try {\n      data = schema.parse(parsed);\n    } catch (err) {\n      throw new LlmError({\n        message: `OpenAI structured output: response failed schema validation. ${String(err)}`,\n        provider: PROVIDER,\n        retryable: false,\n        cause: err,\n      });\n    }\n\n    return {\n      data,\n      usage: normalizeUsage(rawResponse.usage),\n      latencyMs: Date.now() - start,\n    };\n  }\n\n  return {\n    config,\n    complete,\n    stream,\n    structured,\n  };\n}\n","/**\n * Type-only stubs for providers not yet implemented.\n *\n * Perplexity — later week (internal tooling, separate decision)\n *\n * All stubs throw a clear \"not yet implemented\" LlmError.\n * They are registered in the factory so the switch statement is exhaustive\n * and unknown provider values are caught at runtime with a useful message.\n */\n\nimport type { LlmClient, LlmClientConfig, LlmStreamChunk } from '../types.js';\nimport { LlmError } from '../types.js';\n\n/**\n * Returns an AsyncGenerator that immediately rejects when iterated.\n * Implemented without generator syntax to avoid Biome's useYield lint rule —\n * a throw-only generator has no meaningful yield, which Biome correctly flags.\n * The returned object satisfies the AsyncGenerator<LlmStreamChunk> interface contract.\n */\nfunction rejectingStream(err: LlmError): AsyncGenerator<LlmStreamChunk> {\n  const rejected = Promise.reject<IteratorResult<LlmStreamChunk>>(err);\n  // Attach a no-op catch so Node does not emit an unhandledRejection warning\n  // before the caller consumes the generator via for-await-of.\n  rejected.catch(() => undefined);\n  return {\n    next: () => rejected,\n    return: () => Promise.resolve({ value: undefined, done: true as const }),\n    throw: () => Promise.reject(err),\n    [Symbol.asyncIterator]() {\n      return this;\n    },\n    [Symbol.asyncDispose]: async () => undefined,\n  };\n}\n\nfunction notImplemented(provider: string): LlmClient {\n  const err = new LlmError({\n    message: `[dlabs-toolkit] Provider '${provider}' is not yet implemented. Anthropic, OpenAI, Gemini, and DeepSeek are available; Perplexity ships in a later week.`,\n    provider,\n    retryable: false,\n  });\n\n  // Return an object that throws on any method call.\n  // The error is pre-constructed so stack traces point to the factory call site,\n  // not the method call site — easier to debug misconfigured providers.\n  return {\n    get config(): LlmClientConfig {\n      throw err;\n    },\n    complete: () => Promise.reject(err),\n    stream: () => rejectingStream(err),\n    structured: () => Promise.reject(err),\n  };\n}\n\n/** Perplexity provider stub — later week. */\nexport function createPerplexityProvider(config: LlmClientConfig): LlmClient {\n  void config;\n  return notImplemented('perplexity');\n}\n","/**\n * Factory functions for LlmClient.\n *\n * createClient — dispatches to the correct provider implementation.\n * createClientFromEnv — convenience wrapper that reads API keys from env vars.\n *\n * Provider dispatch:\n *   'anthropic'  → fully implemented (Week 2)\n *   'openai'     → fully implemented (Week 2)\n *   'gemini'     → fully implemented (Week 3)\n *   'deepseek'   → fully implemented (Week 3)\n *   'perplexity' → stub, throws \"not yet implemented\" (later week)\n */\n\nimport { createAnthropicProvider } from './providers/anthropic.js';\nimport { createDeepSeekProvider } from './providers/deepseek.js';\nimport { createGeminiProvider } from './providers/gemini.js';\nimport { createOpenAIProvider } from './providers/openai.js';\nimport { createPerplexityProvider } from './providers/stubs.js';\nimport type { LlmClient, LlmClientConfig } from './types.js';\nimport { LlmError } from './types.js';\n\n/**\n * Create an LlmClient for the given provider and config.\n * Dispatches to the provider-specific implementation.\n *\n * Anthropic, OpenAI, Gemini, and DeepSeek are fully implemented.\n * Perplexity is a type-registered stub that throws \"not yet implemented\".\n */\nexport function createClient(config: LlmClientConfig): LlmClient {\n  switch (config.provider) {\n    case 'anthropic':\n      return createAnthropicProvider(config);\n\n    case 'openai':\n      return createOpenAIProvider(config);\n\n    case 'gemini':\n      return createGeminiProvider(config);\n\n    case 'deepseek':\n      return createDeepSeekProvider(config);\n\n    case 'perplexity':\n      return createPerplexityProvider(config);\n\n    default: {\n      // TypeScript exhaustiveness check — if a new provider is added to the union\n      // without a case here, this will be a compile-time error.\n      const _exhaustive: never = config.provider;\n      throw new LlmError({\n        message: `[dlabs-toolkit] Unknown provider: ${String(_exhaustive)}`,\n        provider: String(_exhaustive),\n        retryable: false,\n      });\n    }\n  }\n}\n\n/**\n * Convenience: create an LlmClient from environment variables.\n *\n * Reads API keys from the environment based on provider:\n *   anthropic  → ANTHROPIC_API_KEY\n *   openai     → OPENAI_API_KEY\n *   gemini     → GOOGLE_AI_API_KEY\n *   deepseek   → DEEPSEEK_API_KEY\n *   perplexity → PERPLEXITY_API_KEY\n *\n * Throws LlmError if the required env var is not set.\n */\nexport function createClientFromEnv(\n  provider: LlmClientConfig['provider'],\n  model: string,\n  overrides?: Partial<Omit<LlmClientConfig, 'provider' | 'model' | 'apiKey'>>\n): LlmClient {\n  const apiKey = resolveApiKey(provider);\n  return createClient({ provider, model, apiKey, ...overrides });\n}\n\n/** Read the API key for a given provider from environment variables. */\nfunction resolveApiKey(provider: LlmClientConfig['provider']): string {\n  const envVarMap: Record<LlmClientConfig['provider'], string> = {\n    anthropic: 'ANTHROPIC_API_KEY',\n    openai: 'OPENAI_API_KEY',\n    gemini: 'GOOGLE_AI_API_KEY',\n    deepseek: 'DEEPSEEK_API_KEY',\n    perplexity: 'PERPLEXITY_API_KEY',\n  };\n\n  const envVar = envVarMap[provider];\n  const apiKey = process.env[envVar];\n\n  if (apiKey === undefined || apiKey.trim() === '') {\n    throw new LlmError({\n      message: `[dlabs-toolkit] ${envVar} is not set. Set this environment variable to use the ${provider} provider.`,\n      provider,\n      retryable: false,\n    });\n  }\n\n  return apiKey;\n}\n"],"mappings":"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","names":["PROVIDER","normalizeUsage","PROVIDER","normalizeUsage","OpenAI","PROVIDER","normalizeUsage","OpenAI"]}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@diabolicallabs/llm-client",
+  "version": "0.1.0",
+  "description": "Unified LLM API for Anthropic, OpenAI, Google, and DeepSeek. Streaming, retry/backoff, structured output, token normalization. © Diabolical Labs",
+  "author": "Diana Ismail <diana@deeismail.com> (https://deeismail.com)",
+  "publisher": "Diabolical Labs",
+  "license": "UNLICENSED",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mannism/dlabs-toolkit.git",
+    "directory": "packages/llm-client"
+  },
+  "homepage": "https://github.com/mannism/dlabs-toolkit#readme",
+  "bugs": {
+    "url": "https://github.com/mannism/dlabs-toolkit/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "@vitest/coverage-v8": "^4.1.5",
+    "tsup": "^8.3.5",
+    "vitest": "^4.1.5"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.94.0",
+    "@google/genai": "^1.52.0",
+    "openai": "^6.36.0",
+    "zod": "^4.4.3"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check ./src && eslint ./src",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}