@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/{runtime → execution}/index.d.ts

@@ -1,18 +1,14 @@
-import { A as AgentEvent } from '../events-CE72w8W4.js';
-import { T as TokenUsage, M as Message } from '../messages-BYWGn8TY.js';
-import { S as ScopeSnapshot } from '../types-CQL-SvTn.js';
-import { S as StepProcessingOptions, z as StepProcessingOutput, l as AgentTurnStepCommitSnapshot, r as CreateAgentTurnStepCommitBatchOptions, d as AgentTurnCommitBatch, P as PrepareModelStepOptions, u as PreparedAgentModelStep, R as RunModelStepOptions, x as RunToolBatchOptions, y as RunToolBatchResult, C as CommitOutputOptions, p as CommitStepOptions, j as AgentTurnState, n as AgentTurnStepCommitToolResult, m as AgentTurnStepCommitToolCall } from '../types-QKHHQLLq.js';
-export { A as AgentTurnActiveToolCall, a as AgentTurnBoundaryMetadata, b as AgentTurnBoundarySnapshot, c as AgentTurnCommitApplier, e as AgentTurnCommitOptions, f as AgentTurnEngine, g as AgentTurnEngineOptions, h as AgentTurnPhase, i as AgentTurnResolvedToolCall, k as AgentTurnStateAdvanceOptions, o as AgentTurnStepRuntimeConfig, q as CreateAgentTurnStateOptions, v as ProcessorOptions, w as ProcessorOutput, B as advanceAgentTurnState, E as createAgentTurnEngine, F as createAgentTurnState, G as failAgentTurnState } from '../types-QKHHQLLq.js';
-import { A as AnyInferenceResult } from '../types-KKDrdU9Y.js';
-import { ModelMessage } from 'ai';
-import '../tool-BHbyUAy3.js';
+import { e as AnyInferenceResult, cB as StepProcessingOptions, cC as StepProcessingOutput, a6 as AgentTurnStepCommitSnapshot, aF as CreateAgentTurnStepCommitBatchOptions, _ as AgentTurnCommitBatch, b$ as PrepareModelStepOptions, c0 as PreparedAgentModelStep, cb as RunModelStepOptions, A as AgentEvent, cc as RunToolBatchOptions, cd as RunToolBatchResult, av as CommitOutputOptions, aw as CommitStepOptions, dg as TokenUsage, v as ScopeSnapshot, a4 as AgentTurnState, dn as ToolMetadata, a8 as AgentTurnStepCommitToolResult, a7 as AgentTurnStepCommitToolCall, M as Message, dv as UserMessage, ar as AssistantMessage, dm as ToolMessage, cM as SystemMessage } from '../instance-BqV2D5pc.js';
+export { Q as AgentTurnActiveToolCall, X as AgentTurnBoundaryMetadata, Y as AgentTurnBoundarySnapshot, Z as AgentTurnCommitApplier, $ as AgentTurnCommitOptions, a0 as AgentTurnEngine, a1 as AgentTurnEngineOptions, a2 as AgentTurnPhase, a3 as AgentTurnResolvedToolCall, a5 as AgentTurnStateAdvanceOptions, a9 as AgentTurnStepRuntimeConfig, aE as CreateAgentTurnStateOptions, dy as advanceAgentTurnState, dC as createAgentTurnEngine, dD as createAgentTurnState, dK as failAgentTurnState } from '../instance-BqV2D5pc.js';
+import { L as Logger } from '../types-RSCv7nQ4.js';
+export { c as convertAgentMessagesToModelMessages } from '../model-messages-B4nK9D1-.js';
+import '../types-C_LCeYNg.js';
+import 'ai';
 import 'zod';
-import '../tool-DLXAR9Ce.js';
-import '../types-CHiPh8U2.js';
-import '../runner-e2YRcUoX.js';
-import '@ai-sdk/provider-utils';
-import '../types-BfNpU8NS.js';
 import '../types-CQaXbRsS.js';
+import '../types-Bj_J8u_W.js';
+import '@ai-sdk/provider-utils';
+import '../sandbox/index.js';
 import '../llm-error-D93FNNLY.js';
 
 /**
@@ -38,10 +34,6 @@ declare class ContextOverflowError extends Error {
  * Process an inference stream into runtime step events.
  */
 declare function processStepStream(stream: AnyInferenceResult, options: StepProcessingOptions): Promise<StepProcessingOutput>;
