@rowan-agent/models 0.4.4

package/dist/index-ChnUfIk1.d.cts

@@ -0,0 +1,426 @@
+type KnownApi = "openai-completions" | "openai-responses" | "anthropic-messages";
+type Api = KnownApi | (string & {});
+type KnownProvider = "openai" | "anthropic" | "deepseek" | "openrouter" | "groq" | "together" | "fireworks" | "xai" | "cerebras";
+type Provider = KnownProvider | string;
+interface ModelCost {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+}
+interface Model {
+    id: string;
+    name: string;
+    api: Api;
+    provider: Provider;
+    baseUrl: string;
+    reasoning: boolean;
+    input: ("text" | "image")[];
+    cost: ModelCost;
+    contextWindow: number;
+    maxTokens: number;
+    headers?: Record<string, string>;
+}
+type ProviderModelConfig = {
+    id: string;
+    name: string;
+    api: Api;
+    reasoning: boolean;
+    input: ("text" | "image")[];
+    cost: ModelCost;
+    contextWindow: number;
+    maxTokens: number;
+};
+type ProviderConfig = {
+    name: string;
+    baseUrl: string;
+    apiKey?: string;
+    api: Api;
+    streamSimple?: ApiStreamFn;
+    headers?: Record<string, string>;
+    authHeader?: string;
+    models: ProviderModelConfig[];
+    oauth?: {
+        clientId: string;
+        scopes?: string[];
+        tokenEndpoint?: string;
+    };
+};
+type LlmModelRef = {
+    provider: string;
+    name: string;
+};
+type LlmTokenUsage = {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+};
+type LlmModelUsage = LlmTokenUsage & {
+    inputMessages: number;
+};
+type LlmTextContent = {
+    type: "text";
+    text: string;
+};
+type LlmImageContent = {
+    type: "image";
+    data: string;
+    mimeType: string;
+};
+type LlmThinkingContent = {
+    type: "thinking";
+    thinking: string;
+    signature?: string;
+};
+type LlmToolUseContent = {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: unknown;
+};
+type LlmToolResultContent = {
+    type: "tool_result";
+    toolUseId: string;
+    content: string;
+    isError?: boolean;
+};
+type LlmContentPart = LlmTextContent | LlmImageContent | LlmThinkingContent | LlmToolUseContent | LlmToolResultContent;
+type LlmMessage = {
+    role: "user" | "assistant" | "tool";
+    content: string | LlmContentPart[];
+};
+type LlmToolDefinition = {
+    name: string;
+    description: string;
+    parameters: unknown;
+};
+type LlmToolCall = {
+    id: string;
+    name: string;
+    arguments: unknown;
+};
+type LlmToolChoice = "auto" | "required" | "none" | {
+    type: "tool";
+    name: string;
+};
+type LlmRequest = {
+    model: LlmModelRef;
+    system?: string;
+    messages: LlmMessage[];
+    tools?: LlmToolDefinition[];
+    toolChoice?: LlmToolChoice;
+    maxTokens?: number;
+    temperature?: number;
+};
+type LlmStopReason = "end_turn" | "tool_use" | "max_tokens" | "stop" | "error" | "unknown";
+type LlmResponse = {
+    content: string;
+    thinking?: string;
+    toolCalls?: LlmToolCall[];
+    stopReason?: LlmStopReason;
+    usage?: LlmTokenUsage;
+};
+type TextBlock = {
+    type: "text";
+    text: string;
+};
+type ThinkingBlock = {
+    type: "thinking";
+    thinking: string;
+};
+type ToolCallBlock = {
+    type: "tool_call";
+    id: string;
+    name: string;
+    args: string;
+};
+type ContentBlock = TextBlock | ThinkingBlock | ToolCallBlock;
+/**
+ * Accumulated assistant message partial, carried by each streaming event.
+ * The provider builds this incrementally; the consumer reads it directly.
+ */
+type AssistantMessagePartial = {
+    role: "assistant";
+    contentBlocks: ContentBlock[];
+    stopReason?: LlmStopReason;
+};
+type LlmStreamEvent = {
+    type: "start";
+    partial: AssistantMessagePartial;
+} | {
+    type: "text_delta";
+    text: string;
+    partial: AssistantMessagePartial;
+} | {
+    type: "thinking_delta";
+    thinking: string;
+    partial: AssistantMessagePartial;
+} | {
+    type: "tool_call_start";
+    id: string;
+    name: string;
+    partial: AssistantMessagePartial;
+} | {
+    type: "tool_call_delta";
+    id: string;
+    arguments: string;
+    partial: AssistantMessagePartial;
+} | {
+    type: "tool_call_end";
+    id: string;
+    name: string;
+    arguments: string;
+    partial: AssistantMessagePartial;
+} | {
+    type: "model_requested";
+    model: LlmModelRef;
+    usage: LlmModelUsage;
+} | {
+    type: "error";
+    error: Error;
+} | {
+    type: "done";
+    response?: LlmResponse;
+};
+declare function textFromPartial(partial: AssistantMessagePartial): string;
+declare function toolCallsFromPartial(partial: AssistantMessagePartial): ToolCallBlock[];
+type LlmStreamOptions = {
+    signal?: AbortSignal;
+};
+/**
+ * Low-level stream function: receives a full LlmRequest and yields events.
+ * This is the function the agent loop consumes.
+ */
+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.
+ */
+type ApiStreamFn = (model: Model, request: LlmRequest, options: LlmStreamOptions) => AsyncIterable<LlmStreamEvent>;
+type AgentContextMessage = {
+    id: string;
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    createdAt: string;
+    metadata?: Record<string, unknown> & {
+        phase?: string;
+        toolCalls?: Array<{
+            id: string;
+            name: string;
+            args: unknown;
+        }>;
+        toolCallId?: string;
+        toolName?: string;
+        isError?: boolean;
+    };
+};
+type AgentContextSkill = {
+    name: string;
+    description: string;
+    filePath: string;
+    baseDir: string;
+    disableModelInvocation: boolean;
+};
+type Outcome = {
+    id: string;
+    taskId?: string;
+    message: string;
+};
+type ToolCall = {
+    id: string;
+    name: string;
+    args: unknown;
+};
+type ToolResult = {
+    toolCallId: string;
+    toolName: string;
+    ok: boolean;
+    content: unknown;
+    error?: string;
+};
+type AgentEvent = {
+    type: "agent_start";
+    sessionId: string;
+    ts: string;
+} | {
+    type: "agent_end";
+    sessionId: string;
+    messages: AgentContextMessage[];
+    ts: string;
+} | {
+    type: "turn_start";
+    content: AgentContextMessage[];
+    ts: string;
+} | {
+    type: "turn_end";
+    content: AgentContextMessage[];
+    outcome?: Outcome;
+    ts: string;
+} | {
+    type: "model_requested";
+    model: LlmModelRef;
+    usage: LlmModelUsage;
+    ts: string;
+} | {
+    type: "phase_start";
+    phase: string;
+    ts: string;
+} | {
+    type: "phase_end";
+    phase: string;
+    ts: string;
+} | {
+    type: "message_start";
+    message: AgentContextMessage;
+    ts: string;
+} | {
+    type: "message_update";
+    message: AgentContextMessage;
+    delta: string;
+    ts: string;
+} | {
+    type: "message_end";
+    message: AgentContextMessage;
+    ts: string;
+} | {
+    type: "tool_execution_start";
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    ts: string;
+} | {
+    type: "tool_execution_update";
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    partialResult: unknown;
+    ts: string;
+} | {
+    type: "tool_execution_end";
+    toolCallId: string;
+    toolName: string;
+    result: ToolResult;
+    isError: boolean;
+    ts: string;
+};
+type AgentEventListener = ((event: AgentEvent) => void | Promise<void>) & {
+    flush?: () => void | Promise<void>;
+};
+
+declare class ProviderError extends Error {
+    readonly code: string;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly details?: Record<string, unknown>;
+    constructor(input: {
+        code: string;
+        message: string;
+        status?: number;
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+    });
+}
+
+type ProviderFetch = (input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => ReturnType<typeof fetch>;
+type BaseProviderConfig = {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    timeoutMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    fetch?: ProviderFetch;
+};
+
+type OpenAICompletionsConfig = BaseProviderConfig & {
+    responseFormat?: boolean;
+};
+type ResolveOpenAICompletionsConfigInput = {
+    baseUrl?: string;
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    timeoutMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    fetch?: ProviderFetch;
+    responseFormat?: boolean;
+    env?: Record<string, string | undefined>;
+};
+declare function resolveOpenAICompletionsConfig(input?: ResolveOpenAICompletionsConfigInput): OpenAICompletionsConfig;
+declare function createOpenAICompletionsStream(config: OpenAICompletionsConfig): StreamFn;
+/**
+ * ApiStreamFn-compatible stream function for OpenAI Chat Completions API.
+ * Resolves config from the Model descriptor and environment.
+ */
+declare const streamOpenAICompletions: ApiStreamFn;
+declare function callOpenAICompletions(config: OpenAICompletionsConfig, request: LlmRequest, options?: LlmStreamOptions): Promise<{
+    content: string;
+    usage?: LlmTokenUsage;
+}>;
+
+type OpenAIResponsesConfig = BaseProviderConfig & {
+    reasoningEffort?: "low" | "medium" | "high";
+};
+type ResolveOpenAIResponsesConfigInput = {
+    baseUrl?: string;
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    timeoutMs?: number;
+    maxRetries?: number;
+    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;
+/**
+ * ApiStreamFn-compatible stream function for OpenAI Responses API.
+ * Resolves config from the Model descriptor and environment.
+ */
+declare const streamOpenAIResponses: ApiStreamFn;
+
+type AnthropicConfig = {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    maxTokens?: number;
+    timeoutMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    fetch?: ProviderFetch;
+    thinking?: {
+        budgetTokens: number;
+    };
+};
+type ResolveAnthropicConfigInput = {
+    baseUrl?: string;
+    apiKey?: string;
+    model?: string;
+    maxTokens?: number;
+    timeoutMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    fetch?: ProviderFetch;
+    thinking?: {
+        budgetTokens: number;
+    };
+    env?: Record<string, string | undefined>;
+};
+declare function resolveAnthropicConfig(input?: ResolveAnthropicConfigInput): AnthropicConfig;
+declare function createAnthropicStream(config: AnthropicConfig): StreamFn;
+/**
+ * ApiStreamFn-compatible stream function for Anthropic Messages API.
+ * Resolves config from the Model descriptor and environment.
+ */
+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 };