@lite-agent/provider 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { ModelProvider } from '@lite-agent/core';
+import OpenAI from 'openai';
+
+interface AnthropicClientLike {
+    messages: {
+        create(params: Anthropic.MessageCreateParamsStreaming, options?: {
+            signal?: AbortSignal;
+        }): Promise<AsyncIterable<Anthropic.RawMessageStreamEvent>> | AsyncIterable<Anthropic.RawMessageStreamEvent>;
+    };
+}
+interface AnthropicProviderOptions {
+    apiKey?: string;
+    baseURL?: string;
+    client?: AnthropicClientLike;
+}
+declare function anthropic(opts?: AnthropicProviderOptions): ModelProvider;
+
+type Chunk = OpenAI.Chat.Completions.ChatCompletionChunk;
+type Params = OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming;
+interface OpenAIClientLike {
+    chat: {
+        completions: {
+            create(params: Params, options?: {
+                signal?: AbortSignal;
+            }): Promise<AsyncIterable<Chunk>> | AsyncIterable<Chunk>;
+        };
+    };
+}
+interface OpenAIProviderOptions {
+    apiKey?: string;
+    baseURL?: string;
+    client?: OpenAIClientLike;
+}
+declare function openai(opts?: OpenAIProviderOptions): ModelProvider;
+
+export { type AnthropicClientLike, type AnthropicProviderOptions, type OpenAIClientLike, type OpenAIProviderOptions, anthropic, openai };

package/dist/index.js

