@nuvin/agent-core 0.0.0-rc.9 → 0.0.0

package/dist/models/mock-model.d.ts

@@ -0,0 +1,15 @@
+import type { ChatRequest, ChatResponse, EngineChatModel, ModelExecutionOptions, ReasoningConfig } from "../shared/types.ts";
+export interface MockModelOptions {
+    model?: string;
+    maxTokens?: number;
+    reasoning?: ReasoningConfig;
+}
+export declare class MockModel implements EngineChatModel {
+    readonly model: string;
+    readonly maxTokens: number;
+    readonly requests: ChatRequest[];
+    private readonly reasoning?;
+    constructor(options?: MockModelOptions);
+    complete(request: ChatRequest, _options?: ModelExecutionOptions): Promise<ChatResponse>;
+}
+//# sourceMappingURL=mock-model.d.ts.map

package/dist/models/model-errors.d.ts

@@ -0,0 +1,16 @@
+export interface ProviderStreamEventErrorOptions {
+    code?: string;
+    retryable?: boolean;
+    status?: number;
+}
+export declare class ProviderRequestConstructionError extends Error {
+    constructor(message: string);
+}
+export declare class ProviderStreamEventError extends Error {
+    readonly code?: string;
+    readonly retryable: boolean;
+    readonly status?: number;
+    constructor(message: string, options?: ProviderStreamEventErrorOptions);
+}
+export declare function isRetryableProviderStreamEventError(error: unknown): boolean;
+//# sourceMappingURL=model-errors.d.ts.map

package/dist/models/model-limits.d.ts

@@ -0,0 +1,7 @@
+import type { ModelInfo, ModelLimits } from "../shared/types.ts";
+type RawModelResponse = Record<string, unknown>;
+export declare function getFallbackModelLimits(provider: string, model: string): ModelLimits | undefined;
+export declare function normalizeModelInfo(provider: string, model: RawModelResponse): ModelInfo;
+export declare function normalizeModelLimits(provider: string, model: RawModelResponse): ModelLimits | undefined;
+export {};
+//# sourceMappingURL=model-limits.d.ts.map

package/dist/models/model-registry.d.ts

@@ -0,0 +1,44 @@
+import type { ChatModelAuthScheme, ChatModelSurface } from "./chat-model.ts";
+export interface ModelProfile {
+    contextWindow?: number;
+    maxOutput?: number;
+    surface?: ChatModelSurface;
+    baseUrl?: string;
+}
+export interface ProviderProfile {
+    label?: string;
+    baseUrl?: string;
+    modelsBaseUrl?: string;
+    anthropicBaseUrl?: string;
+    surface?: ChatModelSurface;
+    authScheme?: ChatModelAuthScheme;
+    defaultModel?: string;
+    defaultModels: string[];
+    supportsModelFetch: boolean;
+    models: Record<string, ModelProfile>;
+}
+export interface ResolvedModelProfile {
+    label?: string;
+    baseUrl?: string;
+    modelsBaseUrl?: string;
+    anthropicBaseUrl?: string;
+    surface?: ChatModelSurface;
+    authScheme?: ChatModelAuthScheme;
+    defaultModel?: string;
+    defaultModels?: string[];
+    supportsModelFetch?: boolean;
+    contextWindow?: number;
+    maxOutput?: number;
+}
+export declare function getProviderProfile(provider: string): ProviderProfile | undefined;
+export declare function getModelProfile(provider: string, model: string): ModelProfile | undefined;
+export declare function resolveModelProfile(provider: string, model: string): ResolvedModelProfile | undefined;
+export declare function getDefaultMaxTokens(): number;
+export declare function getDefaultModel(): string;
+export declare function getCliDefaultModel(): string;
+export declare function getProviderLabel(provider: string): string | undefined;
+export declare function getProviderDefaultModel(provider: string): string | undefined;
+export declare function getProviderDefaultModels(provider: string): string[];
+export declare function providerSupportsModelFetch(provider: string): boolean;
+export declare function getOnboardingProviderKeys(): string[];
+//# sourceMappingURL=model-registry.d.ts.map

package/dist/models/model-surface-router.d.ts

@@ -0,0 +1,19 @@
+import type { ChatRequest } from "../shared/types.ts";
+export type RoutedModelMode = "complete" | "stream";
+export interface ModelSurfaceRouter {
+    selectSurface(request: ChatRequest, options: {
+        mode: RoutedModelMode;
+    }): Promise<string> | string;
+}
+export declare class StaticModelSurfaceRouter implements ModelSurfaceRouter {
+    private readonly completeSurface;
+    private readonly streamSurface;
+    constructor(options: {
+        complete: string;
+        stream: string;
+    });
+    selectSurface(_request: ChatRequest, options: {
+        mode: RoutedModelMode;
+    }): string;
+}
+//# sourceMappingURL=model-surface-router.d.ts.map

package/dist/models/model-transports.d.ts

