@nuvin/agent-core 0.0.0-rc.8 → 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-mpqTRf_e.js';
-export { aQ as AgentAssistantChunkEvent, aP as AgentAssistantMessageEvent, bk as AgentDefinition, bj 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, bi 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, bs as CreateManagedRunInput, au as DoneChunk, E as EngineChatModel, bc as ExtensionContext, bh as ExtensionRegistration, 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, bn as ManagedAgentRun, bo as ManagedAgentRunHandle, bm as ManagedRunError, bp as ManagedRunEvent, bq as ManagedRunEventHandler, bl 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, be as Observer, bg as ObserverExtensionRegistration, bw as OpenAiFunctionCall, bx as OpenAiFunctionCallOutput, bE as OpenAiFunctionTool, bu as OpenAiInputImage, bv as OpenAiInputMessage, bt as OpenAiInputText, bA as OpenAiOutputMessage, by as OpenAiOutputTextPart, a4 as OpenAiReasoningBlock, ar as OpenAiReasoningDeltaChunk, af as OpenAiReasoningEffort, bB as OpenAiReasoningOutputItem, ag as OpenAiReasoningSummary, as as OpenAiReasoningSummaryDeltaChunk, a3 as OpenAiReasoningSummaryText, bz as OpenAiRefusalPart, bC as OpenAiResponsesOutputItem, bD as OpenAiResponsesReasoningParam, O as OpenAiResponsesRequest, bb 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, br as RuntimeManagerOptions, ba 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, bd as Transformer, bf as TransformerExtensionRegistration, e as TurnInput, T as TurnResult, ay as TurnResultStatus, f as TurnState, am as Usage } from '../types-mpqTRf_e.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(_0x375263,_0x3f0f83){var _0x2ad27a={_0x3cdd86:0x51b,_0x3ffeb1:0x516,_0x2f5f11:0x59b,_0x11bc34:0x59a,_0x114c22:0x51a,_0x467f97:0x595,_0xc6c999:0x595,_0x3ff8d0:0x598,_0x3fa1ab:0x513,_0xee690e:0x515,_0x4dcbd3:0x518,_0x55808d:0x517,_0x497ba7:0x592,_0x1ba135:0x599,_0x148e58:0x51d,_0x559ff9:0x51d,_0x256e7d:0x51c,_0x197240:0x598,_0x10f7df:0x50f,_0x2e76c2:0x511},_0x3f0cfe={_0xe078f3:0x3c8},_0x4de389=_0x375263();function _0x29f722(_0x2548e9,_0x5d26d3,_0x1887f4,_0x35ce88){return _0x5303(_0x5d26d3-_0x3f0cfe._0xe078f3,_0x1887f4);}function _0x11b6f0(_0x140e4b,_0x492af0,_0xf44c6d,_0x21d9fc){return _0x5303(_0x21d9fc-0x347,_0x140e4b);}while(!![]){try{var _0xb9ac3a=parseInt(_0x11b6f0(0x514,_0x2ad27a._0x3cdd86,0x515,_0x2ad27a._0x3ffeb1))/0x1*(-parseInt(_0x29f722(_0x2ad27a._0x2f5f11,_0x2ad27a._0x11bc34,0x5a0,0x59b))/0x2)+parseInt(_0x11b6f0(0x518,_0x2ad27a._0x114c22,0x51e,0x51a))/0x3*(parseInt(_0x29f722(_0x2ad27a._0x467f97,_0x2ad27a._0xc6c999,0x595,_0x2ad27a._0x3ff8d0))/0x4)+parseInt(_0x11b6f0(0x51b,0x511,_0x2ad27a._0x3fa1ab,_0x2ad27a._0xee690e))/0x5+-parseInt(_0x11b6f0(_0x2ad27a._0x4dcbd3,_0x2ad27a._0x55808d,0x50f,0x512))/0x6*(-parseInt(_0x29f722(0x59c,0x598,_0x2ad27a._0x497ba7,_0x2ad27a._0x1ba135))/0x7)+parseInt(_0x11b6f0(_0x2ad27a._0x148e58,0x51a,_0x2ad27a._0x559ff9,_0x2ad27a._0x256e7d))/0x8*(parseInt(_0x29f722(_0x2ad27a._0x1ba135,_0x2ad27a._0x1ba135,_0x2ad27a._0x197240,0x59c))/0x9)+parseInt(_0x11b6f0(_0x2ad27a._0x10f7df,_0x2ad27a._0x3ffeb1,_0x2ad27a._0x2e76c2,0x513))/0xa+-parseInt(_0x29f722(0x59e,0x59c,0x597,0x59c))/0xb;if(_0xb9ac3a===_0x3f0f83)break;else _0x4de389['push'](_0x4de389['shift']());}catch(_0x450351){_0x4de389['push'](_0x4de389['shift']());}}}(_0x30db,0x1b012));function _0x5303(_0x338e9e,_0xb63432){_0x338e9e=_0x338e9e-0x1cb;var _0x30db97=_0x30db();var _0x530351=_0x30db97[_0x338e9e];if(_0x5303['rLtrOo']===undefined){var _0x2f42d2=function(_0xbbe0b){var _0xaebdad='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var _0x1223f2='',_0x19b08d='';for(var _0x333a8d=0x0,_0x5689bd,_0x498a6b,_0x47fad9=0x0;_0x498a6b=_0xbbe0b['charAt'](_0x47fad9++);~_0x498a6b&&(_0x5689bd=_0x333a8d%0x4?_0x5689bd*0x40+_0x498a6b:_0x498a6b,_0x333a8d++%0x4)?_0x1223f2+=String['fromCharCode'](0xff&_0x5689bd>>(-0x2*_0x333a8d&0x6)):0x0){_0x498a6b=_0xaebdad['indexOf'](_0x498a6b);}for(var _0x5732ec=0x0,_0x5080e4=_0x1223f2['length'];_0x5732ec<_0x5080e4;_0x5732ec++){_0x19b08d+='%'+('00'+_0x1223f2['charCodeAt'](_0x5732ec)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0x19b08d);};_0x5303['IrXMPL']=_0x2f42d2,_0x5303['BoBhBh']={},_0x5303['rLtrOo']=!![];}var _0x5e4ead=_0x30db97[0x0],_0x14c56b=_0x338e9e+_0x5e4ead,_0x556931=_0x5303['BoBhBh'][_0x14c56b];return!_0x556931?(_0x530351=_0x5303['IrXMPL'](_0x530351),_0x5303['BoBhBh'][_0x14c56b]=_0x530351):_0x530351=_0x556931,_0x530351;}function _0x30db(){var _0x23686d=['ndm5otCZnNDSsfPvrG','mJrUuKncu1y','nNf6qxL0BG','mtGZmZiWmfvTChrgtq','nfvqwe9zCq','otaXmJCWAMXICMTR','ntLUrwTrEKq','odm5nJqZyKLxyvbU','mZm4mtiXzeLOEu9P','mZq2mhbtzgLTrG','ndKYnZHbAgDQCMe'];_0x30db=function(){return _0x23686d;};return _0x30db();}import{mapAutoReasoningEffortToBudgetTokens,resolveAnthropicThinkingConfig,resolveOpenAiReasoningConfig}from'../chunk-NYZR4XKO.js';import{OperationAbortedError,addAbortListener,isAbortError,throwIfAborted,toAbortError}from'../chunk-X7VAACWY.js';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