@@ -0,0 +1,291 @@
+// src/anthropic/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+import { ProviderError } from "@lite-agent/core";
+
+// src/anthropic/mapping.ts
+var DEFAULT_MAX_TOKENS = 4096;
+function toBlockParam(b) {
+  if (b.type === "text") return { type: "text", text: b.text };
+  if (b.type === "tool_call") {
+    return {
+      type: "tool_use",
+      id: b.id,
+      name: b.name,
+      input: b.input ?? {}
+    };
+  }
+  return b.isError ? {
+    type: "tool_result",
+    tool_use_id: b.id,
+    content: b.content,
+    is_error: true
+  } : { type: "tool_result", tool_use_id: b.id, content: b.content };
+}
+function toMessageParam(m) {
+  const role = m.role === "assistant" ? "assistant" : "user";
+  const content = typeof m.content === "string" ? m.content : m.content.map(toBlockParam);
+  return { role, content };
+}
+function toInputSchema(parameters) {
+  const { $schema: _drop, ...rest } = parameters;
+  return rest;
+}
+function toTool(spec) {
+  return {
+    name: spec.name,
+    description: spec.description,
+    input_schema: toInputSchema(spec.parameters)
+  };
+}
+function toAnthropicParams(req) {
+  const params = {
+    model: req.model,
+    max_tokens: req.maxTokens ?? DEFAULT_MAX_TOKENS,
+    messages: req.messages.filter((m) => m.role !== "system").map(toMessageParam),
+    stream: true
+  };
+  if (req.system) params.system = req.system;
+  if (req.stopSequences) params.stop_sequences = req.stopSequences;
+  if (req.tools && req.tools.length) params.tools = req.tools.map(toTool);
+  return params;
+}
+
+// src/anthropic/stream.ts
+async function* translateStream(events) {
+  const blocks = [];
+  const toolJson = [];
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for await (const event of events) {
+    switch (event.type) {
+      case "message_start":
+        inputTokens = event.message.usage.input_tokens;
+        break;
+      case "content_block_start": {
+        const cb = event.content_block;
+        if (cb.type === "text") {
+          blocks[event.index] = { type: "text", text: cb.text };
+        } else if (cb.type === "tool_use") {
+          blocks[event.index] = {
+            type: "tool_call",
+            id: cb.id,
+            name: cb.name,
+            input: {}
+          };
+          toolJson[event.index] = "";
+        }
+        break;
+      }
+      case "content_block_delta": {
+        const d = event.delta;
+        if (d.type === "text_delta") {
+          const b = blocks[event.index];
+          if (b && b.type === "text") b.text += d.text;
+          yield { type: "text_delta", text: d.text };
+        } else if (d.type === "input_json_delta") {
+          toolJson[event.index] = (toolJson[event.index] ?? "") + d.partial_json;
+        }
+        break;
+      }
+      case "content_block_stop": {
+        const b = blocks[event.index];
+        if (b && b.type === "tool_call") {
+          const raw = toolJson[event.index] ?? "";
+          b.input = raw ? JSON.parse(raw) : {};
+        }
+        break;
+      }
+      case "message_delta":
+        outputTokens = event.usage.output_tokens;
+        break;
+      case "message_stop": {
+        const message = {
+          role: "assistant",
+          content: blocks.filter((b) => b !== void 0)
+        };
+        const usage = { inputTokens, outputTokens };
+        yield { type: "message_done", message, usage };
+        break;
+      }
+    }
+  }
+}
+
+// src/anthropic/anthropic.ts
+function toProviderError(e) {
+  if (e instanceof ProviderError) return e;
+  const status = typeof e.status === "number" ? e.status : void 0;
+  const message = e instanceof Error ? e.message : String(e);
+  return new ProviderError(message, status);
+}
+function anthropic(opts = {}) {
+  const client = opts.client ?? new Anthropic({
+    apiKey: opts.apiKey ?? process.env["ANTHROPIC_API_KEY"],
+    baseURL: opts.baseURL ?? process.env["BASE_URL"]
+  });
+  return {
+    id: "anthropic",
+    async *stream(req, signal) {
+      const params = toAnthropicParams(req);
+      try {
+        const raw = await client.messages.create(
+          params,
+          signal ? { signal } : void 0
+        );
+        yield* translateStream(raw);
+      } catch (e) {
+        throw toProviderError(e);
+      }
+    }
+  };
+}
+
+// src/openai/openai.ts
+import OpenAI from "openai";
+import { ProviderError as ProviderError2 } from "@lite-agent/core";
+
+// src/openai/mapping.ts
+function textOf(blocks) {
+  return blocks.filter(
+    (b) => b.type === "text"
+  ).map((b) => b.text).join("");
+}
+function toChatMessages(m) {
+  if (typeof m.content === "string") {
+    if (m.role === "assistant")
+      return [{ role: "assistant", content: m.content }];
+    return [{ role: "user", content: m.content }];
+  }
+  if (m.role === "assistant") {
+    const msg = {
+      role: "assistant",
+      content: textOf(m.content) || null
+    };
+    const toolCalls = m.content.filter(
+      (b) => b.type === "tool_call"
+    ).map(
+      (b) => ({
+        id: b.id,
+        type: "function",
+        function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) }
+      })
+    );
+    if (toolCalls.length) msg.tool_calls = toolCalls;
+    return [msg];
+  }
+  const out = [];
+  const texts = [];
+  for (const b of m.content) {
+    if (b.type === "tool_result")
+      out.push({ role: "tool", tool_call_id: b.id, content: b.content });
+    else if (b.type === "text") texts.push(b.text);
+  }
+  if (texts.length) out.push({ role: "user", content: texts.join("") });
+  return out;
+}
+function toChatTool(spec) {
+  const { $schema: _drop, ...parameters } = spec.parameters;
+  return {
+    type: "function",
+    function: { name: spec.name, description: spec.description, parameters }
+  };
+}
+function toOpenAIParams(req) {
+  const messages = [];
+  if (req.system) messages.push({ role: "system", content: req.system });
+  for (const m of req.messages) {
+    if (m.role === "system") continue;
+    messages.push(...toChatMessages(m));
+  }
+  const params = {
+    model: req.model,
+    messages,
+    stream: true,
+    stream_options: { include_usage: true }
+  };
+  if (req.maxTokens) params.max_tokens = req.maxTokens;
+  if (req.stopSequences) params.stop = req.stopSequences;
+  if (req.tools && req.tools.length) params.tools = req.tools.map(toChatTool);
+  return params;
+}
+
+// src/openai/stream.ts
+import { textBlock } from "@lite-agent/core";
+function safeParse(args) {
+  if (!args) return {};
+  try {
+    return JSON.parse(args);
+  } catch {
+    return {};
+  }
+}
+async function* translateStream2(raw) {
+  let text = "";
+  const calls = /* @__PURE__ */ new Map();
+  let usage = { inputTokens: 0, outputTokens: 0 };
+  for await (const chunk of raw) {
+    const delta = chunk.choices[0]?.delta;
+    if (delta?.content) {
+      text += delta.content;
+      yield { type: "text_delta", text: delta.content };
+    }
+    for (const tc of delta?.tool_calls ?? []) {
+      const cur = calls.get(tc.index) ?? { id: "", name: "", args: "" };
+      if (tc.id) cur.id = tc.id;
+      if (tc.function?.name) cur.name = tc.function.name;
+      if (tc.function?.arguments) cur.args += tc.function.arguments;
+      calls.set(tc.index, cur);
+    }
+    if (chunk.usage) {
+      usage = {
+        inputTokens: chunk.usage.prompt_tokens,
+        outputTokens: chunk.usage.completion_tokens
+      };
+    }
+  }
+  const content = [];
+  if (text) content.push(textBlock(text));
+  for (const [, c] of [...calls.entries()].sort((a, b) => a[0] - b[0])) {
+    content.push({
+      type: "tool_call",
+      id: c.id,
+      name: c.name,
+      input: safeParse(c.args)
+    });
+  }
+  const message = { role: "assistant", content };
+  yield { type: "message_done", message, usage };
+}
+
+// src/openai/openai.ts
+function toProviderError2(e) {
+  if (e instanceof ProviderError2) return e;
+  const status = typeof e.status === "number" ? e.status : void 0;
+  const message = e instanceof Error ? e.message : String(e);
+  return new ProviderError2(message, status);
+}
+function openai(opts = {}) {
+  const client = opts.client ?? new OpenAI({
+    apiKey: opts.apiKey ?? process.env["OPENAI_API_KEY"],
+    baseURL: opts.baseURL ?? process.env["OPENAI_BASE_URL"]
+  });
+  return {
+    id: "openai",
+    async *stream(req, signal) {
+      const params = toOpenAIParams(req);
+      try {
+        const raw = await client.chat.completions.create(
+          params,
+          signal ? { signal } : void 0
+        );
+        yield* translateStream2(raw);
+      } catch (e) {
+        throw toProviderError2(e);
+      }
+    }
+  };
+}
+export {
+  anthropic,
+  openai
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@lite-agent/provider",
+  "version": "0.1.0",
+  "description": "Model providers for lite-agent: Anthropic Messages API + OpenAI Chat Completions (also OpenAI-compatible / local endpoints).",
+  "license": "ISC",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "agent",
+    "ai",
+    "llm",
+    "anthropic",
+    "claude",
+    "openai",
+    "provider"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NelsonYong/lite-agent.git",
+    "directory": "packages/provider"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean --tsconfig tsconfig.build.json",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.80.0",
+    "@lite-agent/core": "workspace:*",
+    "openai": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsup": "^8.3.0",
+    "typescript": "^6.0.2",
+    "vitest": "^2.1.0"
+  }
+}