@nuvin/agent-core 0.0.0-rc.18 → 0.0.0-rc.19

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,60 @@
+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 static readonly sharedResponsesSocketSessions;
+    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;
+    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,22 +1,5 @@
-import { I as AutoReasoningEffort, x as ReasoningConfig, K as AnthropicThinkingConfig, L as OpenAiReasoningConfig, h as TurnState } from '../types-11Znykt2.js';
-export { aS as AgentAssistantChunkEvent, aR as AgentAssistantMessageEvent, bm as AgentDefinition, bl as AgentDefinitionFactoryContext, A as AgentEvent, aD as AgentEventContext, b5 as AgentEventHandler, a_ as AgentFinalMessageEvent, b as AgentInput, b1 as AgentLifecycleEvent, aP as AgentModelRequestEvent, aQ as AgentModelResponseEvent, a as AgentOptions, b0 as AgentProviderRetryEvent, aW as AgentReasoningChunkEvent, aV as AgentReasoningMessageEvent, c as AgentSendOptions, aX as AgentToolCallEvent, aY as AgentToolResultEvent, aZ as AgentToolResultMessageEvent, aU as AgentToolUseChunkEvent, aT as AgentToolUseMessageEvent, a$ as AgentTurnCompleteEvent, aO as AgentUserMessageEvent, af as AnthropicAdaptiveThinkingConfig, a9 as AnthropicAssistantContentBlock, ag as AnthropicDisabledThinkingConfig, ae as AnthropicEnabledThinkingConfig, a4 as AnthropicRedactedThinkingBlock, a8 as AnthropicRedactedThinkingWireBlock, as as AnthropicSignatureDeltaChunk, a3 as AnthropicThinkingBlock, ar as AnthropicThinkingDeltaChunk, ac as AnthropicThinkingDisplay, ad as AnthropicThinkingEffort, a7 as AnthropicThinkingWireBlock, bk as AnyExtensionRegistration, bb as AnyToolDefinition, aG as AskUserAnswers, aE as AskUserOption, aF as AskUserQuestion, aH as AskUserQuestionRequest, ak as AssistantContentBlock, ab as AutoReasoningConfig, B as BaseChatModelOptions, aC as ChatModel, C as ChatRequest, p as ChatResponse, y as ChatResponseChunk, m as CompileRequestInput, i as ContentBlock, ap as ContentDeltaChunk, k as ContentInput, bu as CreateManagedRunInput, aw as DoneChunk, E as EngineChatModel, bg as ExtensionContext, e as ExtensionRegistry, am as IdentifiedMessage, a0 as ImageBlock, $ as ImageMediaType, b7 as InferJsonSchema, Q as JsonObject, N as JsonPrimitive, _ as JsonSchema, Z as JsonSchemaArray, Y as JsonSchemaBoolean, X as JsonSchemaNumber, J as JsonSchemaObject, W as JsonSchemaString, V as JsonSchemaType, U as JsonValue, bp as ManagedAgentRun, bq as ManagedAgentRunHandle, bo as ManagedRunError, br as ManagedRunEvent, bs as ManagedRunEventHandler, bn as ManagedRunStatus, M as Message, l as MessageInput, aj as MessageProviderState, al as MessageRole, z as ModelExecutionOptions, D as ModelInfo, F as ModelLimits, n as ModelRequest, o as ModelResponse, bi as Observer, bj as ObserverExtensionRegistration, bd as ObserverOnlyStage, by as OpenAiFunctionCall, bz as OpenAiFunctionCallOutput, bG as OpenAiFunctionTool, bw as OpenAiInputImage, bx as OpenAiInputMessage, bv as OpenAiInputText, bC as OpenAiOutputMessage, bA as OpenAiOutputTextPart, a6 as OpenAiReasoningBlock, at as OpenAiReasoningDeltaChunk, ah as OpenAiReasoningEffort, bD as OpenAiReasoningOutputItem, ai as OpenAiReasoningSummary, au as OpenAiReasoningSummaryDeltaChunk, a5 as OpenAiReasoningSummaryText, bB as OpenAiRefusalPart, bE as OpenAiResponsesOutputItem, bF as OpenAiResponsesReasoningParam, O as OpenAiResponsesRequest, ao as OutputFormat, bf as PayloadByStage, aB as PrepareRequestInput, v as PreparedRequest, w as ProviderCredential, G as ProviderCredentialKind, H as ProviderEndpoints, u as ProviderRequestMutator, av as ProviderRetryChunk, P as ProviderSessionResolver, aa as ReasoningVisibility, t as ResolvedProviderSession, R as RunTurnDeps, bt as RuntimeManagerOptions, be as Stage, S as SystemInput, j as TextBlock, ba as ToolDefinition, aI as ToolExecutionContext, b9 as ToolGenerator, az as ToolOutputEnvelope, b8 as ToolOutputValue, s as ToolResult, r as ToolResultBlock, ay as ToolResultChunk, a2 as ToolResultContent, a1 as ToolResultContentBlock, ax as ToolResultMeta, b6 as ToolRuntime, aL as ToolRuntimeCompletedEvent, b2 as ToolRuntimeDispatchDecision, aN as ToolRuntimeEvent, b4 as ToolRuntimeEventHandler, aK as ToolRuntimeOutputChunkEvent, aM as ToolRuntimeRejectedEvent, aJ as ToolRuntimeStartedEvent, b3 as ToolRuntimeToolCallHandler, T as ToolSchema, q as ToolUseBlock, aq as ToolUseDeltaChunk, bc as TransformableStage, bh as Transformer, f as TransformerExtensionRegistration, g as TurnInput, d as TurnResult, aA as TurnResultStatus, an as Usage } from '../types-11Znykt2.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;
-
-declare class TurnFailedError extends Error {
-    readonly state: TurnState;
-    constructor(cause: unknown, state: TurnState);
-}
-
-export { AnthropicThinkingConfig, AutoReasoningEffort, OpenAiReasoningConfig, OperationAbortedError, ReasoningConfig, TurnFailedError, TurnState, 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(_0x406257,_0x36ced4){var _0x2e2623={_0x16e8a3:0x2bc,_0x205251:0x2b7,_0x283aa9:0x2bb,_0x1e00cf:0x2ba,_0x32ea1d:0x2b7,_0x3fdbba:0x2b5,_0x2f50bf:0x273,_0x5e1067:0x272,_0x211940:0x26e,_0x15f02a:0x269,_0x1d0d95:0x265,_0x1749c5:0x2b7,_0x5f5973:0x2b0,_0x29d12e:0x2ba,_0x1d6114:0x2bd,_0x247580:0x26d,_0x17906c:0x26b,_0x3264a7:0x26a,_0x3ad192:0x2b9,_0x1cf2e8:0x2bd,_0x40bde6:0x2bd},_0x129b36={_0x5132bc:0x1e3};function _0x18e744(_0x1a4fbe,_0x396f43,_0xbc7067,_0x532cc8){return _0xad3f(_0x1a4fbe- -0x345,_0x532cc8);}function _0x583c53(_0x4ff0e8,_0x51b729,_0x5d65e9,_0x30935e){return _0xad3f(_0x5d65e9-_0x129b36._0x5132bc,_0x51b729);}var _0x3600fb=_0x406257();while(!![]){try{var _0x3216b3=-parseInt(_0x18e744(-_0x2e2623._0x16e8a3,-_0x2e2623._0x205251,-_0x2e2623._0x283aa9,-_0x2e2623._0x1e00cf))/0x1+parseInt(_0x18e744(-_0x2e2623._0x32ea1d,-_0x2e2623._0x3fdbba,-_0x2e2623._0x3fdbba,-0x2b3))/0x2*(-parseInt(_0x583c53(0x26f,_0x2e2623._0x2f50bf,0x26d,_0x2e2623._0x5e1067))/0x3)+-parseInt(_0x583c53(0x270,0x26b,0x270,_0x2e2623._0x211940))/0x4+parseInt(_0x583c53(0x268,0x267,_0x2e2623._0x15f02a,_0x2e2623._0x1d0d95))/0x5*(-parseInt(_0x18e744(-0x2b5,-_0x2e2623._0x1749c5,-_0x2e2623._0x3fdbba,-_0x2e2623._0x5f5973))/0x6)+parseInt(_0x18e744(-_0x2e2623._0x29d12e,-0x2b9,-_0x2e2623._0x1d6114,-_0x2e2623._0x3fdbba))/0x7*(parseInt(_0x583c53(_0x2e2623._0x247580,0x277,_0x2e2623._0x5e1067,0x275))/0x8)+-parseInt(_0x583c53(0x266,_0x2e2623._0x17906c,_0x2e2623._0x3264a7,0x26c))/0x9*(-parseInt(_0x18e744(-_0x2e2623._0x3ad192,-0x2be,-0x2b6,-_0x2e2623._0x1cf2e8))/0xa)+parseInt(_0x18e744(-_0x2e2623._0x1d6114,-0x2bc,-0x2b7,-_0x2e2623._0x40bde6))/0xb;if(_0x3216b3===_0x36ced4)break;else _0x3600fb['push'](_0x3600fb['shift']());}catch(_0x1401f9){_0x3600fb['push'](_0x3600fb['shift']());}}}(_0x1006,0xb62a9));import{mapAutoReasoningEffortToBudgetTokens,resolveAnthropicThinkingConfig,resolveOpenAiReasoningConfig}from'../chunk-NYZR4XKO.js';function _0x1006(){var _0x5bc2cd=['m3DvyMTlAG','n0flugzPqG','mZaZmhnWzKzHAa','mZm4mtC4nenhDvfQvG','nte4mdyWA1zvAuDL','mte1otq4mtzczLjotNm','nLzPEhPYBW','nZmWnZu3mhfVt29Lvq','ndiZownHz2LWCq','mZmZmda4nZjPvhnjr00','mtmWnZi3ng9Yr3HJAa'];_0x1006=function(){return _0x5bc2cd;};return _0x1006();}function _0xad3f(_0x493e87,_0x2df4aa){_0x493e87=_0x493e87-0x86;var _0x1006fe=_0x1006();var _0xad3fe=_0x1006fe[_0x493e87];if(_0xad3f['dOYYEI']===undefined){var _0x511c5e=function(_0x2e4059){var _0x4bca54='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var _0x4478b5='',_0x5ebda1='';for(var _0x27699a=0x0,_0x14ad36,_0xfe4c7,_0x5dfeba=0x0;_0xfe4c7=_0x2e4059['charAt'](_0x5dfeba++);~_0xfe4c7&&(_0x14ad36=_0x27699a%0x4?_0x14ad36*0x40+_0xfe4c7:_0xfe4c7,_0x27699a++%0x4)?_0x4478b5+=String['fromCharCode'](0xff&_0x14ad36>>(-0x2*_0x27699a&0x6)):0x0){_0xfe4c7=_0x4bca54['indexOf'](_0xfe4c7);}for(var _0x343f85=0x0,_0x391447=_0x4478b5['length'];_0x343f85<_0x391447;_0x343f85++){_0x5ebda1+='%'+('00'+_0x4478b5['charCodeAt'](_0x343f85)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0x5ebda1);};_0xad3f['DoMTFe']=_0x511c5e,_0xad3f['YNNdpl']={},_0xad3f['dOYYEI']=!![];}var _0x5f4d23=_0x1006fe[0x0],_0x44a4ed=_0x493e87+_0x5f4d23,_0x2f01c8=_0xad3f['YNNdpl'][_0x44a4ed];return!_0x2f01c8?(_0xad3fe=_0xad3f['DoMTFe'](_0xad3fe),_0xad3f['YNNdpl'][_0x44a4ed]=_0xad3fe):_0xad3fe=_0x2f01c8,_0xad3fe;}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 _0x1f52(_0x48bc7f,_0x3c859e){_0x48bc7f=_0x48bc7f-0x67;var _0x103fcd=_0x103f();var _0x1f52e4=_0x103fcd[_0x48bc7f];if(_0x1f52['qfyvQt']===undefined){var _0xe73ec2=function(_0x28a587){var _0x18b8f3='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var _0x4e4d4a='',_0x18e252='';for(var _0x2d0e6a=0x0,_0xa33ee7,_0xb1fd67,_0x546bed=0x0;_0xb1fd67=_0x28a587['charAt'](_0x546bed++);~_0xb1fd67&&(_0xa33ee7=_0x2d0e6a%0x4?_0xa33ee7*0x40+_0xb1fd67:_0xb1fd67,_0x2d0e6a++%0x4)?_0x4e4d4a+=String['fromCharCode'](0xff&_0xa33ee7>>(-0x2*_0x2d0e6a&0x6)):0x0){_0xb1fd67=_0x18b8f3['indexOf'](_0xb1fd67);}for(var _0xcde640=0x0,_0x4564c8=_0x4e4d4a['length'];_0xcde640<_0x4564c8;_0xcde640++){_0x18e252+='%'+('00'+_0x4e4d4a['charCodeAt'](_0xcde640)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0x18e252);};_0x1f52['PdSyKB']=_0xe73ec2,_0x1f52['BlzXOG']={},_0x1f52['qfyvQt']=!![];}var _0x3dd39b=_0x103fcd[0x0],_0x18c578=_0x48bc7f+_0x3dd39b,_0x3de5d8=_0x1f52['BlzXOG'][_0x18c578];return!_0x3de5d8?(_0x1f52e4=_0x1f52['PdSyKB'](_0x1f52e4),_0x1f52['BlzXOG'][_0x18c578]=_0x1f52e4):_0x1f52e4=_0x3de5d8,_0x1f52e4;}(function(_0x59a4f7,_0x21023a){var _0x123d24={_0x1f7aee:0x9b,_0x1346d3:0x5,_0x1594f5:0x96,_0x47364b:0x94,_0x56ad7b:0x92,_0x47347c:0x99,_0x13a90e:0x9d,_0x3c04e6:0x9f,_0x3124b8:0x9f,_0x53a36d:0x9d,_0x48900f:0x1,_0x203bdf:0x6,_0x56ba59:0x2,_0x1b9292:0x98},_0x4ea517={_0x5a86fb:0x6e},_0x271995=_0x59a4f7();function _0x15a2bf(_0x51c401,_0x55c95e,_0x486752,_0x1756c0){return _0x1f52(_0x55c95e-0x2d,_0x1756c0);}function _0x463844(_0x1487de,_0x2397fa,_0x2b955c,_0x5d7903){return _0x1f52(_0x1487de- -_0x4ea517._0x5a86fb,_0x2397fa);}while(!![]){try{var _0xa5df13=-parseInt(_0x15a2bf(0x97,_0x123d24._0x1f7aee,0x9a,0x95))/0x1*(parseInt(_0x463844(0x1,-0x3,0x4,0x1))/0x2)+-parseInt(_0x463844(-_0x123d24._0x1346d3,-0x2,-0x7,-0x7))/0x3+parseInt(_0x15a2bf(_0x123d24._0x1594f5,_0x123d24._0x47364b,0x90,_0x123d24._0x56ad7b))/0x4*(-parseInt(_0x15a2bf(_0x123d24._0x47347c,_0x123d24._0x13a90e,0x9e,0x9c))/0x5)+-parseInt(_0x15a2bf(0x9f,_0x123d24._0x3c04e6,0x9d,0x9b))/0x6*(parseInt(_0x15a2bf(0x98,_0x123d24._0x47347c,_0x123d24._0x3124b8,_0x123d24._0x3124b8))/0x7)+-parseInt(_0x15a2bf(0x93,0x97,0x9c,_0x123d24._0x53a36d))/0x8*(-parseInt(_0x463844(-_0x123d24._0x48900f,-0x3,0x4,-0x2))/0x9)+parseInt(_0x463844(-_0x123d24._0x203bdf,0x0,-0xa,-0x2))/0xa*(-parseInt(_0x463844(0x3,-_0x123d24._0x56ba59,-_0x123d24._0x56ba59,0x8))/0xb)+parseInt(_0x15a2bf(0x96,_0x123d24._0x1b9292,0x92,_0x123d24._0x47364b))/0xc;if(_0xa5df13===_0x21023a)break;else _0x271995['push'](_0x271995['shift']());}catch(_0xe245d2){_0x271995['push'](_0x271995['shift']());}}}(_0x103f,0xccd16));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 _0x103f(){var _0x52703b=['nZCYmdm2mMrZAK50zq','mtzwBvv5u2u','mtiYntm0mJbzyxnHAfC','mJC3odG3teLKChLu','ogLXAfzsrG','nteYnZe0nZzAv0PIqLG','n2zeB0n6va','mte2mZqWnJzZzvvrD3a','mJy3ntaZs25fB1rr','nLHUCvHjuW','mty0odK0nu1drxP2Dq','mtfqr2Txq0u'];_0x103f=function(){return _0x52703b;};return _0x103f();}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