@rowan-agent/models 0.4.4 → 0.4.7

package/README.md

@@ -1,36 +1,183 @@
-# @rowan-agent/adapters
+# @rowan-agent/models
 
-## Main Features
+Model registry, streaming provider implementations, cost calculation, and protocol types. Supports OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages APIs with streaming, retry, tool calling, and thinking/reasoning.
 
-`@rowan-agent/adapters` connects external model services to the Rowan runtime protocol. The current primary implementation is an OpenAI-compatible Chat Completions adapter that resolves configuration, builds requests, handles retries and timeouts, and normalizes JSON model output into typed Rowan phase output events such as routing decisions, tasks, tool calls, and verification results.
+## Installation
 
-The package also provides JSON extraction helpers. They can parse complete JSON, `json` fenced code blocks, or balanced JSON fragments embedded in text. When model output does not match the expected contract, the adapter raises `OpenAICompatibleError` or `JsonExtractionError` with useful error codes for logging and recovery.
+```bash
+bun add @rowan-agent/models
+```
+
+## Quick Start
+
+```ts
+import { resolveModel, calculateCost, stream } from "@rowan-agent/models";
+
+const model = resolveModel("anthropic/claude-sonnet-4-20250514");
+
+for await (const event of stream(model, request, { signal })) {
+  if (event.type === "text_delta") process.stdout.write(event.delta);
+}
+
+const cost = calculateCost(model, usage);
+console.log(cost.total); // USD
+```
+
+## Model Registry
+
+An in-memory registry of model definitions. Models are auto-registered on import from `models.generated.ts`. Use `resolveModel` for quick lookup by `"provider/model"` string, or `registerModel` to add custom models.
+
+```ts
+import { registerModel, getModel, resolveModel, getProviders, getModels, getAllModels } from "@rowan-agent/models";
+
+registerModel({
+  id: "gpt-4.1-mini", name: "gpt-4.1-mini",
+  api: "openai-completions", provider: "openai",
+  baseUrl: "https://api.openai.com/v1",
+  reasoning: false, input: ["text", "image"],
+  cost: { input: 0.40, output: 1.60, cacheRead: 0.10, cacheWrite: 0.40 },
+  contextWindow: 1047576, maxTokens: 32768,
+});
+
+const model = resolveModel("openai/gpt-4.1-mini");
+const providers = getProviders();           // ["openai", "anthropic", ...]
+const all = getAllModels();                  // Model[]
+```
+
+### Pre-registered Models
 
-## Architecture
+| Provider | Models |
+|----------|--------|
+| `anthropic` | claude-sonnet-4-20250514, claude-opus-4-20250514, claude-haiku-4-20250514 |
+| `openai` | gpt-4o, and others |
 
-`src/index.ts` exports the package surface.
+## Cost Calculation
 
-`src/openai-compatible.ts` is the main adapter layer and has three core responsibilities:
+Computes per-token costs from usage data, broken down by input, output, cache read, and cache write.
 
-- `resolveOpenAICompatibleConfig` resolves `baseUrl`, `apiKey`, `model`, timeout, retry, and tool settings from input options and environment variables.
-- `callOpenAICompatibleChatCompletion` wraps HTTP requests, response parsing, error normalization, exponential backoff retries, and abort/timeout handling.
-- `createOpenAICompatibleStream` implements Rowan's `StreamFn`, uses `@rowan-agent/context` to build phase prompts, and converts model output into typed `phase_output` events from `@rowan-agent/protocol`.
+```ts
+import { calculateCost, resolveModel } from "@rowan-agent/models";
+
+const model = resolveModel("anthropic/claude-sonnet-4-20250514")!;
+const cost = calculateCost(model, {
+  inputTokens: 1000, outputTokens: 500,
+  cacheReadTokens: 2000, cacheWriteTokens: 100,
+});
+// cost = { input, output, cacheRead, cacheWrite, total }
+```
+
+## Providers
+
+Three built-in API providers, each with streaming support and exponential backoff retry.
+
+### Provider Registry
+
+The dispatch layer routes requests to the right provider based on the model's `api` field.
+
+```ts
+import { stream, streamByRef, createDispatchStream, registerApiProvider } from "@rowan-agent/models";
+
+for await (const event of stream(model, request, { signal })) { ... }
+for await (const event of streamByRef("openai/gpt-4.1-mini", request)) { ... }
 
-`src/json-extract.ts` only handles JSON extraction and parse errors from model text. It is independent from model providers and runtime phases.
+const streamFn = createDispatchStream();  // reusable StreamFn
+registerApiProvider({ api: "my-api", stream: myApiStreamFn });  // custom provider
+```
 