@@ -0,0 +1,17 @@
+export interface ModelWebSocket {
+    readonly readyState: number;
+    addEventListener(type: "close" | "error" | "message" | "open", listener: EventListenerOrEventListenerObject): void;
+    close(code?: number, reason?: string): void;
+    removeEventListener(type: "close" | "error" | "message" | "open", listener: EventListenerOrEventListenerObject): void;
+    send(data: string): void;
+}
+export type WebSocketFactory = (options: {
+    headers: Record<string, string>;
+    url: string;
+}) => ModelWebSocket;
+export declare function createDefaultWebSocketFactory(): WebSocketFactory;
+export declare function iterateSseEvents(response: Response, signal?: AbortSignal): AsyncGenerator<string>;
+export declare function waitForWebSocketOpen(socket: ModelWebSocket, signal?: AbortSignal): Promise<void>;
+export declare function iterateWebSocketMessages(socket: ModelWebSocket, signal?: AbortSignal): AsyncIterable<Record<string, unknown>>;
+export declare function toWebSocketUrl(baseUrl: string, path: string): string;
+//# sourceMappingURL=model-transports.d.ts.map

package/dist/models/openai-model.d.ts

@@ -0,0 +1,67 @@
+import type { BaseChatModelOptions, ChatRequest, ChatResponse, ChatResponseChunk, ModelExecutionOptions, ProviderCredential } from "../shared/types.ts";
+import type { WebSocketFactory } from "./model-transports.ts";
+import { OpenAiApiError } from "./openai-surfaces.ts";
+import type { ProviderRequestMutator, ProviderSessionResolver, ResolvedProviderSession } from "./provider-session.ts";
+import { type ProviderSessionManager } from "./provider-session.ts";
+import { RoutedModel } from "./routed-model.ts";
+export type { WebSocketFactory } from "./model-transports.ts";
+export { OpenAiApiError };
+export interface OpenAiRequestHeadersContext {
+    request?: ChatRequest;
+    body: unknown;
+    credential: ProviderCredential;
+    session?: ResolvedProviderSession;
+    stream: boolean;
+}
+export type OpenAiHeaderResolver = (context: OpenAiRequestHeadersContext) => Promise<Record<string, string>> | Record<string, string>;
+export interface OpenAiModelOptions extends Partial<BaseChatModelOptions> {
+    apiKey?: string;
+    baseUrl?: string;
+    chatCompletionsPath?: string;
+    responsesPath?: string;
+    fetch?: typeof globalThis.fetch;
+    providerSessionResolver?: ProviderSessionResolver;
+    requestMutators?: ProviderRequestMutator[];
+    headerResolver?: OpenAiHeaderResolver;
+    sessionManager?: ProviderSessionManager;
+    webSocketFactory?: WebSocketFactory;
+}
+export declare class OpenAiModel extends RoutedModel {
+    private readonly responsesSocketSessions;
+    protected readonly chatCompletionsPath: string;
+    protected readonly responsesPath: string;
+    constructor(options?: OpenAiModelOptions);
+    protected completeViaChatCompletionsSurface(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    protected completeViaResponsesSurface(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    protected completeViaResponsesWebSocketSurface(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    protected streamViaChatCompletionsSurface(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    protected streamViaResponsesSurface(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    protected streamViaResponsesWebSocketSurface(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    chatComplete(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    response(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    responseSocket(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    chatStream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    responseStream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    responseSocketStream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    complete(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    stream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    private getResponsesSocketSessionState;
+    /**
+     * Drop an idle session state from the map so it does not accumulate for the
+     * life of this model instance. Only evicts when nothing is using it: no live
+     * or connecting socket and no held lock. Guarded against deleting a state that
+     * has already been replaced under the same key.
+     */
+    private maybeEvictResponsesSocketSession;
+    private getResponsesSocketSessionKey;
+    private acquireResponsesSocketLock;
+    private prepareResponsesSocketRequest;
+    private buildResponsesSocketEvent;
+    private findResponsesSocketCheckpoint;
+    private shouldRetryResponsesSocketRequest;
+    private invalidateResponsesSocketSession;
+    private getOrCreateResponsesSocket;
+    private streamViaPersistentResponsesSocket;
+    private streamViaResponsesSocketAttempt;
+}
+//# sourceMappingURL=openai-model.d.ts.map

package/dist/models/openai-surfaces.d.ts

@@ -0,0 +1,74 @@
+import { toOpenAiResponsesRequest } from "../formats/provider-adapters.ts";
+import type { ChatRequest, JsonSchemaObject, ToolSchema } from "../shared/types.ts";
+import type { RoutedModelStreamParser, RoutedModelSurface } from "./routed-model.ts";
+export declare const OPENAI_CHAT_COMPLETIONS_SURFACE = "openai-chat-completions";
+export declare const OPENAI_CHAT_COMPLETIONS_STREAM_SURFACE = "openai-chat-completions-stream";
+export declare const OPENAI_RESPONSES_SURFACE = "openai-responses";
+export declare const OPENAI_RESPONSES_STREAM_SURFACE = "openai-responses-stream";
+export declare const OPENAI_RESPONSES_WEBSOCKET_SURFACE = "openai-responses-ws";
+interface OpenAiChatCompletionToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface OpenAiChatCompletionToolDefinition {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters?: ToolSchema["input_schema"];
+    };
+}
+type OpenAiChatCompletionUserContentPart = {
+    type: "image_url";
+    image_url: {
+        url: string;
+    };
+} | {
+    type: "text";
+    text: string;
+};
+interface OpenAiChatCompletionMessage {
+    role: "assistant" | "system" | "tool" | "user";
+    content: null | string | OpenAiChatCompletionUserContentPart[];
+    tool_calls?: OpenAiChatCompletionToolCall[];
+    tool_call_id?: string;
+}
+interface OpenAiChatCompletionsRequest {
+    model: string;
+    messages: OpenAiChatCompletionMessage[];
+    max_completion_tokens?: number;
+    max_tokens?: number;
+    reasoning_effort?: "high" | "low" | "medium" | "minimal" | "none" | "xhigh";
+    stream: boolean;
+    tools?: OpenAiChatCompletionToolDefinition[];
+    response_format?: {
+        type: "json_schema";
+        json_schema: {
+            name: string;
+            schema: JsonSchemaObject;
+            strict: boolean;
+        };
+    };
+}
+export declare class OpenAiApiError extends Error {
+    readonly status: number;
+    readonly body: string;
+    constructor(status: number, body: string, message: string);
+}
+export declare function createChatRequestBody(request: ChatRequest, stream: boolean): OpenAiChatCompletionsRequest;
+export declare function createOpenAiResponsesWebSocketEvent(request: ChatRequest, options?: {
+    input?: ReturnType<typeof toOpenAiResponsesRequest>["input"];
+    previousResponseId?: string;
+}): Record<string, unknown>;
+export declare function createOpenAiApiError(response: Response): Promise<OpenAiApiError>;
+export declare function createOpenAiResponsesStreamParser(request: ChatRequest): RoutedModelStreamParser;
+export declare function createOpenAiSurfaces(options?: {
+    chatCompletionsPath?: string;
+    responsesPath?: string;
+}): RoutedModelSurface[];
+export {};
+//# sourceMappingURL=openai-surfaces.d.ts.map

package/dist/models/provider-adapter.d.ts

@@ -0,0 +1,23 @@
+import type { ChatRequest, ProviderCredential, ResolvedProviderSession } from "../shared/types.ts";
+export interface ProviderHeaderContext {
+    request?: ChatRequest;
+    body?: unknown;
+    credential: ProviderCredential;
+    session?: ResolvedProviderSession;
+    stream: boolean;
+}
+export interface ProviderAdapter {
+    createHeaders(context: ProviderHeaderContext, options: {
+        accept: string;
+        includeContentType?: boolean;
+    }): Headers | Promise<Headers>;
+    createMissingCredentialError(): Error;
+    mapApiError(error: Error): Error;
+    resolveBaseUrl(defaultBaseUrl: string, session: ResolvedProviderSession | undefined): string;
+    resolveCredential(apiKey: string | undefined, session: ResolvedProviderSession | undefined): ProviderCredential | undefined;
+    toApiError(response: Response): Promise<Error>;
+}
+export declare function trimTrailingSlashes(value: string): string;
+export declare function resolveApiCredential(apiKey: string | undefined, session: ResolvedProviderSession | undefined): ProviderCredential | undefined;
+export declare function resolveSessionBaseUrl(defaultBaseUrl: string, session: ResolvedProviderSession | undefined): string;
+//# sourceMappingURL=provider-adapter.d.ts.map

package/dist/models/provider-session.d.ts

@@ -0,0 +1,16 @@
+import type { ModelRequest, PreparedRequest, ProviderRequestMutator, ProviderSessionResolver, ResolvedProviderSession } from "../shared/types.ts";
+export type { ProviderCredential, ProviderCredentialKind, ProviderEndpoints, ProviderRequestMutator, ProviderSessionResolver, ResolvedProviderSession, } from "../shared/types.ts";
+export interface PrepareProviderRequestOptions {
+    sessionManager?: ProviderSessionManager;
+    requestMutators?: ProviderRequestMutator[];
+    signal?: AbortSignal;
+}
+export declare class ProviderSessionManager {
+    private readonly resolver;
+    private cached?;
+    constructor(resolver: ProviderSessionResolver);
+    resolve(signal?: AbortSignal): Promise<ResolvedProviderSession>;
+    invalidate(): void;
+}
+export declare function prepareProviderRequest(request: ModelRequest, options?: PrepareProviderRequestOptions): Promise<PreparedRequest>;
+//# sourceMappingURL=provider-session.d.ts.map

package/dist/models/routed-model.d.ts

@@ -0,0 +1,90 @@
+import type { ChatRequest, ChatResponse, ChatResponseChunk, EngineChatModel, ModelExecutionOptions, ReasoningConfig } from "../shared/types.ts";
+import type { ModelSurfaceRouter } from "./model-surface-router.ts";
+import type { WebSocketFactory } from "./model-transports.ts";
+import type { ProviderAdapter, ProviderHeaderContext } from "./provider-adapter.ts";
+import type { ProviderRequestMutator, ProviderSessionResolver } from "./provider-session.ts";
+import { ProviderSessionManager } from "./provider-session.ts";
+export interface RoutedModelStreamParser {
+    consumeSseEvent?(rawEvent: string): ChatResponseChunk[];
+    consumeWebSocketEvent?(event: Record<string, unknown>): ChatResponseChunk[];
+    finish(): ChatResponse;
+    isDone?(): boolean;
+}
+export interface RoutedModelSurfaceRequest {
+    accept?: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    initialEvent?: unknown;
+    path?: string;
+    url?: string;
+}
+export interface RoutedModelSurface {
+    id: string;
+    transport: "http-json" | "http-sse" | "websocket";
+    createRequest(request: ChatRequest): RoutedModelSurfaceRequest;
+    createStreamParser?(request: ChatRequest): RoutedModelStreamParser;
+    parseResponse?(payload: unknown, request: ChatRequest): ChatResponse;
+}
+export interface RoutedModelOptions {
+    apiKey?: string;
+    baseUrl: string;
+    fetch?: typeof globalThis.fetch;
+    model: string;
+    maxTokens?: number;
+    reasoning?: ReasoningConfig;
+    providerAdapter: ProviderAdapter;
+    providerSessionResolver?: ProviderSessionResolver;
+    requestMutators?: ProviderRequestMutator[];
+    router: ModelSurfaceRouter;
+    sessionManager?: ProviderSessionManager;
+    surfaces: RoutedModelSurface[];
+    webSocketFactory?: WebSocketFactory;
+}
+export declare class RoutedModel implements EngineChatModel {
+    readonly model: string;
+    readonly maxTokens: number;
+    protected readonly reasoning?: ReasoningConfig;
+    protected readonly apiKey?: string;
+    protected readonly baseUrl: string;
+    protected readonly fetchImpl: typeof globalThis.fetch;
+    protected readonly providerAdapter: ProviderAdapter;
+    protected readonly requestMutators: ProviderRequestMutator[];
+    protected readonly router: ModelSurfaceRouter;
+    protected readonly sessionManager?: ProviderSessionManager;
+    protected readonly webSocketFactory: WebSocketFactory;
+    private readonly surfaces;
+    constructor(options: RoutedModelOptions);
+    complete(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    stream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    protected completeViaRouter(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    protected streamViaRouter(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    protected completeViaSurface(request: ChatRequest, surfaceId: string, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    protected streamViaSurface(request: ChatRequest, surfaceId: string, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    protected sendRawRequest(options: {
+        accept?: string;
+        body?: unknown;
+        method: "GET" | "POST";
+        path: string;
+        signal?: AbortSignal;
+    }): Promise<Response>;
+    protected getRetryDelayMs(response: Response | undefined, attemptIndex: number): number;
+    private shouldRetryResponse;
+    private shouldRetryRequestError;
+    private shouldRetryStreamAttemptError;
+    private waitForRetry;
+    private sendWithRetries;
+    protected createMissingCredentialError(): Error;
+    protected createHeaders(context: ProviderHeaderContext, options: {
+        accept: string;
+        includeContentType?: boolean;
+    }): Promise<Headers>;
+    protected mapApiError(error: Error): Error;
+    protected toApiError(response: Response): Promise<Error>;
+    private getSurface;
+    private prepareChatRequest;
+    protected applyModelDefaults(request: ChatRequest): ChatRequest;
+    private sendHttpSurfaceRequest;
+    private streamHttpSurface;
+    private streamWebSocketSurface;
+}
+//# sourceMappingURL=routed-model.d.ts.map

package/dist/shared/abort.d.ts

@@ -0,0 +1,9 @@
+export declare class OperationAbortedError extends Error {
+    readonly code = "ABORT_ERR";
+    constructor(message?: string);
+}
+export declare function toAbortError(reason: unknown): Error;
+export declare function isAbortError(error: unknown): boolean;
+export declare function throwIfAborted(signal?: AbortSignal): void;
+export declare function addAbortListener(signal: AbortSignal | undefined, onAbort: () => void): () => void;
+//# sourceMappingURL=abort.d.ts.map

package/dist/shared/index.d.ts

@@ -1,17 +1,5 @@
-import { G as AutoReasoningEffort, v as ReasoningConfig, H as AnthropicThinkingConfig, I as OpenAiReasoningConfig } from '../types-Bb2eVtsy.js';
-export { aQ as AgentAssistantChunkEvent, aP as AgentAssistantMessageEvent, bl as AgentDefinition, bk as AgentDefinitionFactoryContext, A as AgentEvent, aB as AgentEventContext, b3 as AgentEventHandler, aY as AgentFinalMessageEvent, b as AgentInput, a$ as AgentLifecycleEvent, aN as AgentModelRequestEvent, aO as AgentModelResponseEvent, a as AgentOptions, a_ as AgentProviderRetryEvent, aU as AgentReasoningChunkEvent, aT as AgentReasoningMessageEvent, c as AgentSendOptions, aV as AgentToolCallEvent, aW as AgentToolResultEvent, aX as AgentToolResultMessageEvent, aS as AgentToolUseChunkEvent, aR as AgentToolUseMessageEvent, aZ as AgentTurnCompleteEvent, aM as AgentUserMessageEvent, ad as AnthropicAdaptiveThinkingConfig, a7 as AnthropicAssistantContentBlock, ae as AnthropicDisabledThinkingConfig, ac as AnthropicEnabledThinkingConfig, a2 as AnthropicRedactedThinkingBlock, a6 as AnthropicRedactedThinkingWireBlock, aq as AnthropicSignatureDeltaChunk, a1 as AnthropicThinkingBlock, ap as AnthropicThinkingDeltaChunk, aa as AnthropicThinkingDisplay, ab as AnthropicThinkingEffort, a5 as AnthropicThinkingWireBlock, bj as AnyExtensionRegistration, b9 as AnyToolDefinition, aE as AskUserAnswers, aC as AskUserOption, aD as AskUserQuestion, aF as AskUserQuestionRequest, ai as AssistantContentBlock, a9 as AutoReasoningConfig, B as BaseChatModelOptions, aA as ChatModel, C as ChatRequest, n as ChatResponse, w as ChatResponseChunk, k as CompileRequestInput, g as ContentBlock, an as ContentDeltaChunk, i as ContentInput, bt as CreateManagedRunInput, au as DoneChunk, E as EngineChatModel, be as ExtensionContext, d as ExtensionRegistry, ak as IdentifiedMessage, _ as ImageBlock, Z as ImageMediaType, b5 as InferJsonSchema, K as JsonObject, J as JsonPrimitive, Y as JsonSchema, W as JsonSchemaArray, V as JsonSchemaBoolean, U as JsonSchemaNumber, X as JsonSchemaObject, Q as JsonSchemaString, N as JsonSchemaType, L as JsonValue, bo as ManagedAgentRun, bp as ManagedAgentRunHandle, bn as ManagedRunError, bq as ManagedRunEvent, br as ManagedRunEventHandler, bm as ManagedRunStatus, M as Message, j as MessageInput, ah as MessageProviderState, aj as MessageRole, x as ModelExecutionOptions, y as ModelInfo, z as ModelLimits, l as ModelRequest, m as ModelResponse, bg as Observer, bi as ObserverExtensionRegistration, bb as ObserverOnlyStage, bx as OpenAiFunctionCall, by as OpenAiFunctionCallOutput, bF as OpenAiFunctionTool, bv as OpenAiInputImage, bw as OpenAiInputMessage, bu as OpenAiInputText, bB as OpenAiOutputMessage, bz as OpenAiOutputTextPart, a4 as OpenAiReasoningBlock, ar as OpenAiReasoningDeltaChunk, af as OpenAiReasoningEffort, bC as OpenAiReasoningOutputItem, ag as OpenAiReasoningSummary, as as OpenAiReasoningSummaryDeltaChunk, a3 as OpenAiReasoningSummaryText, bA as OpenAiRefusalPart, bD as OpenAiResponsesOutputItem, bE as OpenAiResponsesReasoningParam, O as OpenAiResponsesRequest, bd as PayloadByStage, az as PrepareRequestInput, t as PreparedRequest, u as ProviderCredential, D as ProviderCredentialKind, F as ProviderEndpoints, s as ProviderRequestMutator, at as ProviderRetryChunk, P as ProviderSessionResolver, a8 as ReasoningVisibility, r as ResolvedProviderSession, R as RunTurnDeps, bs as RuntimeManagerOptions, bc as Stage, S as SystemInput, h as TextBlock, b8 as ToolDefinition, aG as ToolExecutionContext, b7 as ToolGenerator, ax as ToolOutputEnvelope, b6 as ToolOutputValue, q as ToolResult, p as ToolResultBlock, aw as ToolResultChunk, a0 as ToolResultContent, $ as ToolResultContentBlock, av as ToolResultMeta, b4 as ToolRuntime, aJ as ToolRuntimeCompletedEvent, b0 as ToolRuntimeDispatchDecision, aL as ToolRuntimeEvent, b2 as ToolRuntimeEventHandler, aI as ToolRuntimeOutputChunkEvent, aK as ToolRuntimeRejectedEvent, aH as ToolRuntimeStartedEvent, b1 as ToolRuntimeToolCallHandler, al as ToolSchema, o as ToolUseBlock, ao as ToolUseDeltaChunk, ba as TransformableStage, bf as Transformer, bh as TransformerExtensionRegistration, e as TurnInput, T as TurnResult, ay as TurnResultStatus, f as TurnState, am as Usage } from '../types-Bb2eVtsy.js';
-
-declare class OperationAbortedError extends Error {
-    readonly code = "ABORT_ERR";
-    constructor(message?: string);
-}
-declare function toAbortError(reason: unknown): Error;
-declare function isAbortError(error: unknown): boolean;
-declare function throwIfAborted(signal?: AbortSignal): void;
-declare function addAbortListener(signal: AbortSignal | undefined, onAbort: () => void): () => void;
-
-declare function mapAutoReasoningEffortToBudgetTokens(effort: AutoReasoningEffort): number;
-declare function resolveAnthropicThinkingConfig(reasoning: ReasoningConfig | undefined): AnthropicThinkingConfig | undefined;
-declare function resolveOpenAiReasoningConfig(reasoning: ReasoningConfig | undefined): OpenAiReasoningConfig | undefined;
-
-export { AnthropicThinkingConfig, AutoReasoningEffort, OpenAiReasoningConfig, OperationAbortedError, ReasoningConfig, addAbortListener, isAbortError, mapAutoReasoningEffortToBudgetTokens, resolveAnthropicThinkingConfig, resolveOpenAiReasoningConfig, throwIfAborted, toAbortError };
+export * from "./abort.ts";
+export * from "./reasoning-config.ts";
+export * from "./turn-failed.ts";
+export * from "./types.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/index.js

@@ -1 +1 @@
-function _0x264e(){var _0x3138b5=['mJeWnJyXCwjosKno','mJC4mwrRthLQBa','mZaXmenTzvHzyG','nJe4mJK1vwnoB0f4','mJqXmNDIBgTvEa','ndjxBLL2Aw8','ntqZmLfXAur1ua','ndeWCg50BeTc','mJy3mZuWnfPdq0f3Eq','ndK3mZKWmgXuBKzVsq','mJyWodu0qwT5AgDS'];_0x264e=function(){return _0x3138b5;};return _0x264e();}(function(_0x2a77fe,_0x47a4cc){var _0x50f079={_0x1a445d:0x234,_0x40af55:0x235,_0x40694e:0x232,_0x56e4a4:0x232,_0xa01571:0x269,_0x49c24f:0x238,_0x63f061:0x23a,_0x504c1f:0x22c,_0x22d039:0x261,_0x31ce07:0x261,_0x405bbc:0x262,_0x4e1be2:0x264,_0x5230fb:0x25f,_0x4a18be:0x265,_0x2083fa:0x237,_0x593892:0x239,_0x520aa8:0x229,_0x459846:0x268,_0x1861a0:0x262,_0x2b3812:0x26a},_0x3d2e8e={_0x54db7d:0x38a};function _0x31fa2e(_0x4b9d4c,_0x576257,_0x4767d8,_0xedaa17){return _0x1649(_0x4b9d4c- -_0x3d2e8e._0x54db7d,_0x4767d8);}function _0x4a74b0(_0xdbe7c0,_0x7b797,_0x3d5c21,_0x2c10f3){return _0x1649(_0xdbe7c0- -0x3bc,_0x2c10f3);}var _0x1256d8=_0x2a77fe();while(!![]){try{var _0x93900d=-parseInt(_0x31fa2e(-0x237,-0x236,-_0x50f079._0x1a445d,-_0x50f079._0x40af55))/0x1+parseInt(_0x31fa2e(-_0x50f079._0x40694e,-_0x50f079._0x56e4a4,-0x234,-0x230))/0x2*(parseInt(_0x4a74b0(-0x267,-0x268,-_0x50f079._0xa01571,-0x261))/0x3)+-parseInt(_0x31fa2e(-_0x50f079._0x49c24f,-_0x50f079._0x63f061,-0x236,-0x235))/0x4+parseInt(_0x31fa2e(-0x233,-0x230,-0x233,-0x231))/0x5*(parseInt(_0x31fa2e(-0x231,-0x231,-0x237,-_0x50f079._0x504c1f))/0x6)+parseInt(_0x4a74b0(-0x266,-_0x50f079._0x22d039,-_0x50f079._0x31ce07,-0x267))/0x7*(-parseInt(_0x4a74b0(-_0x50f079._0x405bbc,-_0x50f079._0x4e1be2,-_0x50f079._0x5230fb,-_0x50f079._0x4a18be))/0x8)+-parseInt(_0x31fa2e(-0x239,-_0x50f079._0x2083fa,-_0x50f079._0x63f061,-_0x50f079._0x593892))/0x9+-parseInt(_0x31fa2e(-0x22f,-_0x50f079._0x520aa8,-0x22a,-0x22e))/0xa*(-parseInt(_0x4a74b0(-_0x50f079._0x459846,-_0x50f079._0x405bbc,-_0x50f079._0x1861a0,-_0x50f079._0x2b3812))/0xb);if(_0x93900d===_0x47a4cc)break;else _0x1256d8['push'](_0x1256d8['shift']());}catch(_0x39b93b){_0x1256d8['push'](_0x1256d8['shift']());}}}(_0x264e,0xa4e53));import{mapAutoReasoningEffortToBudgetTokens,resolveAnthropicThinkingConfig,resolveOpenAiReasoningConfig}from'../chunk-NYZR4XKO.js';import{OperationAbortedError,addAbortListener,isAbortError,throwIfAborted,toAbortError}from'../chunk-X7VAACWY.js';function _0x1649(_0x5bf8da,_0x3218c3){_0x5bf8da=_0x5bf8da-0x151;var _0x264ec0=_0x264e();var _0x164986=_0x264ec0[_0x5bf8da];if(_0x1649['MNGuWw']===undefined){var _0x42a9ab=function(_0x6d27e7){var _0x18c137='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var _0x3cf9e9='',_0x267b37='';for(var _0x5725f8=0x0,_0x3cc6a3,_0x4e3dc9,_0x25620e=0x0;_0x4e3dc9=_0x6d27e7['charAt'](_0x25620e++);~_0x4e3dc9&&(_0x3cc6a3=_0x5725f8%0x4?_0x3cc6a3*0x40+_0x4e3dc9:_0x4e3dc9,_0x5725f8++%0x4)?_0x3cf9e9+=String['fromCharCode'](0xff&_0x3cc6a3>>(-0x2*_0x5725f8&0x6)):0x0){_0x4e3dc9=_0x18c137['indexOf'](_0x4e3dc9);}for(var _0x25341a=0x0,_0x22e119=_0x3cf9e9['length'];_0x25341a<_0x22e119;_0x25341a++){_0x267b37+='%'+('00'+_0x3cf9e9['charCodeAt'](_0x25341a)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0x267b37);};_0x1649['xoDQDz']=_0x42a9ab,_0x1649['RFJouA']={},_0x1649['MNGuWw']=!![];}var _0x1d0671=_0x264ec0[0x0],_0x1c420e=_0x5bf8da+_0x1d0671,_0x468a58=_0x1649['RFJouA'][_0x1c420e];return!_0x468a58?(_0x164986=_0x1649['xoDQDz'](_0x164986),_0x1649['RFJouA'][_0x1c420e]=_0x164986):_0x164986=_0x468a58,_0x164986;}export{OperationAbortedError,addAbortListener,isAbortError,mapAutoReasoningEffortToBudgetTokens,resolveAnthropicThinkingConfig,resolveOpenAiReasoningConfig,throwIfAborted,toAbortError};
+(function(_0x2cd82a,_0x454dea){var _0x442099={_0x30b1cf:0x2f8,_0x4a1ed8:0x2fc,_0x1a2acb:0x2fa,_0x54f30a:0x248,_0x351893:0x248,_0x5de95b:0x245,_0x152bb3:0x243,_0x2e653:0x23f,_0x547ca7:0x246,_0x2e4a14:0x24a,_0x51fd05:0x247,_0x81594a:0x2f7,_0x582f03:0x2fb,_0x289fe3:0x300,_0x5504cb:0x249,_0x13f5ee:0x303},_0x5e8892={_0x446dbf:0x181},_0x5613d3=_0x2cd82a();function _0x195084(_0x48f541,_0x59df2a,_0x21bb1b,_0x2d2b4d){return _0x2f7b(_0x59df2a-0xcc,_0x48f541);}function _0x1e9e03(_0x152a4c,_0x2e1266,_0x1c116a,_0x180d1e){return _0x2f7b(_0x180d1e-_0x5e8892._0x446dbf,_0x1c116a);}while(!![]){try{var _0x5c52bb=parseInt(_0x1e9e03(_0x442099._0x30b1cf,0x2ff,0x2f6,0x2fa))/0x1+parseInt(_0x1e9e03(_0x442099._0x4a1ed8,0x2f9,_0x442099._0x1a2acb,0x2fc))/0x2*(parseInt(_0x195084(_0x442099._0x54f30a,_0x442099._0x351893,0x24d,_0x442099._0x5de95b))/0x3)+parseInt(_0x1e9e03(_0x442099._0x1a2acb,0x2f7,0x2f6,0x2f8))/0x4*(-parseInt(_0x195084(0x248,0x244,_0x442099._0x152bb3,_0x442099._0x2e653))/0x5)+-parseInt(_0x195084(0x247,_0x442099._0x547ca7,_0x442099._0x2e4a14,_0x442099._0x51fd05))/0x6*(parseInt(_0x1e9e03(0x2f5,0x2f9,0x2f3,_0x442099._0x81594a))/0x7)+parseInt(_0x1e9e03(0x2fe,_0x442099._0x582f03,0x305,_0x442099._0x289fe3))/0x8+-parseInt(_0x195084(0x24d,0x249,0x24e,_0x442099._0x5504cb))/0x9+-parseInt(_0x1e9e03(0x301,_0x442099._0x13f5ee,0x2fd,0x2ff))/0xa;if(_0x5c52bb===_0x454dea)break;else _0x5613d3['push'](_0x5613d3['shift']());}catch(_0x5a27b0){_0x5613d3['push'](_0x5613d3['shift']());}}}(_0x3adc,0x6237c));import{mapAutoReasoningEffortToBudgetTokens,resolveAnthropicThinkingConfig,resolveOpenAiReasoningConfig}from'../chunk-NYZR4XKO.js';function _0x2f7b(_0x2bba3a,_0x50aedd){_0x2bba3a=_0x2bba3a-0x176;var _0x3adc84=_0x3adc();var _0x2f7b23=_0x3adc84[_0x2bba3a];if(_0x2f7b['ePFOAF']===undefined){var _0x371c37=function(_0xbff65b){var _0x59219f='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var _0x200a0a='',_0x532180='';for(var _0x3e4b2e=0x0,_0x1d7cac,_0x2a442f,_0x5e6b11=0x0;_0x2a442f=_0xbff65b['charAt'](_0x5e6b11++);~_0x2a442f&&(_0x1d7cac=_0x3e4b2e%0x4?_0x1d7cac*0x40+_0x2a442f:_0x2a442f,_0x3e4b2e++%0x4)?_0x200a0a+=String['fromCharCode'](0xff&_0x1d7cac>>(-0x2*_0x3e4b2e&0x6)):0x0){_0x2a442f=_0x59219f['indexOf'](_0x2a442f);}for(var _0xbc7e1b=0x0,_0x2738a3=_0x200a0a['length'];_0xbc7e1b<_0x2738a3;_0xbc7e1b++){_0x532180+='%'+('00'+_0x200a0a['charCodeAt'](_0xbc7e1b)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0x532180);};_0x2f7b['UFPXgL']=_0x371c37,_0x2f7b['ramQTw']={},_0x2f7b['ePFOAF']=!![];}var _0x41ccbc=_0x3adc84[0x0],_0x230b79=_0x2bba3a+_0x41ccbc,_0x465971=_0x2f7b['ramQTw'][_0x230b79];return!_0x465971?(_0x2f7b23=_0x2f7b['UFPXgL'](_0x2f7b23),_0x2f7b['ramQTw'][_0x230b79]=_0x2f7b23):_0x2f7b23=_0x465971,_0x2f7b23;}import{TurnFailedError}from'../chunk-FFIZ6TKW.js';import{OperationAbortedError,addAbortListener,isAbortError,throwIfAborted,toAbortError}from'../chunk-X7VAACWY.js';export{OperationAbortedError,TurnFailedError,addAbortListener,isAbortError,mapAutoReasoningEffortToBudgetTokens,resolveAnthropicThinkingConfig,resolveOpenAiReasoningConfig,throwIfAborted,toAbortError};function _0x3adc(){var _0x144d6d=['mJi2mJqXmhbPweDoEq','nJmWody2neP0u2jgAq','nJqWnta3qKvYq2XA','mtiYodyYofDSAKXKvW','nvbPtMLgBG','ntK4mta0qKfHAgPh','nMH1u0nHsa','ndu2CfzdtxvN','mZi0m1jPBxnMzq','ntq1mZyWneXPBMLyBW'];_0x3adc=function(){return _0x144d6d;};return _0x3adc();}

package/dist/shared/reasoning-config.d.ts

@@ -0,0 +1,5 @@
+import type { AnthropicThinkingConfig, AutoReasoningEffort, OpenAiReasoningConfig, ReasoningConfig } from "./types.ts";
+export declare function mapAutoReasoningEffortToBudgetTokens(effort: AutoReasoningEffort): number;
+export declare function resolveAnthropicThinkingConfig(reasoning: ReasoningConfig | undefined): AnthropicThinkingConfig | undefined;
+export declare function resolveOpenAiReasoningConfig(reasoning: ReasoningConfig | undefined): OpenAiReasoningConfig | undefined;
+//# sourceMappingURL=reasoning-config.d.ts.map

package/dist/shared/turn-failed.d.ts

@@ -0,0 +1,6 @@
+import type { TurnState } from "./types.ts";
+export declare class TurnFailedError extends Error {
+    readonly state: TurnState;
+    constructor(cause: unknown, state: TurnState);
+}
+//# sourceMappingURL=turn-failed.d.ts.map