@nuvin/agent-core 0.0.0-rc.9 → 0.1.0-rc.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(_0x359ba2,_0x1bfa38){var _0x383263={_0x195de7:0x190,_0x2b4fd:0x194,_0x25791b:0x47,_0x28d93e:0x3e,_0x2bf6e5:0x44,_0x1e5102:0x49,_0x2531b1:0x18b,_0x474321:0x18d,_0x307bb0:0x18e,_0x48192b:0x189,_0x3d398a:0x46,_0x4c4e0a:0x47},_0x2e99b3={_0x37f282:0x1eb},_0x46e5bc={_0x296ab7:0x15},_0x5a7361=_0x359ba2();function _0x16e9b5(_0x2dbfe0,_0x7fdbda,_0x29a43c,_0x281f21){return _0x12d9(_0x2dbfe0- -_0x46e5bc._0x296ab7,_0x29a43c);}function _0x547459(_0x16c061,_0x45800e,_0x38192f,_0x5acf68){return _0x12d9(_0x5acf68- -_0x2e99b3._0x37f282,_0x45800e);}while(!![]){try{var _0x458e8e=-parseInt(_0x16e9b5(_0x383263._0x195de7,0x190,_0x383263._0x2b4fd,0x18c))/0x1+-parseInt(_0x547459(-0x40,-_0x383263._0x25791b,-_0x383263._0x28d93e,-0x43))/0x2*(-parseInt(_0x547459(-_0x383263._0x2bf6e5,-0x49,-0x4d,-_0x383263._0x1e5102))/0x3)+parseInt(_0x16e9b5(_0x383263._0x2531b1,_0x383263._0x474321,0x18e,0x188))/0x4*(-parseInt(_0x16e9b5(_0x383263._0x307bb0,0x18a,0x191,0x18e))/0x5)+parseInt(_0x16e9b5(0x18c,0x191,_0x383263._0x48192b,_0x383263._0x48192b))/0x6+parseInt(_0x547459(-0x46,-0x45,-0x49,-0x45))/0x7+parseInt(_0x547459(-_0x383263._0x3d398a,-_0x383263._0x4c4e0a,-0x45,-0x47))/0x8+-parseInt(_0x547459(-0x44,-0x45,-0x48,-_0x383263._0x2bf6e5))/0x9;if(_0x458e8e===_0x1bfa38)break;else _0x5a7361['push'](_0x5a7361['shift']());}catch(_0x30d074){_0x5a7361['push'](_0x5a7361['shift']());}}}(_0x7d3c,0x3e099));import{mapAutoReasoningEffortToBudgetTokens,resolveAnthropicThinkingConfig,resolveOpenAiReasoningConfig}from'../chunk-NYZR4XKO.js';function _0x7d3c(){var _0x229a8b=['mJyYnZe4r0vcu1nV','mtGYntmYme9YANLHAa','mZqYmtu4nhHIz3f4zq','mtK2mdm4u3jztMDU','nJy4y0fMrgDg','mJa5mZiWog1zugPhvG','ouj0u1DzDW','mte3mdvLEvfyt1C','mZa3nda4oe1dC0H2Ba'];_0x7d3c=function(){return _0x229a8b;};return _0x7d3c();}import{TurnFailedError}from'../chunk-FFIZ6TKW.js';function _0x12d9(_0x3bdc7b,_0x247a58){_0x3bdc7b=_0x3bdc7b-0x1a0;var _0x7d3c55=_0x7d3c();var _0x12d959=_0x7d3c55[_0x3bdc7b];if(_0x12d9['PcldTZ']===undefined){var _0x2c1356=function(_0x411296){var _0x4249c6='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var _0x105669='',_0x170a80='';for(var _0x4b46b1=0x0,_0xb02cb7,_0x506b1b,_0x4826fb=0x0;_0x506b1b=_0x411296['charAt'](_0x4826fb++);~_0x506b1b&&(_0xb02cb7=_0x4b46b1%0x4?_0xb02cb7*0x40+_0x506b1b:_0x506b1b,_0x4b46b1++%0x4)?_0x105669+=String['fromCharCode'](0xff&_0xb02cb7>>(-0x2*_0x4b46b1&0x6)):0x0){_0x506b1b=_0x4249c6['indexOf'](_0x506b1b);}for(var _0x53bd23=0x0,_0x14d96e=_0x105669['length'];_0x53bd23<_0x14d96e;_0x53bd23++){_0x170a80+='%'+('00'+_0x105669['charCodeAt'](_0x53bd23)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0x170a80);};_0x12d9['VKHuYF']=_0x2c1356,_0x12d9['FQDIgu']={},_0x12d9['PcldTZ']=!![];}var _0x568125=_0x7d3c55[0x0],_0x3f6a27=_0x3bdc7b+_0x568125,_0x468091=_0x12d9['FQDIgu'][_0x3f6a27];return!_0x468091?(_0x12d959=_0x12d9['VKHuYF'](_0x12d959),_0x12d9['FQDIgu'][_0x3f6a27]=_0x12d959):_0x12d959=_0x468091,_0x12d959;}import{OperationAbortedError,addAbortListener,isAbortError,throwIfAborted,toAbortError}from'../chunk-X7VAACWY.js';export{OperationAbortedError,TurnFailedError,addAbortListener,isAbortError,mapAutoReasoningEffortToBudgetTokens,resolveAnthropicThinkingConfig,resolveOpenAiReasoningConfig,throwIfAborted,toAbortError};

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