-## Usage Flow
+### OpenAI Chat Completions
 
-1. Prepare OpenAI-compatible environment variables: `ROWAN_OPENAI_BASE_URL` is optional, while `ROWAN_OPENAI_API_KEY` and `ROWAN_MODEL` are required.
-2. Call `resolveOpenAICompatibleConfig` and pass the runtime tools through `tools`.
-3. Call `createOpenAICompatibleStream` to create a `StreamFn` that the Rowan runtime can consume.
-4. Pass the `stream` to `Agent` from `@rowan-agent/agent`.
+Endpoint: `{baseUrl}/chat/completions`. Auth: `Authorization: Bearer`.
 
 ```ts
-import {
-  createOpenAICompatibleStream,
-  resolveOpenAICompatibleConfig,
-} from "@rowan-agent/adapters";
+import { resolveOpenAICompletionsConfig, createOpenAICompletionsStream, callOpenAICompletions } from "@rowan-agent/models/providers";
 
-const config = resolveOpenAICompatibleConfig({ tools });
-const stream = createOpenAICompatibleStream(config);
+const config = resolveOpenAICompletionsConfig();           // from env vars
+const streamFn = createOpenAICompletionsStream(config);    // StreamFn
+const response = await callOpenAICompletions(config, req); // non-streaming
 ```
