@nuvin/agent-core 0.0.0-rc.2 → 0.0.0-rc.20

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 { D as AutoReasoningEffort, u as ReasoningConfig, F as AnthropicThinkingConfig, G as OpenAiReasoningConfig } from '../types-QPBW5jHO.js';
-export { aJ as AgentAssistantChunkEvent, aI as AgentAssistantMessageEvent, bd as AgentDefinition, bc as AgentDefinitionFactoryContext, aU as AgentEvent, ay as AgentEventContext, aY as AgentEventHandler, aR as AgentFinalMessageEvent, a as AgentInput, aT as AgentLifecycleEvent, aG as AgentModelRequestEvent, aH as AgentModelResponseEvent, A as AgentOptions, aN as AgentReasoningChunkEvent, aM as AgentReasoningMessageEvent, b as AgentSendOptions, aO as AgentToolCallEvent, aP as AgentToolResultEvent, aQ as AgentToolResultMessageEvent, aL as AgentToolUseChunkEvent, aK as AgentToolUseMessageEvent, aS as AgentTurnCompleteEvent, aF as AgentUserMessageEvent, ab as AnthropicAdaptiveThinkingConfig, a5 as AnthropicAssistantContentBlock, ac as AnthropicDisabledThinkingConfig, aa as AnthropicEnabledThinkingConfig, a0 as AnthropicRedactedThinkingBlock, a4 as AnthropicRedactedThinkingWireBlock, ao as AnthropicSignatureDeltaChunk, $ as AnthropicThinkingBlock, an as AnthropicThinkingDeltaChunk, a8 as AnthropicThinkingDisplay, a9 as AnthropicThinkingEffort, a3 as AnthropicThinkingWireBlock, bb as AnyExtensionRegistration, b2 as AnyToolDefinition, ag as AssistantContentBlock, a7 as AutoReasoningConfig, B as BaseChatModelOptions, ax as ChatModel, j as ChatRequest, l as ChatResponse, v as ChatResponseChunk, h as CompileRequestInput, f as ContentBlock, al as ContentDeltaChunk, C as ContentInput, bl as CreateManagedRunInput, t as EngineChatModel, b5 as ExtensionContext, ba as ExtensionRegistration, E as ExtensionRegistry, ai as IdentifiedMessage, Y as ImageBlock, X as ImageMediaType, a_ as InferJsonSchema, H as JsonObject, J as JsonPrimitive, W as JsonSchema, U as JsonSchemaArray, Q as JsonSchemaBoolean, N as JsonSchemaNumber, V as JsonSchemaObject, L as JsonSchemaString, K as JsonSchemaType, I as JsonValue, bg as ManagedAgentRun, bh as ManagedAgentRunHandle, bf as ManagedRunError, bi as ManagedRunEvent, bj as ManagedRunEventHandler, be as ManagedRunStatus, M as Message, g as MessageInput, af as MessageProviderState, ah as MessageRole, w as ModelExecutionOptions, x as ModelInfo, ar as ModelLimits, i as ModelRequest, k as ModelResponse, b7 as Observer, b9 as ObserverExtensionRegistration, bp as OpenAiFunctionCall, bq as OpenAiFunctionCallOutput, bx as OpenAiFunctionTool, bn as OpenAiInputImage, bo as OpenAiInputMessage, bm as OpenAiInputText, bt as OpenAiOutputMessage, br as OpenAiOutputTextPart, a2 as OpenAiReasoningBlock, ap as OpenAiReasoningDeltaChunk, ad as OpenAiReasoningEffort, bu as OpenAiReasoningOutputItem, ae as OpenAiReasoningSummary, aq as OpenAiReasoningSummaryDeltaChunk, a1 as OpenAiReasoningSummaryText, bs as OpenAiRefusalPart, bv as OpenAiResponsesOutputItem, bw as OpenAiResponsesReasoningParam, O as OpenAiResponsesRequest, b4 as PayloadByStage, aw as PrepareRequestInput, r as PreparedRequest, s as ProviderCredential, y as ProviderCredentialKind, z as ProviderEndpoints, q as ProviderRequestMutator, P as ProviderSessionResolver, a6 as ReasoningVisibility, p as ResolvedProviderSession, R as RunTurnDeps, bk as RuntimeManagerOptions, b3 as Stage, S as SystemInput, e as TextBlock, b1 as ToolDefinition, az as ToolExecutionContext, b0 as ToolGenerator, au as ToolOutputEnvelope, a$ as ToolOutputValue, o as ToolResult, n as ToolResultBlock, at as ToolResultChunk, _ as ToolResultContent, Z as ToolResultContentBlock, as as ToolResultMeta, aZ as ToolRuntime, aC as ToolRuntimeCompletedEvent, aV as ToolRuntimeDispatchDecision, aE as ToolRuntimeEvent, aX as ToolRuntimeEventHandler, aB as ToolRuntimeOutputChunkEvent, aD as ToolRuntimeRejectedEvent, aA as ToolRuntimeStartedEvent, aW as ToolRuntimeToolCallHandler, aj as ToolSchema, m as ToolUseBlock, am as ToolUseDeltaChunk, b6 as Transformer, b8 as TransformerExtensionRegistration, c as TurnInput, T as TurnResult, av as TurnResultStatus, d as TurnState, ak as Usage } from '../types-QPBW5jHO.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(_0x45bda9,_0x34f9be){var _0x286c51={_0x24b4cb:0xd8,_0x2de504:0xd4,_0xe75a21:0xd3,_0x541c02:0xd8,_0x56a0df:0xde,_0xb47cd5:0xd9,_0x10ec4e:0xd7,_0x31b4ac:0xd5,_0x583cd7:0x21d,_0x5d044a:0x221,_0x5c9d09:0x21a,_0x10e2a2:0x214,_0x184b11:0x219,_0x3a3cf1:0x215,_0x1ba193:0x222,_0x779ce3:0x21f,_0x5ce91f:0xd8,_0x412100:0xce},_0x44c47e={_0x4e7008:0x3c},_0x40edbc=_0x45bda9();function _0x241699(_0x48667c,_0xba3c4e,_0x5f5951,_0x2415b7){return _0x4b68(_0x2415b7- -0x2b4,_0xba3c4e);}function _0x2632bf(_0x438478,_0x481dd3,_0x116e4b,_0xfd1a1c){return _0x4b68(_0xfd1a1c-_0x44c47e._0x4e7008,_0x438478);}while(!![]){try{var _0x382f92=parseInt(_0x241699(-_0x286c51._0x24b4cb,-_0x286c51._0x2de504,-_0x286c51._0xe75a21,-0xd7))/0x1*(-parseInt(_0x241699(-0xd5,-_0x286c51._0x541c02,-_0x286c51._0x56a0df,-_0x286c51._0xb47cd5))/0x2)+-parseInt(_0x241699(-_0x286c51._0x10ec4e,-0xce,-0xce,-0xd3))/0x3*(-parseInt(_0x241699(-_0x286c51._0x24b4cb,-0xd3,-0xd5,-0xd8))/0x4)+-parseInt(_0x241699(-_0x286c51._0xe75a21,-0xd5,-0xd3,-_0x286c51._0x31b4ac))/0x5*(-parseInt(_0x2632bf(_0x286c51._0x583cd7,0x21c,_0x286c51._0x5d044a,0x21e))/0x6)+-parseInt(_0x2632bf(0x21c,0x217,0x21b,_0x286c51._0x5c9d09))/0x7+parseInt(_0x2632bf(_0x286c51._0x10e2a2,_0x286c51._0x184b11,_0x286c51._0x3a3cf1,0x216))/0x8+-parseInt(_0x2632bf(0x21a,_0x286c51._0x1ba193,0x222,_0x286c51._0x779ce3))/0x9+parseInt(_0x241699(-0xdf,-_0x286c51._0x56a0df,-_0x286c51._0x5ce91f,-0xdb))/0xa*(-parseInt(_0x241699(-0xd6,-0xd9,-_0x286c51._0x412100,-0xd4))/0xb);if(_0x382f92===_0x34f9be)break;else _0x40edbc['push'](_0x40edbc['shift']());}catch(_0xf39296){_0x40edbc['push'](_0x40edbc['shift']());}}}(_0x1002,0x6e122));import{mapAutoReasoningEffortToBudgetTokens,resolveAnthropicThinkingConfig,resolveOpenAiReasoningConfig}from'../chunk-NYZR4XKO.js';import{OperationAbortedError,addAbortListener,isAbortError,throwIfAborted,toAbortError}from'../chunk-X7VAACWY.js';function _0x4b68(_0x492945,_0x3865c9){_0x492945=_0x492945-0x1d9;var _0x1002db=_0x1002();var _0x4b68df=_0x1002db[_0x492945];if(_0x4b68['kZcJsm']===undefined){var _0x353924=function(_0x770c2){var _0x1beb2a='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var _0x252ee5='',_0x14ef2e='';for(var _0x580345=0x0,_0x36ac06,_0x2e9d2c,_0x4a9f24=0x0;_0x2e9d2c=_0x770c2['charAt'](_0x4a9f24++);~_0x2e9d2c&&(_0x36ac06=_0x580345%0x4?_0x36ac06*0x40+_0x2e9d2c:_0x2e9d2c,_0x580345++%0x4)?_0x252ee5+=String['fromCharCode'](0xff&_0x36ac06>>(-0x2*_0x580345&0x6)):0x0){_0x2e9d2c=_0x1beb2a['indexOf'](_0x2e9d2c);}for(var _0x204eff=0x0,_0x4bc1f9=_0x252ee5['length'];_0x204eff<_0x4bc1f9;_0x204eff++){_0x14ef2e+='%'+('00'+_0x252ee5['charCodeAt'](_0x204eff)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0x14ef2e);};_0x4b68['dbxWPb']=_0x353924,_0x4b68['IGHNCb']={},_0x4b68['kZcJsm']=!![];}var _0x3db008=_0x1002db[0x0],_0x4ee899=_0x492945+_0x3db008,_0x2a2e19=_0x4b68['IGHNCb'][_0x4ee899];return!_0x2a2e19?(_0x4b68df=_0x4b68['dbxWPb'](_0x4b68df),_0x4b68['IGHNCb'][_0x4ee899]=_0x4b68df):_0x4b68df=_0x2a2e19,_0x4b68df;}export{OperationAbortedError,addAbortListener,isAbortError,mapAutoReasoningEffortToBudgetTokens,resolveAnthropicThinkingConfig,resolveOpenAiReasoningConfig,throwIfAborted,toAbortError};function _0x1002(){var _0x59995e=['nda3ndG2ne9swufXra','nZC4ndjQCxHMEwG','nhrxBMfJsq','mtnxthvxthi','mtqYmJq3ueXzy1LK','nw1PB0T3AW','mJy0yLzHAw1u','mJi4nZGZmeH3uvjtEa','nZKYndi2B0Pfz2nw','mJyXnZC2n29nAerTwG','nty2odbfC0zSCe0'];_0x1002=function(){return _0x59995e;};return _0x1002();}
+(function(_0xf877df,_0x4fc3ac){var _0x38e873={_0x5e9dfe:0x21f,_0x6a0d0:0x224,_0x1a3cb3:0x221,_0x58ab1b:0x21e,_0x355102:0x3b1,_0x45bc6d:0x3ac,_0x5b0c4d:0x218,_0x4f3dc6:0x3b6,_0x3acc12:0x3bb,_0x59f6f4:0x3bf,_0xd15874:0x3be,_0x504148:0x21a,_0x3ba607:0x225,_0x44991d:0x3b0,_0x23b504:0x3b3,_0x45f2e5:0x3b7,_0x71ecb4:0x3b2,_0x187eb7:0x3b8,_0x5e3b39:0x3b4,_0x3824ff:0x3b7,_0x3d65a1:0x225,_0x5d8a83:0x227,_0x32cb9b:0x229,_0x5f588b:0x21c,_0x5e725b:0x220},_0x5d22cb={_0x41ac66:0x24c},_0xacf212={_0x16a3f9:0xb6},_0x407e93=_0xf877df();function _0x46e963(_0x1da81c,_0x2e59b9,_0x3de7b3,_0x56a95a){return _0x1e59(_0x3de7b3-_0xacf212._0x16a3f9,_0x2e59b9);}function _0xf680ec(_0x35a03a,_0x3a5d6b,_0x2aad3c,_0x252591){return _0x1e59(_0x3a5d6b-_0x5d22cb._0x41ac66,_0x35a03a);}while(!![]){try{var _0x2b101c=-parseInt(_0x46e963(0x221,_0x38e873._0x5e9dfe,_0x38e873._0x6a0d0,_0x38e873._0x6a0d0))/0x1*(parseInt(_0x46e963(0x21f,0x225,_0x38e873._0x1a3cb3,_0x38e873._0x58ab1b))/0x2)+parseInt(_0xf680ec(_0x38e873._0x355102,0x3b0,_0x38e873._0x45bc6d,0x3ac))/0x3*(-parseInt(_0x46e963(_0x38e873._0x5b0c4d,0x21e,0x21b,0x21d))/0x4)+-parseInt(_0xf680ec(0x3b1,0x3b4,_0x38e873._0x4f3dc6,0x3ba))/0x5*(-parseInt(_0xf680ec(0x3bc,_0x38e873._0x3acc12,_0x38e873._0x59f6f4,_0x38e873._0xd15874))/0x6)+-parseInt(_0x46e963(_0x38e873._0x504148,_0x38e873._0x3ba607,_0x38e873._0x5e9dfe,_0x38e873._0x5b0c4d))/0x7*(parseInt(_0xf680ec(0x3a8,0x3af,0x3a9,_0x38e873._0x44991d))/0x8)+-parseInt(_0xf680ec(0x3bf,0x3b8,0x3bd,_0x38e873._0x23b504))/0x9*(parseInt(_0xf680ec(_0x38e873._0x45f2e5,_0x38e873._0x71ecb4,_0x38e873._0x23b504,_0x38e873._0x187eb7))/0xa)+parseInt(_0xf680ec(0x3b8,0x3b3,_0x38e873._0x5e3b39,_0x38e873._0x3824ff))/0xb*(parseInt(_0x46e963(_0x38e873._0x3d65a1,_0x38e873._0x5d8a83,0x223,_0x38e873._0x32cb9b))/0xc)+parseInt(_0x46e963(_0x38e873._0x5f588b,_0x38e873._0x5e725b,0x220,0x21b))/0xd;if(_0x2b101c===_0x4fc3ac)break;else _0x407e93['push'](_0x407e93['shift']());}catch(_0x142c97){_0x407e93['push'](_0x407e93['shift']());}}}(_0x2131,0x61980));import{mapAutoReasoningEffortToBudgetTokens,resolveAnthropicThinkingConfig,resolveOpenAiReasoningConfig}from'../chunk-NYZR4XKO.js';import{TurnFailedError}from'../chunk-FFIZ6TKW.js';import{OperationAbortedError,addAbortListener,isAbortError,throwIfAborted,toAbortError}from'../chunk-X7VAACWY.js';function _0x1e59(_0x28eb47,_0x2847d8){_0x28eb47=_0x28eb47-0x163;var _0x21314f=_0x2131();var _0x1e59c5=_0x21314f[_0x28eb47];if(_0x1e59['ewDEDz']===undefined){var _0x11411f=function(_0x26799c){var _0x349163='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var _0x1fc4b7='',_0x211b7d='';for(var _0x3b16b9=0x0,_0x419d97,_0x1dbed7,_0x231b9b=0x0;_0x1dbed7=_0x26799c['charAt'](_0x231b9b++);~_0x1dbed7&&(_0x419d97=_0x3b16b9%0x4?_0x419d97*0x40+_0x1dbed7:_0x1dbed7,_0x3b16b9++%0x4)?_0x1fc4b7+=String['fromCharCode'](0xff&_0x419d97>>(-0x2*_0x3b16b9&0x6)):0x0){_0x1dbed7=_0x349163['indexOf'](_0x1dbed7);}for(var _0x339d49=0x0,_0x3c6d24=_0x1fc4b7['length'];_0x339d49<_0x3c6d24;_0x339d49++){_0x211b7d+='%'+('00'+_0x1fc4b7['charCodeAt'](_0x339d49)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0x211b7d);};_0x1e59['TdVHDL']=_0x11411f,_0x1e59['ThSVxb']={},_0x1e59['ewDEDz']=!![];}var _0x15ff3c=_0x21314f[0x0],_0x5c54d8=_0x28eb47+_0x15ff3c,_0x4ce78c=_0x1e59['ThSVxb'][_0x5c54d8];return!_0x4ce78c?(_0x1e59c5=_0x1e59['TdVHDL'](_0x1e59c5),_0x1e59['ThSVxb'][_0x5c54d8]=_0x1e59c5):_0x1e59c5=_0x4ce78c,_0x1e59c5;}function _0x2131(){var _0x3eefbf=['mJqWnJK2ogXczgHqCa','m0H0sKzSzG','mJK1mdG5mMzYBgDXsW','mJbhCMrZCMG','nZi0mtmWrK9TreLe','mtuWmZaYnvznrKTOAG','n3zuswX5tq','mtK4ntu2mtvwB2rdv2W','odzjCMjoAeq','otq5mJKZDNvZB25V','mtjYtvfZC3K','nty4nNzuqufkDW','nMv2CNjSqq'];_0x2131=function(){return _0x3eefbf;};return _0x2131();}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