-/**
- * @deprecated Use `processStepStream`.
- */
-declare const processStream: typeof processStepStream;
 
 declare function createAgentTurnStepCommitBatch(step: number, snapshot: AgentTurnStepCommitSnapshot, options?: CreateAgentTurnStepCommitBatchOptions): AgentTurnCommitBatch | undefined;
 
@@ -57,6 +49,13 @@ declare function runModelStep(options: RunModelStepOptions): AsyncGenerator<Agen
 
 /**
  * Execute planned tool calls outside the AI SDK loop.
+ *
+ * When multiple tool calls are pending, the batch is partitioned:
+ *  - Tools that declare `capabilities.parallelSafe` run concurrently
+ *  - All other tools run serially (in original order)
+ *
+ * Serial tools always run after the parallel batch completes, preserving
+ * the invariant that non-parallel-safe tools never overlap with anything.
  */
 declare function runToolBatch(options: RunToolBatchOptions): Promise<RunToolBatchResult>;
 
@@ -80,6 +79,8 @@ interface AgentTaskPayload {
 interface AgentTaskExecutionContext {
     /** Abort signal propagated to agent.chat(). */
     signal?: AbortSignal;
+    /** Stable identifier for this task execution when supplied by the caller. */
+    executionId?: string;
     /** Optional trigger descriptor from caller (for logging/routing). */
     trigger?: string;
     /**
@@ -87,6 +88,45 @@ interface AgentTaskExecutionContext {
      * For scheduled jobs, a job ID is a good candidate.
      */
     fallbackSessionKey?: string;
+    /**
+     * Optional prior execution state to resume from. When provided, the task
+     * runner restores accumulated response, usage, tool results, and step
+     * counter from this snapshot before streaming the next agent.chat() turn.
+     *
+     * This enables runtime providers (e.g. Dapr) to implement crash recovery
+     * on the direct (non-workflow) execution path: load the last checkpoint
+     * from the execution store, then re-run with `restoreFrom` so the turn
+     * continues from where it left off rather than starting fresh.
+     *
+     * The snapshot only provides accumulated bookkeeping — the actual
+     * conversation context is recovered through the session storage layer
+     * (same sessionId → same persisted messages).
+     */
+    restoreFrom?: AgentTaskResumeSnapshot;
+}
+/**
+ * Portable snapshot of prior execution state used for resume.
+ *
+ * This is intentionally a minimal subset — just enough for the task runner
+ * to restore its accumulators. The full `AgentTaskExecutionSnapshot` (with
+ * turn state, events, scope) lives in the runtime provider's execution store.
+ */
+interface AgentTaskResumeSnapshot {
+    /** Accumulated response text from prior execution. */
+    response: string;
+    /** Accumulated token usage from prior execution. */
+    usage: TokenUsage;
+    /** Tool calls completed in the prior execution. */
+    toolCalls: Array<{
+        name: string;
+        result: unknown;
+    }>;
+    /** Step counter to resume from. */
+    step: number;
+    /** Event counter to resume from. */
+    eventCount: number;
+    /** ISO timestamp of the original execution start. */
+    startedAt: string;
 }
 interface AgentTaskResult {
     response: string;
@@ -116,6 +156,7 @@ interface AgentTaskExecutionRun<TPayload extends AgentTaskPayload = AgentTaskPay
     payload: Readonly<TPayload>;
     context: Readonly<AgentTaskExecutionContext>;
     sessionId: string;
+    executionId: string;
     startedAt: string;
     scope?: ScopeSnapshot;
 }
@@ -157,7 +198,7 @@ interface AgentTaskObserver<TPayload extends AgentTaskPayload = AgentTaskPayload
      * it into activities so child spans (AI SDK, tool calls) are
      * correlated under the observer's root span.
      */
-    getOtelContext?(sessionId: string): unknown;
+    getOtelContext?(sessionId: string, executionId?: string): unknown;
     /**
      * Activate the OTel context for a session around a function call.
      *
@@ -166,7 +207,7 @@ interface AgentTaskObserver<TPayload extends AgentTaskPayload = AgentTaskPayload
      * execution mode. The observer wraps `fn` in `context.with()` so
      * that `context.active()` returns the session's trace context.
      */
-    activateContext?<T>(sessionId: string, fn: () => T): T;
+    activateContext?<T>(sessionId: string, executionId: string, fn: () => T): T;
 }
 interface AgentTaskCheckpointStrategyInput<TPayload extends AgentTaskPayload = AgentTaskPayload> {
     run: AgentTaskExecutionRun<TPayload>;
@@ -205,6 +246,8 @@ interface AgentTaskRunnerOptions<TPayload extends AgentTaskPayload = AgentTaskPa
      * `defaultAgentTaskCheckpointStrategy(...)`.
      */
     checkpointStrategy?: AgentTaskCheckpointStrategy<TPayload>;
+    /** Logger for diagnostic output. Defaults to silent. */
+    logger?: Logger;
 }
 /**
  * Create a reusable task runner that maps generic task payloads to `agent.chat()`.
@@ -255,6 +298,7 @@ interface AgentWorkflowToolMessageSnapshot {
     toolCallId: string;
     toolName: string;
     result: unknown;
+    metadata?: ToolMetadata;
     compactedAt?: number;
 }
 interface AgentWorkflowSystemMessageSnapshot {
@@ -264,7 +308,7 @@ interface AgentWorkflowSystemMessageSnapshot {
     content: string;
 }
 type AgentWorkflowMessageSnapshot = AgentWorkflowUserMessageSnapshot | AgentWorkflowAssistantMessageSnapshot | AgentWorkflowToolMessageSnapshot | AgentWorkflowSystemMessageSnapshot;
-type AgentWorkflowTurnPhase = "model-step" | "tool-batch" | "step-commit" | "output-commit" | "completed" | "failed";
+type AgentWorkflowTurnPhase = "input-commit" | "model-step" | "tool-batch" | "step-commit" | "output-commit" | "completed" | "failed";
 interface AgentWorkflowReplayDecision {
     toolCallId: string;
     toolName: string;
@@ -291,11 +335,17 @@ interface AgentWorkflowToolCallResult {
     toolResult: AgentTurnStepCommitToolResult;
     turnState?: AgentTurnState;
 }
+interface AgentWorkflowInterventionSnapshot {
+    id: string;
+    message: string;
+    createdAt: string;
+}
 interface AgentWorkflowTurnState {
     sessionId: string;
     systemPrompts: string[];
     messages: AgentWorkflowMessageSnapshot[];
     phase: AgentWorkflowTurnPhase;
+    pendingInput?: AgentWorkflowUserMessageSnapshot;
     step: number;
     maxSteps: number;
     usage?: TokenUsage;
@@ -306,6 +356,19 @@ interface AgentWorkflowTurnState {
     error?: string;
     startedAt: string;
     updatedAt: string;
+    /**
+     * Pending steering messages injected by an external client.
+     * In direct execution, the `InterventionController` handles this.
+     * In durable execution, pending messages are drained at each
+     * model-step boundary and injected as user messages.
+     */
+    pendingInterventions?: AgentWorkflowInterventionSnapshot[];
+    /**
+     * Deferred follow-up messages queued by an external client.
+     * These are held until the current turn completes and can then be
+     * surfaced by the host as candidate next-turn messages.
+     */
+    queuedFollowUps?: AgentWorkflowInterventionSnapshot[];
 }
 interface CreateAgentWorkflowTurnStateOptions {
     sessionId: string;
@@ -313,15 +376,30 @@ interface CreateAgentWorkflowTurnStateOptions {
     maxSteps: number;
     systemPrompts?: string[];
     initialMessages?: AgentWorkflowMessageSnapshot[];
+    initialInput?: AgentWorkflowUserMessageSnapshot;
     initialStep?: number;
 }
-declare function snapshotAgentWorkflowMessage(message: Message): AgentWorkflowMessageSnapshot;
-declare function snapshotAgentWorkflowMessages(messages: Message[]): AgentWorkflowMessageSnapshot[];
-declare function restoreAgentWorkflowMessage(snapshot: AgentWorkflowMessageSnapshot): Message;
-declare function restoreAgentWorkflowMessages(snapshots: AgentWorkflowMessageSnapshot[]): Message[];
 declare function createAgentWorkflowTurnState(options: CreateAgentWorkflowTurnStateOptions): AgentWorkflowTurnState;
 declare function cloneAgentWorkflowTurnState(state: AgentWorkflowTurnState): AgentWorkflowTurnState;
+declare function applyWorkflowInterventions(state: AgentWorkflowTurnState, interventions: readonly AgentWorkflowInterventionSnapshot[], updatedAt: string): AgentWorkflowTurnState;
+/**
+ * Drain pending intervention messages from the workflow state,
+ * injecting each as a user message into `state.messages`.
+ *
+ * Returns the updated state with `pendingInterventions` cleared.
+ * If there are no pending interventions, returns the state unchanged.
+ *
+ * This is the durable-execution equivalent of
+ * `InterventionController.drainImmediate()` in the direct path.
+ */
+declare function drainWorkflowInterventions(state: AgentWorkflowTurnState, updatedAt: string): AgentWorkflowTurnState;
+declare function queueWorkflowFollowUps(state: AgentWorkflowTurnState, followUps: readonly AgentWorkflowInterventionSnapshot[], updatedAt: string): AgentWorkflowTurnState;
 
+interface AgentWorkflowInputCommitPlan {
+    kind: "input-commit";
+    sessionId: string;
+    messages: AgentWorkflowMessageSnapshot[];
+}
 interface AgentWorkflowModelStepPlan {
     kind: "model-step";
     sessionId: string;
@@ -344,13 +422,21 @@ interface AgentWorkflowToolCallPlan {
     turnState: AgentWorkflowTurnState["turnState"];
     replayDecision?: AgentWorkflowReplayDecision;
 }
+interface AgentWorkflowToolBatchPlan {
+    kind: "tool-batch";
+    step: number;
+    sessionId: string;
+    toolCalls: AgentTurnStepCommitToolCall[];
+    turnState: AgentWorkflowTurnState["turnState"];
+    replayDecisions: Record<string, AgentWorkflowReplayDecision>;
+}
 interface AgentWorkflowOutputCommitPlan {
     kind: "output-commit";
     sessionId: string;
     text: string;
     usage?: TokenUsage;
 }
-type AgentWorkflowOperationPlan = AgentWorkflowModelStepPlan | AgentWorkflowToolCallPlan | AgentWorkflowStepCommitPlan | AgentWorkflowOutputCommitPlan;
+type AgentWorkflowOperationPlan = AgentWorkflowInputCommitPlan | AgentWorkflowModelStepPlan | AgentWorkflowToolCallPlan | AgentWorkflowToolBatchPlan | AgentWorkflowStepCommitPlan | AgentWorkflowOutputCommitPlan;
 
 /**
  * Decide which deterministic workflow operation should run next.
@@ -382,13 +468,13 @@ declare function recordAgentWorkflowReplayDecision(state: AgentWorkflowTurnState
  */
 declare function failAgentWorkflowTurnState(state: AgentWorkflowTurnState, error: Error, updatedAt: string): AgentWorkflowTurnState;
 
-/**
- * Convert framework messages into Vercel AI SDK model messages.
- *
- * This keeps the message translation logic reusable for workflow activities
- * and other runtime integrations without forcing those integrations to reach
- * into `Agent` internals.
- */
-declare function convertAgentMessagesToModelMessages(messages: Message[]): ModelMessage[];
+declare function snapshotAgentWorkflowMessage(message: UserMessage): AgentWorkflowUserMessageSnapshot;
+declare function snapshotAgentWorkflowMessage(message: AssistantMessage): AgentWorkflowAssistantMessageSnapshot;
+declare function snapshotAgentWorkflowMessage(message: ToolMessage): AgentWorkflowToolMessageSnapshot;
+declare function snapshotAgentWorkflowMessage(message: SystemMessage): AgentWorkflowSystemMessageSnapshot;
+declare function snapshotAgentWorkflowMessage(message: Message): AgentWorkflowMessageSnapshot;
+declare function snapshotAgentWorkflowMessages(messages: Message[]): AgentWorkflowMessageSnapshot[];
+declare function restoreAgentWorkflowMessage(snapshot: AgentWorkflowMessageSnapshot): Message;
+declare function restoreAgentWorkflowMessages(snapshots: AgentWorkflowMessageSnapshot[]): Message[];
 
-export { type AgentTaskChatAdapter, type AgentTaskCheckpointReason, type AgentTaskCheckpointStrategy, type AgentTaskCheckpointStrategyInput, type AgentTaskExecutionCheckpoint, type AgentTaskExecutionContext, type AgentTaskExecutionRun, type AgentTaskExecutionSnapshot, type AgentTaskObserver, type AgentTaskPayload, type AgentTaskResult, type AgentTaskRunner, type AgentTaskRunnerOptions, AgentTurnCommitBatch, AgentTurnState, AgentTurnStepCommitSnapshot, AgentTurnStepCommitToolCall, AgentTurnStepCommitToolResult, type AgentWorkflowAssistantMessageSnapshot, type AgentWorkflowCommitResult, type AgentWorkflowMessageSnapshot, type AgentWorkflowModelStepPlan, type AgentWorkflowModelStepResult, type AgentWorkflowOperationPlan, type AgentWorkflowOutputCommitPlan, type AgentWorkflowReplayDecision, type AgentWorkflowStepCommitPlan, type AgentWorkflowSystemMessageSnapshot, type AgentWorkflowToolBatchResult, type AgentWorkflowToolCallPlan, type AgentWorkflowToolCallResult, type AgentWorkflowToolCallSnapshot, type AgentWorkflowToolMessageSnapshot, type AgentWorkflowTurnPhase, type AgentWorkflowTurnState, type AgentWorkflowUserMessageSnapshot, CommitOutputOptions, CommitStepOptions, ContextOverflowError, CreateAgentTurnStepCommitBatchOptions, type CreateAgentWorkflowTurnStateOptions, DoomLoopError, PrepareModelStepOptions, PreparedAgentModelStep, RunModelStepOptions, RunToolBatchOptions, RunToolBatchResult, StepProcessingOptions, StepProcessingOutput, applyAgentWorkflowCommitResult, applyAgentWorkflowModelStepResult, applyAgentWorkflowToolBatchResult, applyAgentWorkflowToolCallResult, cloneAgentWorkflowTurnState, commitOutput, commitStep, convertAgentMessagesToModelMessages, createAgentTaskRunner, createAgentTurnStepCommitBatch, createAgentWorkflowTurnState, defaultAgentTaskCheckpointStrategy, failAgentWorkflowTurnState, planNextAgentWorkflowOperation, prepareModelStep, processStepStream, processStream, recordAgentWorkflowReplayDecision, restoreAgentWorkflowMessage, restoreAgentWorkflowMessages, runModelStep, runToolBatch, snapshotAgentWorkflowMessage, snapshotAgentWorkflowMessages };
+export { type AgentTaskChatAdapter, type AgentTaskCheckpointReason, type AgentTaskCheckpointStrategy, type AgentTaskCheckpointStrategyInput, type AgentTaskExecutionCheckpoint, type AgentTaskExecutionContext, type AgentTaskExecutionRun, type AgentTaskExecutionSnapshot, type AgentTaskObserver, type AgentTaskPayload, type AgentTaskResult, type AgentTaskResumeSnapshot, type AgentTaskRunner, type AgentTaskRunnerOptions, AgentTurnCommitBatch, AgentTurnState, AgentTurnStepCommitSnapshot, AgentTurnStepCommitToolCall, AgentTurnStepCommitToolResult, type AgentWorkflowAssistantMessageSnapshot, type AgentWorkflowCommitResult, type AgentWorkflowInputCommitPlan, type AgentWorkflowInterventionSnapshot, type AgentWorkflowMessageSnapshot, type AgentWorkflowModelStepPlan, type AgentWorkflowModelStepResult, type AgentWorkflowOperationPlan, type AgentWorkflowOutputCommitPlan, type AgentWorkflowReplayDecision, type AgentWorkflowStepCommitPlan, type AgentWorkflowSystemMessageSnapshot, type AgentWorkflowToolBatchPlan, type AgentWorkflowToolBatchResult, type AgentWorkflowToolCallPlan, type AgentWorkflowToolCallResult, type AgentWorkflowToolCallSnapshot, type AgentWorkflowToolMessageSnapshot, type AgentWorkflowTurnPhase, type AgentWorkflowTurnState, type AgentWorkflowUserMessageSnapshot, CommitOutputOptions, CommitStepOptions, ContextOverflowError, CreateAgentTurnStepCommitBatchOptions, type CreateAgentWorkflowTurnStateOptions, DoomLoopError, PrepareModelStepOptions, PreparedAgentModelStep, RunModelStepOptions, RunToolBatchOptions, RunToolBatchResult, StepProcessingOptions, StepProcessingOutput, applyAgentWorkflowCommitResult, applyAgentWorkflowModelStepResult, applyAgentWorkflowToolBatchResult, applyAgentWorkflowToolCallResult, applyWorkflowInterventions, cloneAgentWorkflowTurnState, commitOutput, commitStep, createAgentTaskRunner, createAgentTurnStepCommitBatch, createAgentWorkflowTurnState, defaultAgentTaskCheckpointStrategy, drainWorkflowInterventions, failAgentWorkflowTurnState, planNextAgentWorkflowOperation, prepareModelStep, processStepStream, queueWorkflowFollowUps, recordAgentWorkflowReplayDecision, restoreAgentWorkflowMessage, restoreAgentWorkflowMessages, runModelStep, runToolBatch, snapshotAgentWorkflowMessage, snapshotAgentWorkflowMessages };

package/dist/{runtime → execution}/index.js

@@ -7,22 +7,23 @@ import {
   applyAgentWorkflowModelStepResult,
   applyAgentWorkflowToolBatchResult,
   applyAgentWorkflowToolCallResult,
+  applyWorkflowInterventions,
   cloneAgentWorkflowTurnState,
   commitOutput,
   commitStep,
-  convertAgentMessagesToModelMessages,
   createAgentTaskRunner,
   createAgentTurnEngine,
   createAgentTurnState,
   createAgentTurnStepCommitBatch,
   createAgentWorkflowTurnState,
   defaultAgentTaskCheckpointStrategy,
+  drainWorkflowInterventions,
   failAgentTurnState,
   failAgentWorkflowTurnState,
   planNextAgentWorkflowOperation,
   prepareModelStep,
   processStepStream,
-  processStream,
+  queueWorkflowFollowUps,
   recordAgentWorkflowReplayDecision,
   restoreAgentWorkflowMessage,
   restoreAgentWorkflowMessages,
@@ -30,16 +31,18 @@ import {
   runToolBatch,
   snapshotAgentWorkflowMessage,
   snapshotAgentWorkflowMessages
-} from "../chunk-4BDA7DQY.js";
-import "../chunk-WWYYNWEW.js";
-import "../chunk-N6HWIEEA.js";
-import "../chunk-7VKQ4WPB.js";
-import "../chunk-VEKUXUVF.js";
-import "../chunk-SQU2AJHO.js";
-import "../chunk-N7P4PN3O.js";
-import "../chunk-RZITT45F.js";
-import "../chunk-RFEKJKTO.js";
-import "../chunk-DWYX7ASF.js";
+} from "../chunk-WBPOZ7CL.js";
+import {
+  convertAgentMessagesToModelMessages
+} from "../chunk-CMYN2RCB.js";
+import "../chunk-5NVVNXPQ.js";
+import "../chunk-N3VX7FEE.js";
+import "../chunk-RN6WZEUF.js";
+import "../chunk-CJI7PVS2.js";
+import "../chunk-I6PKJ7XQ.js";
+import "../chunk-V4RFNEET.js";
+import "../chunk-FII65CN7.js";
+import "../chunk-T4UIX5D7.js";
 export {
   AgentTurnEngine,
   ContextOverflowError,
@@ -49,6 +52,7 @@ export {
   applyAgentWorkflowModelStepResult,
   applyAgentWorkflowToolBatchResult,
   applyAgentWorkflowToolCallResult,
+  applyWorkflowInterventions,
   cloneAgentWorkflowTurnState,
   commitOutput,
   commitStep,
@@ -59,12 +63,13 @@ export {
   createAgentTurnStepCommitBatch,
   createAgentWorkflowTurnState,
   defaultAgentTaskCheckpointStrategy,
+  drainWorkflowInterventions,
   failAgentTurnState,
   failAgentWorkflowTurnState,
   planNextAgentWorkflowOperation,
   prepareModelStep,
   processStepStream,
-  processStream,
+  queueWorkflowFollowUps,
   recordAgentWorkflowReplayDecision,
   restoreAgentWorkflowMessage,
   restoreAgentWorkflowMessages,

package/dist/index-BCqEGzBj.d.ts

@@ -0,0 +1,251 @@
+import { R as ReasoningLevel, a as ReasoningConfig } from './types-CQaXbRsS.js';
+import { LanguageModel } from 'ai';
+import { ProviderOptions } from '@ai-sdk/provider-utils';
+
+/**
+ * Model Capability Types for @cuylabs/agent-core
+ *
+ * Defines the structure for model capabilities that can be sourced from
+ * static patterns, local cache, or remote APIs.
+ */
+/**
+ * Input modalities a model can accept
+ */
+type InputModality = "text" | "image" | "audio" | "video" | "pdf";
+/**
+ * Output modalities a model can produce
+ */
+type OutputModality = "text" | "image" | "audio" | "video";
+/**
+ * Comprehensive model capabilities
+ */
+interface ModelCapabilities {
+    /** Model supports extended reasoning/thinking */
+    reasoning: boolean;
+    /** Model supports function/tool calling */
+    toolCalling: boolean;
+    /** Model supports temperature adjustment */
+    temperature: boolean;
+    /** Model supports file attachments */
+    attachments: boolean;
+    /** Model supports streaming responses */
+    streaming: boolean;
+    /** Supported input modalities */
+    inputModalities: InputModality[];
+    /** Supported output modalities */
+    outputModalities: OutputModality[];
+    /** Maximum context window in tokens */
+    contextWindow?: number;
+    /** Maximum output tokens */
+    maxOutput?: number;
+}
+/**
+ * Provider-specific compatibility flags
+ * These handle quirks in different provider implementations
+ */
+interface ProviderCompatibility {
+    /** Supports OpenAI-style reasoning_effort parameter */
+    supportsReasoningEffort?: boolean;
+    /** Supports developer/system role distinction */
+    supportsDeveloperRole?: boolean;
+    /** Field name for max tokens (varies by provider) */
+    maxTokensField?: "max_tokens" | "max_completion_tokens";
+    /** Requires thinking as text tags vs structured */
+    requiresThinkingTags?: boolean;
+    /** Provider-specific thinking format */
+    thinkingFormat?: "openai" | "anthropic" | "google" | "zai";
+}
+/**
+ * Complete model entry with metadata
+ */
+interface ModelEntry {
+    /** Model identifier (e.g., "gpt-4o", "claude-sonnet-4") */
+    id: string;
+    /** Human-readable model name */
+    name: string;
+    /** Provider identifier (e.g., "openai", "anthropic") */
+    provider: string;
+    /** Model capabilities */
+    capabilities: ModelCapabilities;
+    /** Provider-specific compatibility settings */
+    compatibility?: ProviderCompatibility;
+    /** Cost per million tokens (input) */
+    costInput?: number;
+    /** Cost per million tokens (output) */
+    costOutput?: number;
+    /** When this entry was last updated */
+    updatedAt?: string;
+}
+/**
+ * Priority levels for capability sources
+ */
+declare enum SourcePriority {
+    /** User configuration overrides everything */
+    UserConfig = 0,
+    /** Local cache from previous fetch */
+    LocalCache = 1,
+    /** Bundled static data (build-time) */
+    BundledData = 2,
+    /** Pattern-based inference (fallback) */
+    PatternMatch = 3,
+    /** Remote API (if network available) */
+    RemoteAPI = 4
+}
+/**
+ * Result from a capability source lookup
+ */
+interface SourceResult {
+    /** The model entry if found */
+    entry?: ModelEntry;
+    /** Which source provided this result */
+    source: SourcePriority;
+    /** Whether this is a confident match */
+    confident: boolean;
+    /** Error message if lookup failed */
+    error?: string;
+}
+/**
+ * Capability source interface
+ */
+interface CapabilitySource {
+    /** Source priority (lower = higher priority) */
+    priority: SourcePriority;
+    /** Human-readable source name */
+    name: string;
+    /** Look up capabilities for a model */
+    lookup(modelId: string, provider?: string): Promise<SourceResult>;
+    /** Check if this source is available */
+    isAvailable(): Promise<boolean>;
+}
+/**
+ * Options for the capability resolver
+ */
+interface ResolverOptions {
+    /** Enable remote API fetching (default: false) */
+    enableRemoteFetch?: boolean;
+    /** Remote API URL (default: https://models.dev) */
+    remoteApiUrl?: string;
+    /** Cache directory path */
+    cachePath?: string;
+    /** Cache TTL in milliseconds (default: 1 hour) */
+    cacheTtlMs?: number;
+    /** Network timeout in milliseconds (default: 10 seconds) */
+    networkTimeoutMs?: number;
+    /** Custom user overrides for specific models */
+    modelOverrides?: Record<string, Partial<ModelCapabilities>>;
+}
+/**
+ * Default resolver options
+ */
+declare const DEFAULT_RESOLVER_OPTIONS: Required<ResolverOptions>;
+
+/**
+ * Provider-Specific Reasoning Option Builders
+ *
+ * Each function takes a {@link ReasoningLevel} and returns the
+ * provider-options object expected by the Vercel AI SDK's
+ * `providerOptions` parameter.
+ *
+ * Provider key mapping (`getProviderOptionsKey`) is also defined
+ * here so that callers can wrap the raw options correctly.
+ */
+
+/**
+ * Build OpenAI reasoning options.
+ *
+ * OpenAI reasoning models use:
+ * - `reasoningEffort` — controls depth
+ * - `reasoningSummary` — controls whether reasoning is streamed
+ *   (`"auto"` = condensed summary, `"detailed"` = full)
+ *
+ * `reasoningSummary` requires a verified OpenAI organisation.
+ * Set `CODE_AGENT_DISABLE_REASONING_SUMMARY=true` to skip it.
+ */
+declare function buildOpenAIOptions(level: ReasoningLevel, compat?: ProviderCompatibility): Record<string, unknown> | undefined;
+/**
+ * Build Anthropic thinking options.
+ *
+ * Uses `thinking.type: "enabled"` with `budgetTokens`.
+ */
+declare function buildAnthropicOptions(level: ReasoningLevel): Record<string, unknown> | undefined;
+/**
+ * Build Google / Gemini reasoning options.
+ *
+ * - **Gemini 3+** uses `thinkingLevel` (`"low"` / `"high"`)
+ * - **Gemini 2.5 and earlier** uses `thinkingBudget` (token count)
+ */
+declare function buildGoogleOptions(level: ReasoningLevel, modelId?: string): Record<string, unknown> | undefined;
+/**
+ * Build xAI / Grok reasoning options.
+ */
+declare function buildXAIOptions(level: ReasoningLevel): Record<string, unknown> | undefined;
+/**
+ * Build Groq reasoning options.
+ */
+declare function buildGroqOptions(level: ReasoningLevel): Record<string, unknown> | undefined;
+/**
+ * Build Amazon Bedrock reasoning options.
+ *
+ * - Anthropic / Claude models use `budgetTokens`
+ * - Amazon Nova models use `maxReasoningEffort`
+ */
+declare function buildBedrockOptions(level: ReasoningLevel, modelId?: string): Record<string, unknown> | undefined;
+/**
+ * Build OpenRouter reasoning options.
+ */
+declare function buildOpenRouterOptions(level: ReasoningLevel): Record<string, unknown> | undefined;
+/**
+ * Resolve the `providerOptions` key for a given SDK provider string.
+ *
+ * Falls back to the first dot-segment (e.g. `"foo.bar"` → `"foo"`).
+ */
+declare function getProviderOptionsKey(provider: string): string;
+
+/**
+ * Reasoning Configuration & Option Builders
+ *
+ * Orchestrates capability detection and provider-specific option
+ * building to produce ready-to-use `providerOptions` for the
+ * Vercel AI SDK.
+ *
+ * Two flavours of every function are provided:
+ * - **Async** (`getReasoningConfig`, `buildReasoningOptions`) —
+ *   uses the full capability resolver (network + cache).
+ * - **Sync** (`getReasoningConfigSync`, `buildReasoningOptionsSync`) —
+ *   uses fast pattern-matching only (no network).
+ */
+
+/**
+ * Get the reasoning configuration for a model.
+ *
+ * Uses the full capability resolver (including network lookups)
+ * for the most accurate result.
+ */
+declare function getReasoningConfig(model: LanguageModel): Promise<ReasoningConfig>;
+/**
+ * Synchronous reasoning config using pattern-matching only.
+ *
+ * Faster but less accurate than {@link getReasoningConfig}.
+ * Good for hot paths where async is impractical.
+ */
+declare function getReasoningConfigSync(model: LanguageModel): ReasoningConfig;
+/**
+ * Build `providerOptions` for a reasoning level (async).
+ *
+ * Returns `undefined` when reasoning is off or unsupported.
+ */
+declare function buildReasoningOptions(model: LanguageModel, level: ReasoningLevel): Promise<ProviderOptions | undefined>;
+/**
+ * Build `providerOptions` for a reasoning level (sync / pattern-only).
+ */
+declare function buildReasoningOptionsSync(model: LanguageModel, level: ReasoningLevel): ProviderOptions | undefined;
+/**
+ * Check whether a model supports reasoning (async, full resolver).
+ */
+declare function supportsReasoning(model: LanguageModel): Promise<boolean>;
+/**
+ * Synchronous check using pattern-matching only.
+ */
+declare function supportsReasoningSync(model: LanguageModel): boolean;
+
+export { type CapabilitySource as C, DEFAULT_RESOLVER_OPTIONS as D, type InputModality as I, type ModelCapabilities as M, type OutputModality as O, type ProviderCompatibility as P, type ResolverOptions as R, SourcePriority as S, type ModelEntry as a, type SourceResult as b, buildAnthropicOptions as c, buildBedrockOptions as d, buildGoogleOptions as e, buildGroqOptions as f, buildOpenAIOptions as g, buildOpenRouterOptions as h, buildReasoningOptions as i, buildReasoningOptionsSync as j, buildXAIOptions as k, getProviderOptionsKey as l, getReasoningConfig as m, getReasoningConfigSync as n, supportsReasoningSync as o, supportsReasoning as s };