+
+Supports: text, image (base64), tool calling, streaming (SSE with non-streaming fallback), JSON response format.
+
+### OpenAI Responses
+
+Endpoint: `{baseUrl}/responses`. Auth: `Authorization: Bearer`.
+
+```ts
+import { resolveOpenAIResponsesConfig, createOpenAIResponsesStream } from "@rowan-agent/models/providers";
+
+const config = resolveOpenAIResponsesConfig({ reasoningEffort: "high" });
+const streamFn = createOpenAIResponsesStream(config);
+```
+
+Supports: text, tool calling, streaming (always), thinking/reasoning via `reasoningEffort`.
+
+### Anthropic Messages
+
+Endpoint: `{baseUrl}/v1/messages`. Auth: `x-api-key` + `anthropic-version: 2023-06-01`.
+
+```ts
+import { resolveAnthropicConfig, createAnthropicStream } from "@rowan-agent/models/providers";
+
+const config = resolveAnthropicConfig({ thinking: { budgetTokens: 10000 } });
+const streamFn = createAnthropicStream(config);
+```
+
+Supports: text, image (base64), tool calling, streaming (always), thinking/reasoning via `thinking.budgetTokens`.
+
+## SSE Streaming
+
+Low-level SSE parser for `ReadableStream` bodies.
+
+```ts
+import { iterateSseMessages } from "@rowan-agent/models";
+
+for await (const sse of iterateSseMessages(response.body!, signal)) {
+  if (sse.data === "[DONE]") break;
+  const chunk = JSON.parse(sse.data);
+}
+```
+
+## Protocol Types
+
+Shared types for LLM requests, responses, stream events, and agent-level constructs.
+
+```ts
+type LlmRequest = { model: LlmModelRef; system?: string; messages: LlmMessage[]; tools?: LlmToolDefinition[]; toolChoice?: LlmToolChoice; maxTokens?: number; temperature?: number };
+type LlmResponse = { content: string; thinking?: string; toolCalls?: LlmToolCall[]; stopReason?: LlmStopReason; usage?: LlmTokenUsage };
+type LlmStreamEvent = { type: "start" } | { type: "text_delta"; delta: string } | { type: "thinking_delta"; delta: string } | { type: "tool_call_start"; ... } | { type: "done"; stopReason: LlmStopReason } | ...;
+type StreamFn = (request: LlmRequest, options: LlmStreamOptions) => AsyncIterable<LlmStreamEvent>;
+type LlmModelRef = { provider: string; name: string };
+type Model = { id: string; name: string; api: Api; provider: Provider; baseUrl: string; reasoning: boolean; input: ("text" | "image")[]; cost: ModelCost; contextWindow: number; maxTokens: number };
+type KnownApi = "openai-completions" | "openai-responses" | "anthropic-messages";
+type KnownProvider = "openai" | "anthropic" | "deepseek" | "openrouter" | "groq" | "together" | "fireworks" | "xai" | "cerebras";
+```
+
+Agent-level types shared with the agent package:
+
+```ts
+type AgentMessage = { id: string; role: "system" | "user" | "assistant" | "tool"; content: string | LlmContentPart[]; createdAt: string };
+type AgentEvent = { type: "agent_start" | "agent_end" | "turn_start" | ... ; ts: string; ... };
+type ToolCall = { id: string; name: string; args: unknown };
+type ToolResult = { toolCallId: string; toolName: string; ok: boolean; content: unknown; error?: string };
+type Outcome = { id: string; message: string; toolResults?: Array<...> };
+```
+
+## Source Structure
+
+```
+src/
+├── protocol.ts           # All protocol types
+├── models.ts             # Model registry
+├── models.generated.ts   # Pre-registered model catalog
+├── registry.ts           # API provider dispatch (stream, streamByRef)
+├── sse.ts                # SSE parser
+└── providers/
+    ├── openai-completions.ts
+    ├── openai-responses.ts
+    ├── anthropic.ts
+    └── shared.ts         # ProviderError, retry utilities
+```
+
+## Version
+
+Current version: **0.4.6**

package/dist/{chunk-J6S6ZJJA.js → chunk-C4RRYNAJ.js}

@@ -13,9 +13,6 @@ var ProviderError = class extends Error {
     this.details = input.details;
   }
 };
-function defaultEnv() {
-  return process.env;
-}
 function normalizeBaseUrl(baseUrl) {
   return baseUrl.replace(/\/+$/, "");
 }
@@ -152,6 +149,14 @@ function normalizeUsage(usage) {
 function summarizeRequestUsage(request) {
   return { inputMessages: request.messages.length + (request.system ? 1 : 0) };
 }
+function sanitizeToolInput(input) {
+  if (typeof input !== "string") return input;
+  try {
+    return JSON.parse(input);
+  } catch {
+    return input;
+  }
+}
 
 // src/sse.ts
 function flushSseEvent(state) {
@@ -247,14 +252,13 @@ async function* iterateSseMessages(body, signal) {
 
 // src/providers/openai-completions.ts
 function resolveOpenAICompletionsConfig(input = {}) {
-  const env = input.env ?? defaultEnv();
-  const baseUrl = nonEmpty(input.baseUrl) ?? nonEmpty(env.ROWAN_OPENAI_BASE_URL) ?? "https://api.openai.com/v1";
-  const apiKey = nonEmpty(input.apiKey) ?? nonEmpty(env.ROWAN_OPENAI_API_KEY);
-  const model = nonEmpty(input.model) ?? nonEmpty(env.ROWAN_MODEL);
+  const baseUrl = nonEmpty(input.baseUrl) ?? "https://api.openai.com/v1";
+  const apiKey = nonEmpty(input.apiKey);
+  const model = nonEmpty(input.model);
   return {
     baseUrl: normalizeBaseUrl(baseUrl),
-    apiKey: requireValue("API key", apiKey, "set ROWAN_OPENAI_API_KEY or pass --api-key"),
-    model: requireValue("model", model, "set ROWAN_MODEL or pass --model"),
+    apiKey: requireValue("API key", apiKey, "model.apiKey is required (set apiKey in config.yaml or pass --api-key)"),
+    model: requireValue("model", model, "model.id is required"),
     ...input.temperature !== void 0 ? { temperature: input.temperature } : {},
     ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {},
     ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
@@ -330,7 +334,7 @@ function convertMessages(messages) {
             type: "function",
             function: {
               name: p.name,
-              arguments: typeof p.input === "string" ? p.input : JSON.stringify(p.input)
+              arguments: JSON.stringify(sanitizeToolInput(p.input))
             }
           }));
           result.push({ role: "assistant", content: text, tool_calls: toolCalls });
@@ -582,7 +586,11 @@ function createOpenAICompletionsStream(config) {
 var streamOpenAICompletions = (model, request, options) => {
   const config = resolveOpenAICompletionsConfig({
     baseUrl: model.baseUrl,
-    model: model.id
+    model: model.id,
+    apiKey: model.apiKey,
+    timeoutMs: model.timeoutMs,
+    maxRetries: model.maxRetries,
+    retryDelayMs: model.retryDelayMs
   });
   return streamChatCompletions(config, request, options);
 };
@@ -620,14 +628,13 @@ async function callOpenAICompletions(config, request, options = {}) {
 
 // src/providers/openai-responses.ts
 function resolveOpenAIResponsesConfig(input = {}) {
-  const env = input.env ?? defaultEnv();
-  const baseUrl = nonEmpty(input.baseUrl) ?? nonEmpty(env.ROWAN_OPENAI_BASE_URL) ?? "https://api.openai.com/v1";
-  const apiKey = nonEmpty(input.apiKey) ?? nonEmpty(env.ROWAN_OPENAI_API_KEY);
-  const model = nonEmpty(input.model) ?? nonEmpty(env.ROWAN_MODEL);
+  const baseUrl = nonEmpty(input.baseUrl) ?? "https://api.openai.com/v1";
+  const apiKey = nonEmpty(input.apiKey);
+  const model = nonEmpty(input.model);
   return {
     baseUrl: normalizeBaseUrl(baseUrl),
-    apiKey: requireValue("API key", apiKey, "set ROWAN_OPENAI_API_KEY or pass --api-key"),
-    model: requireValue("model", model, "set ROWAN_MODEL or pass --model"),
+    apiKey: requireValue("API key", apiKey, "model.apiKey is required (set apiKey in config.yaml or pass --api-key)"),
+    model: requireValue("model", model, "model.id is required"),
     ...input.temperature !== void 0 ? { temperature: input.temperature } : {},
     ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {},
     ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
@@ -674,7 +681,7 @@ function convertMessages2(messages) {
               type: "function_call",
               id: part.id,
               name: part.name,
-              arguments: typeof part.input === "string" ? part.input : JSON.stringify(part.input)
+              arguments: JSON.stringify(sanitizeToolInput(part.input))
             });
           }
         }
@@ -905,7 +912,11 @@ function createOpenAIResponsesStream(config) {
 var streamOpenAIResponses = (model, request, options) => {
   const config = resolveOpenAIResponsesConfig({
     baseUrl: model.baseUrl,
-    model: model.id
+    model: model.id,
+    apiKey: model.apiKey,
+    timeoutMs: model.timeoutMs,
+    maxRetries: model.maxRetries,
+    retryDelayMs: model.retryDelayMs
   });
   return streamResponses(config, request, options);
 };
@@ -913,14 +924,13 @@ var streamOpenAIResponses = (model, request, options) => {
 // src/providers/anthropic.ts
 var DEFAULT_MAX_TOKENS = 8192;
 function resolveAnthropicConfig(input = {}) {
-  const env = input.env ?? defaultEnv();
-  const baseUrl = nonEmpty(input.baseUrl) ?? nonEmpty(env.ROWAN_ANTHROPIC_BASE_URL) ?? "https://api.anthropic.com";
-  const apiKey = nonEmpty(input.apiKey) ?? nonEmpty(env.ROWAN_ANTHROPIC_API_KEY) ?? nonEmpty(env.ANTHROPIC_API_KEY);
-  const model = nonEmpty(input.model) ?? nonEmpty(env.ROWAN_MODEL);
+  const baseUrl = nonEmpty(input.baseUrl) ?? "https://api.anthropic.com";
+  const apiKey = nonEmpty(input.apiKey);
+  const model = nonEmpty(input.model);
   return {
     baseUrl: normalizeBaseUrl(baseUrl),
-    apiKey: requireValue("API key", apiKey, "set ROWAN_ANTHROPIC_API_KEY or pass --api-key"),
-    model: requireValue("model", model, "set ROWAN_MODEL or pass --model"),
+    apiKey: requireValue("API key", apiKey, "model.apiKey is required (set apiKey in config.yaml or pass --api-key)"),
+    model: requireValue("model", model, "model.id is required"),
     ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {},
     ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
     ...input.maxRetries !== void 0 ? { maxRetries: input.maxRetries } : {},
@@ -1206,7 +1216,11 @@ function createAnthropicStream(config) {
 var streamAnthropic = (model, request, options) => {
   const config = resolveAnthropicConfig({
     baseUrl: model.baseUrl,
-    model: model.id
+    model: model.id,
+    apiKey: model.apiKey,
+    timeoutMs: model.timeoutMs,
+    maxRetries: model.maxRetries,
+    retryDelayMs: model.retryDelayMs
   });
   return streamAnthropicMessages(config, request, options);
 };

package/dist/{index-ChnUfIk1.d.cts → index-BGAiAdlQ.d.cts}

@@ -1,5 +1,5 @@
-type KnownApi = "openai-completions" | "openai-responses" | "anthropic-messages";
-type Api = KnownApi | (string & {});
+type KnownProtocol = "openai-completions" | "openai-responses" | "anthropic-messages";
+type Protocol = KnownProtocol | (string & {});
 type KnownProvider = "openai" | "anthropic" | "deepseek" | "openrouter" | "groq" | "together" | "fireworks" | "xai" | "cerebras";
 type Provider = KnownProvider | string;
 interface ModelCost {
@@ -10,8 +10,8 @@ interface ModelCost {
 }
 interface Model {
     id: string;
-    name: string;
-    api: Api;
+    name?: string;
+    protocol: Protocol;
     provider: Provider;
     baseUrl: string;
     reasoning: boolean;
@@ -20,11 +20,15 @@ interface Model {
     contextWindow: number;
     maxTokens: number;
     headers?: Record<string, string>;
+    apiKey?: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
 }
 type ProviderModelConfig = {
     id: string;
-    name: string;
-    api: Api;
+    name?: string;
+    protocol: Protocol;
     reasoning: boolean;
     input: ("text" | "image")[];
     cost: ModelCost;
@@ -32,10 +36,10 @@ type ProviderModelConfig = {
     maxTokens: number;
 };
 type ProviderConfig = {
-    name: string;
+    id: string;
     baseUrl: string;
-    apiKey?: string;
-    api: Api;
+    apiKey: string;
+    protocol: Protocol;
     streamSimple?: ApiStreamFn;
     headers?: Record<string, string>;
     authHeader?: string;
@@ -48,7 +52,7 @@ type ProviderConfig = {
 };
 type LlmModelRef = {
     provider: string;
-    name: string;
+    id: string;
 };
 type LlmTokenUsage = {
     inputTokens?: number;
@@ -196,37 +200,39 @@ type LlmStreamOptions = {
 type StreamFn = (request: LlmRequest, options: LlmStreamOptions) => AsyncIterable<LlmStreamEvent>;
 /**
  * API-level stream function: receives a resolved Model and yields events.
- * Providers implement this signature. The registry dispatches by model.api.
+ * Providers implement this signature. The registry dispatches by model.protocol.
  */
 type ApiStreamFn = (model: Model, request: LlmRequest, options: LlmStreamOptions) => AsyncIterable<LlmStreamEvent>;
-type AgentContextMessage = {
+type AgentMessage = {
     id: string;
     role: "system" | "user" | "assistant" | "tool";
-    content: string;
+    content: string | LlmContentPart[];
     createdAt: string;
     metadata?: Record<string, unknown> & {
         phase?: string;
-        toolCalls?: Array<{
-            id: string;
-            name: string;
-            args: unknown;
-        }>;
-        toolCallId?: string;
-        toolName?: string;
-        isError?: boolean;
     };
 };
-type AgentContextSkill = {
+type Skill = {
     name: string;
     description: string;
+    /** Absolute path to the SKILL.md file */
     filePath: string;
+    /** Directory containing the SKILL.md file */
     baseDir: string;
+    /** Full body content of the SKILL.md (after frontmatter) */
+    content: string;
     disableModelInvocation: boolean;
 };
 type Outcome = {
     id: string;
-    taskId?: string;
     message: string;
+    toolResults?: Array<{
+        toolCallId: string;
+        toolName: string;
+        ok: boolean;
+        content: unknown;
+        error?: string;
+    }>;
 };
 type ToolCall = {
     id: string;
@@ -247,15 +253,15 @@ type AgentEvent = {
 } | {
     type: "agent_end";
     sessionId: string;
-    messages: AgentContextMessage[];
+    messages: AgentMessage[];
     ts: string;
 } | {
     type: "turn_start";
-    content: AgentContextMessage[];
+    content: AgentMessage[];
     ts: string;
 } | {
     type: "turn_end";
-    content: AgentContextMessage[];
+    content: AgentMessage[];
     outcome?: Outcome;
     ts: string;
 } | {
@@ -273,16 +279,16 @@ type AgentEvent = {
     ts: string;
 } | {
     type: "message_start";
-    message: AgentContextMessage;
+    message: AgentMessage;
     ts: string;
 } | {
     type: "message_update";
-    message: AgentContextMessage;
+    message: AgentMessage;
     delta: string;
     ts: string;
 } | {
     type: "message_end";
-    message: AgentContextMessage;
+    message: AgentMessage;
     ts: string;
 } | {
     type: "tool_execution_start";
@@ -350,7 +356,6 @@ type ResolveOpenAICompletionsConfigInput = {
     retryDelayMs?: number;
     fetch?: ProviderFetch;
     responseFormat?: boolean;
-    env?: Record<string, string | undefined>;
 };
 declare function resolveOpenAICompletionsConfig(input?: ResolveOpenAICompletionsConfigInput): OpenAICompletionsConfig;
 declare function createOpenAICompletionsStream(config: OpenAICompletionsConfig): StreamFn;
@@ -378,7 +383,6 @@ type ResolveOpenAIResponsesConfigInput = {
     retryDelayMs?: number;
     fetch?: ProviderFetch;
     reasoningEffort?: "low" | "medium" | "high";
-    env?: Record<string, string | undefined>;
 };
 declare function resolveOpenAIResponsesConfig(input?: ResolveOpenAIResponsesConfigInput): OpenAIResponsesConfig;
 declare function createOpenAIResponsesStream(config: OpenAIResponsesConfig): StreamFn;
@@ -413,7 +417,6 @@ type ResolveAnthropicConfigInput = {
     thinking?: {
         budgetTokens: number;
     };
-    env?: Record<string, string | undefined>;
 };
 declare function resolveAnthropicConfig(input?: ResolveAnthropicConfigInput): AnthropicConfig;
 declare function createAnthropicStream(config: AnthropicConfig): StreamFn;
@@ -423,4 +426,4 @@ declare function createAnthropicStream(config: AnthropicConfig): StreamFn;
  */
 declare const streamAnthropic: ApiStreamFn;
 
-export { resolveAnthropicConfig as $, type Api as A, type BaseProviderConfig as B, type ContentBlock as C, type OpenAIResponsesConfig as D, type Outcome as E, type ProviderConfig as F, ProviderError as G, type ProviderFetch as H, type ProviderModelConfig as I, type ResolveOpenAICompletionsConfigInput as J, type KnownApi as K, type LlmTokenUsage as L, type Model as M, type ResolveOpenAIResponsesConfigInput as N, type OpenAICompletionsConfig as O, type Provider as P, type ThinkingBlock as Q, type ResolveAnthropicConfigInput as R, type StreamFn as S, type TextBlock as T, type ToolCall as U, type ToolCallBlock as V, type ToolResult as W, callOpenAICompletions as X, createAnthropicStream as Y, createOpenAICompletionsStream as Z, createOpenAIResponsesStream as _, type ApiStreamFn as a, resolveOpenAICompletionsConfig as a0, resolveOpenAIResponsesConfig as a1, streamAnthropic as a2, streamOpenAICompletions as a3, streamOpenAIResponses as a4, textFromPartial as a5, toolCallsFromPartial as a6, type LlmRequest as b, type LlmStreamOptions as c, type LlmStreamEvent as d, type AgentContextMessage as e, type AgentContextSkill as f, type AgentEvent as g, type AgentEventListener as h, type AnthropicConfig as i, type AssistantMessagePartial as j, type KnownProvider as k, type LlmContentPart as l, type LlmImageContent as m, type LlmMessage as n, type LlmModelRef as o, type LlmModelUsage as p, type LlmResponse as q, type LlmStopReason as r, type LlmTextContent as s, type LlmThinkingContent as t, type LlmToolCall as u, type LlmToolChoice as v, type LlmToolDefinition as w, type LlmToolResultContent as x, type LlmToolUseContent as y, type ModelCost as z };
+export { resolveAnthropicConfig as $, type ApiStreamFn as A, type BaseProviderConfig as B, type ContentBlock as C, type Outcome as D, type ProviderConfig as E, ProviderError as F, type ProviderFetch as G, type ProviderModelConfig as H, type ResolveOpenAICompletionsConfigInput as I, type ResolveOpenAIResponsesConfigInput as J, type KnownProtocol as K, type LlmTokenUsage as L, type Model as M, type Skill as N, type OpenAICompletionsConfig as O, type Provider as P, type ThinkingBlock as Q, type ResolveAnthropicConfigInput as R, type StreamFn as S, type TextBlock as T, type ToolCall as U, type ToolCallBlock as V, type ToolResult as W, callOpenAICompletions as X, createAnthropicStream as Y, createOpenAICompletionsStream as Z, createOpenAIResponsesStream as _, type Protocol as a, resolveOpenAICompletionsConfig as a0, resolveOpenAIResponsesConfig as a1, streamAnthropic as a2, streamOpenAICompletions as a3, streamOpenAIResponses as a4, textFromPartial as a5, toolCallsFromPartial as a6, type LlmRequest as b, type LlmStreamOptions as c, type LlmStreamEvent as d, type AgentEvent as e, type AgentEventListener as f, type AgentMessage as g, type AnthropicConfig as h, type AssistantMessagePartial as i, type KnownProvider as j, type LlmContentPart as k, type LlmImageContent as l, type LlmMessage as m, type LlmModelRef as n, type LlmModelUsage as o, type LlmResponse as p, type LlmStopReason as q, type LlmTextContent as r, type LlmThinkingContent as s, type LlmToolCall as t, type LlmToolChoice as u, type LlmToolDefinition as v, type LlmToolResultContent as w, type LlmToolUseContent as x, type ModelCost as y, type OpenAIResponsesConfig as z };