@cuylabs/agent-core 0.6.0 → 0.7.0

package/dist/inference/index.d.ts

@@ -0,0 +1,59 @@
+import { ToolSet } from 'ai';
+import { T as Tool } from '../tool-Db1Ue-1U.js';
+import { T as ToolHost } from '../types-CHiPh8U2.js';
+import { M as MiddlewareRunner } from '../runner-DSKaEz3z.js';
+export { S as StreamChunk } from '../runner-DSKaEz3z.js';
+import { d as TurnTrackerContext } from '../tool-HUtkiVBx.js';
+import { T as ToolExecutionMode, I as InferenceStreamInput, A as AnyInferenceResult } from '../types-FRpzzg_9.js';
+export { a as AnyStreamResult, C as CustomStreamProvider, b as CustomStreamResult, D as DEFAULT_MAX_OUTPUT_TOKENS, c as InferenceCustomResult, d as InferenceStepInfo, e as InferenceStreamResult, L as LLMStreamInput, f as LLMStreamResult, O as OUTPUT_TOKEN_MAX, S as StepInfo } from '../types-FRpzzg_9.js';
+import 'zod';
+import '@ai-sdk/provider-utils';
+import '../messages-BYWGn8TY.js';
+import '../types-9jGQUjqW.js';
+import '../types-CQaXbRsS.js';
+
+/**
+ * Build a Vercel AI SDK `ToolSet` from `Tool.Info` definitions.
+ */
+declare function buildToolSet(options: {
+    tools: Record<string, Tool.Info>;
+    cwd: string;
+    sessionID: string;
+    messageID: string;
+    abort: AbortSignal;
+    turnTracker?: TurnTrackerContext;
+    host?: ToolHost;
+    middleware?: MiddlewareRunner;
+    executionMode?: ToolExecutionMode;
+}): Promise<ToolSet>;
+
+/**
+ * Create a model inference stream with optional retry support.
+ */
+declare function stream(input: InferenceStreamInput): Promise<AnyInferenceResult>;
+/**
+ * Create a stream without retry.
+ */
+declare function streamOnce(input: InferenceStreamInput): Promise<AnyInferenceResult>;
+/**
+ * Create a single-step stream.
+ */
+declare function streamStep(input: InferenceStreamInput): Promise<AnyInferenceResult>;
+
+declare const Inference: {
+    readonly buildToolSet: typeof buildToolSet;
+    readonly stream: typeof stream;
+    readonly streamOnce: typeof streamOnce;
+    readonly streamStep: typeof streamStep;
+};
+/**
+ * @deprecated Use `Inference`.
+ */
+declare const LLM: {
+    readonly buildToolSet: typeof buildToolSet;
+    readonly stream: typeof stream;
+    readonly streamOnce: typeof streamOnce;
+    readonly streamStep: typeof streamStep;
+};
+
+export { AnyInferenceResult, Inference, InferenceStreamInput, LLM, ToolExecutionMode, buildToolSet, stream, streamOnce, streamStep };

package/dist/inference/index.js

@@ -0,0 +1,25 @@
+import {
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  Inference,
+  LLM,
+  OUTPUT_TOKEN_MAX,
+  buildToolSet,
+  stream,
+  streamOnce,
+  streamStep
+} from "../chunk-5K7AQVOU.js";
+import "../chunk-ZPMACVZK.js";
+import "../chunk-IEFIQENH.js";
+import "../chunk-N7P4PN3O.js";
+import "../chunk-VEKUXUVF.js";
+import "../chunk-QGOGIP7T.js";
+export {
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  Inference,
+  LLM,
+  OUTPUT_TOKEN_MAX,
+  buildToolSet,
+  stream,
+  streamOnce,
+  streamStep
+};

package/dist/middleware/index.d.ts

@@ -1,8 +1,11 @@
-export { h as AgentMiddleware, i as AgentModelHooks, B as BlockedModelCall, M as MiddlewareRunner, m as ModelCallContext, f as ModelCallInput, n as ModelCallOutput, T as ToolCallDecision } from '../runner-G1wxEgac.js';
-export { c as ApprovalMiddlewareConfig, O as OtelMiddlewareConfig, T as TelemetryConfig, e as TelemetryConfigResult, f as approvalMiddleware, g as createTelemetryConfig, o as otelMiddleware } from '../index-ipP3_ztp.js';
+export { h as AgentMiddleware, i as AgentModelHooks, B as BlockedModelCall, M as MiddlewareRunner, m as ModelCallContext, e as ModelCallInput, n as ModelCallOutput, T as ToolCallDecision } from '../runner-DSKaEz3z.js';
+export { c as ApprovalMiddlewareConfig, C as CacheTTL, O as OtelMiddlewareConfig, P as PromptCacheConfig, T as TelemetryConfig, e as TelemetryConfigResult, f as approvalMiddleware, g as createTelemetryConfig, o as otelMiddleware, p as promptCacheMiddleware } from '../index-CfBGYrpd.js';
 import 'ai';
+import '@ai-sdk/provider-utils';
 import '../messages-BYWGn8TY.js';
-import '../tool-pFAnJc5Y.js';
+import '../tool-Db1Ue-1U.js';
 import 'zod';
-import '../tool-DYp6-cC3.js';
+import '../tool-HUtkiVBx.js';
+import '../types-CHiPh8U2.js';
+import '../types-9jGQUjqW.js';
 import '../types-CQaXbRsS.js';

package/dist/middleware/index.js

@@ -2,11 +2,13 @@ import {
   MiddlewareRunner,
   approvalMiddleware,
   createTelemetryConfig,
-  otelMiddleware
-} from "../chunk-O2ZCFQL6.js";
+  otelMiddleware,
+  promptCacheMiddleware
+} from "../chunk-CDTV2UYU.js";
 export {
   MiddlewareRunner,
   approvalMiddleware,
   createTelemetryConfig,
-  otelMiddleware
+  otelMiddleware,
+  promptCacheMiddleware
 };

package/dist/models/index.d.ts

@@ -1,5 +1,15 @@
-export { g as getModelId, a as getProviderId } from '../identifiers-BLUxFqV_.js';
 import { LanguageModel } from 'ai';
+import { C as CapabilitySource, S as SourcePriority, d as SourceResult, P as ProviderCompatibility, c as ResolverOptions, b as ModelEntry, M as ModelCapabilities, N as NetworkStatus } from '../capability-resolver-CgRGsWVX.js';
+export { D as DEFAULT_RESOLVER_OPTIONS, I as InputModality, a as ModelCapabilityResolver, O as OutputModality, R as ResolutionResult, e as configureResolver, f as extractModelId, g as extractProvider, h as getDefaultResolver } from '../capability-resolver-CgRGsWVX.js';
+
+/**
+ * Extract a model ID string from a LanguageModel instance.
+ */
+declare function getModelId(model: LanguageModel): string;
+/**
+ * Extract a provider identifier from a LanguageModel instance.
+ */
+declare function getProviderId(model: LanguageModel): string | undefined;
 
 type AdapterKind = "openai" | "anthropic" | "google" | "openai-compatible";
 type AdapterSettings = {
@@ -30,4 +40,96 @@ type Resolver = (key: string) => Promise<LanguageModel>;
 type SyncResolver = (key: string) => LanguageModel;
 declare function createResolver(directory: Directory): Resolver;
 
-export { type AdapterSettings, type Directory, type EngineSpec, type ModelSpec, type Resolver, type SyncResolver, createResolver };
+/**
+ * Profile-Based Capability Detection for @cuylabs/agent-core
+ *
+ * Static pattern matching for model capabilities when no external data is available.
+ * This is the fallback layer — always works offline.
+ */
+
+/**
+ * Infer provider from model ID
+ */
+declare function inferProvider(modelId: string): string | undefined;
+/**
+ * Pattern-based capability source
+ * Always available, uses heuristics to detect capabilities
+ */
+declare class PatternCapabilitySource implements CapabilitySource {
+    readonly priority = SourcePriority.PatternMatch;
+    readonly name = "Pattern Matching";
+    lookup(modelId: string, providerHint?: string): Promise<SourceResult>;
+    isAvailable(): Promise<boolean>;
+}
+/**
+ * Quick check if a model ID likely supports reasoning
+ */
+declare function likelySupportsReasoning(modelId: string): boolean;
+/**
+ * Get provider compatibility for a model
+ */
+declare function getProviderCompatibility(modelId: string, provider?: string): ProviderCompatibility | undefined;
+
+type CapabilityOverrides = ResolverOptions["modelOverrides"];
+type OverrideLookup = {
+    override?: Partial<ModelCapabilities>;
+    matchedKey?: string;
+};
+declare function findCapabilityOverride(overrides: CapabilityOverrides, modelId: string, provider?: string): OverrideLookup;
+declare function applyCapabilityOverride(entry: ModelEntry, override?: Partial<ModelCapabilities>): ModelEntry;
+
+declare class CapabilityCache {
+    private adapter;
+    private memoryCache;
+    private ttlMs;
+    private loaded;
+    constructor(options?: Partial<ResolverOptions>);
+    private load;
+    get(modelId: string, provider?: string): Promise<ModelEntry | undefined>;
+    set(entry: ModelEntry): Promise<void>;
+    setMany(entries: ModelEntry[]): Promise<void>;
+    persist(): Promise<void>;
+    clear(): Promise<void>;
+    stats(): {
+        size: number;
+        loaded: boolean;
+    };
+    getAll(): Promise<ModelEntry[]>;
+    getAllByProvider(): Promise<Record<string, ModelEntry[]>>;
+}
+declare class CacheCapabilitySource implements CapabilitySource {
+    private cache;
+    readonly priority = SourcePriority.LocalCache;
+    readonly name = "Local Cache";
+    constructor(cache: CapabilityCache);
+    lookup(modelId: string, provider?: string): Promise<SourceResult>;
+    isAvailable(): Promise<boolean>;
+}
+
+declare function getNetworkStatus(): NetworkStatus;
+
+declare class RemoteCapabilityFetcher {
+    private apiUrl;
+    private timeoutMs;
+    private cache;
+    private lastFetchTime;
+    private minFetchInterval;
+    constructor(cache: CapabilityCache, options?: Partial<ResolverOptions>);
+    fetchAll(): Promise<ModelEntry[]>;
+    ping(): Promise<boolean>;
+}
+
+declare class RemoteCapabilitySource implements CapabilitySource {
+    readonly priority = SourcePriority.RemoteAPI;
+    readonly name = "Remote API (models.dev)";
+    private fetcher;
+    private cache;
+    private fetchPromise;
+    private enabled;
+    constructor(cache: CapabilityCache, options?: Partial<ResolverOptions>);
+    lookup(modelId: string, provider?: string): Promise<SourceResult>;
+    isAvailable(): Promise<boolean>;
+    refresh(): Promise<void>;
+}
+
+export { type AdapterSettings, CacheCapabilitySource, CapabilityCache, type CapabilityOverrides, CapabilitySource, type Directory, type EngineSpec, ModelCapabilities, ModelEntry, type ModelSpec, NetworkStatus, PatternCapabilitySource, ProviderCompatibility, RemoteCapabilityFetcher, RemoteCapabilitySource, type Resolver, ResolverOptions, SourcePriority, SourceResult, type SyncResolver, applyCapabilityOverride, createResolver, findCapabilityOverride, getModelId, getNetworkStatus, getProviderCompatibility, getProviderId, inferProvider, likelySupportsReasoning };

package/dist/models/index.js

@@ -1,12 +1,46 @@
 import {
-  createResolver
-} from "../chunk-6TDTQJ4P.js";
-import {
+  CacheCapabilitySource,
+  CapabilityCache,
+  DEFAULT_RESOLVER_OPTIONS,
+  ModelCapabilityResolver,
+  PatternCapabilitySource,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
+  SourcePriority,
+  applyCapabilityOverride,
+  configureResolver,
+  createResolver,
+  extractModelId,
+  extractProvider,
+  findCapabilityOverride,
+  getDefaultResolver,
   getModelId,
-  getProviderId
-} from "../chunk-DWYX7ASF.js";
+  getNetworkStatus,
+  getProviderCompatibility,
+  getProviderId,
+  inferProvider,
+  likelySupportsReasoning
+} from "../chunk-QGOGIP7T.js";
 export {
+  CacheCapabilitySource,
+  CapabilityCache,
+  DEFAULT_RESOLVER_OPTIONS,
+  ModelCapabilityResolver,
+  PatternCapabilitySource,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
+  SourcePriority,
+  applyCapabilityOverride,
+  configureResolver,
   createResolver,
+  extractModelId,
+  extractProvider,
+  findCapabilityOverride,
+  getDefaultResolver,
   getModelId,
-  getProviderId
+  getNetworkStatus,
+  getProviderCompatibility,
+  getProviderId,
+  inferProvider,
+  likelySupportsReasoning
 };

package/dist/prompt/index.d.ts

@@ -1,12 +1,15 @@
-import { c as ModelFamily, l as EnvironmentInfo, I as InstructionFile } from '../runner-G1wxEgac.js';
-export { a as PromptBuildContext, P as PromptConfig, b as PromptSection } from '../runner-G1wxEgac.js';
+import { c as ModelFamily, l as EnvironmentInfo, I as InstructionFile } from '../runner-DSKaEz3z.js';
+export { a as PromptBuildContext, P as PromptConfig, b as PromptSection } from '../runner-DSKaEz3z.js';
 import { LanguageModel } from 'ai';
-export { P as PromptBuilder, c as createPromptBuilder } from '../builder-BKkipazh.js';
-export { d as SkillConfig } from '../tool-pFAnJc5Y.js';
+export { P as PromptBuilder, c as createPromptBuilder } from '../builder-BRvqCcIk.js';
+export { d as SkillConfig } from '../tool-Db1Ue-1U.js';
+import '@ai-sdk/provider-utils';
 import '../messages-BYWGn8TY.js';
-import '../tool-DYp6-cC3.js';
+import '../types-9jGQUjqW.js';
+import '../tool-HUtkiVBx.js';
+import '../types-CHiPh8U2.js';
 import '../types-CQaXbRsS.js';
-import '../registry-CuRWWtcT.js';
+import '../registry-BDLIHOQB.js';
 import 'zod';
 
 /**

package/dist/reasoning/index.d.ts

@@ -1,10 +1,9 @@
-import { R as ReasoningLevel } from '../types-CQaXbRsS.js';
-export { E as EXTENDED_LEVELS, F as FIXED_LEVELS, a as ReasoningConfig, S as STANDARD_LEVELS, s as shouldIncludeReasoningSummary } from '../types-CQaXbRsS.js';
-import { P as ProviderCompatibility } from '../resolver-DOfZ-xuk.js';
-export { e as extractModelId, a as extractProvider } from '../resolver-DOfZ-xuk.js';
-export { b as buildReasoningOptions, a as buildReasoningOptionsSync, g as getReasoningConfig, c as getReasoningConfigSync, s as supportsReasoning, d as supportsReasoningSync } from '../config-D2xeGEHK.js';
-import 'ai';
-import '@ai-sdk/provider-utils';
+import { R as ReasoningLevel, a as ReasoningConfig } from '../types-CQaXbRsS.js';
+export { E as EXTENDED_LEVELS, F as FIXED_LEVELS, S as STANDARD_LEVELS, s as shouldIncludeReasoningSummary } from '../types-CQaXbRsS.js';
+import { P as ProviderCompatibility } from '../capability-resolver-CgRGsWVX.js';
+export { f as extractModelId, g as extractProvider } from '../capability-resolver-CgRGsWVX.js';
+import { LanguageModel } from 'ai';
+import { ProviderOptions } from '@ai-sdk/provider-utils';
 
 /**
  * Provider-Specific Reasoning Option Builders
@@ -68,4 +67,51 @@ declare function buildOpenRouterOptions(level: ReasoningLevel): Record<string, u
  */
 declare function getProviderOptionsKey(provider: string): string;
 
-export { ReasoningLevel, buildAnthropicOptions, buildBedrockOptions, buildGoogleOptions, buildGroqOptions, buildOpenAIOptions, buildOpenRouterOptions, buildXAIOptions, getProviderOptionsKey };
+/**
+ * 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 { ReasoningConfig, ReasoningLevel, buildAnthropicOptions, buildBedrockOptions, buildGoogleOptions, buildGroqOptions, buildOpenAIOptions, buildOpenRouterOptions, buildReasoningOptions, buildReasoningOptionsSync, buildXAIOptions, getProviderOptionsKey, getReasoningConfig, getReasoningConfigSync, supportsReasoning, supportsReasoningSync };

package/dist/reasoning/index.js

@@ -17,12 +17,11 @@ import {
   shouldIncludeReasoningSummary,
   supportsReasoning,
   supportsReasoningSync
-} from "../chunk-X635CM2F.js";
+} from "../chunk-ZPMACVZK.js";
 import {
   extractModelId,
   extractProvider
-} from "../chunk-QWFMX226.js";
-import "../chunk-DWYX7ASF.js";
+} from "../chunk-QGOGIP7T.js";
 export {
   EXTENDED_LEVELS,
   FIXED_LEVELS,

package/dist/{registry-CuRWWtcT.d.ts → registry-BDLIHOQB.d.ts}

@@ -1,4 +1,4 @@
-import { S as SkillDiscoveryResult, a as SkillMetadata, b as SkillContent, c as SkillResource, d as SkillConfig } from './tool-pFAnJc5Y.js';
+import { S as SkillDiscoveryResult, a as SkillMetadata, b as SkillContent, c as SkillResource, d as SkillConfig } from './tool-Db1Ue-1U.js';
 
 /**
  * Skill Registry — in-memory store for discovered skills

package/dist/{runner-G1wxEgac.d.ts → runner-DSKaEz3z.d.ts}

@@ -1,8 +1,10 @@
 import * as ai from 'ai';
-import { LanguageModel, ModelMessage, TelemetrySettings } from 'ai';
+import { LanguageModel, ModelMessage, TelemetrySettings, SystemModelMessage } from 'ai';
+import { ProviderOptions } from '@ai-sdk/provider-utils';
 import { T as TokenUsage, M as Message } from './messages-BYWGn8TY.js';
-import { d as SkillConfig, T as Tool } from './tool-pFAnJc5Y.js';
-import { b as ToolContext } from './tool-DYp6-cC3.js';
+import { d as SkillConfig, T as Tool } from './tool-Db1Ue-1U.js';
+import { b as ScopeSnapshot } from './types-9jGQUjqW.js';
+import { b as ToolContext } from './tool-HUtkiVBx.js';
 import { R as ReasoningLevel } from './types-CQaXbRsS.js';
 
 /**
@@ -89,7 +91,7 @@ type StreamChunk = {
 /**
  * Custom stream provider function type.
  *
- * This matches the signature needed for agent-core's LLM module,
+ * This matches the signature needed for agent-core's inference module,
  * returning a StreamProviderResult-compatible object.
  */
 type StreamProvider = (input: StreamProviderInput) => Promise<StreamProviderResult>;
@@ -297,11 +299,15 @@ type AgentEvent = {
     output?: string;
 };
 /**
- * Processor result - what happens after processing a turn
+ * Step-processing result - what happens after reducing one streamed step
  */
-type ProcessorResult = "continue" | "stop" | "compact";
+type StepProcessingResult = "continue" | "stop" | "compact";
 /**
- * Stream input for the LLM
+ * @deprecated Use `StepProcessingResult`.
+ */
+type ProcessorResult = StepProcessingResult;
+/**
+ * Stream input for model inference
  */
 interface StreamInput {
     sessionID: string;
@@ -572,6 +578,26 @@ interface ModelCallInput {
     telemetry?: TelemetrySettings;
     customStreamProvider?: StreamProvider;
     toolExecutionMode?: "auto" | "plan";
+    /**
+     * Provider-specific options passed through to `streamText()`.
+     *
+     * Middleware can set these to enable provider features like Anthropic
+     * prompt caching (`{ anthropic: { cacheControl: { type: "ephemeral" } } }`).
+     *
+     * When multiple sources set providerOptions (e.g. middleware + reasoning),
+     * they are shallow-merged before the LLM call.
+     */
+    providerOptions?: ProviderOptions;
+    /**
+     * System messages with provider-specific options.
+     *
+     * When set, these take precedence over the plain `system` strings.
+     * This allows middleware to attach per-message metadata such as
+     * Anthropic `cacheControl` breakpoints on system content.
+     *
+     * Leave undefined to use the plain `system` string array.
+     */
+    systemMessages?: SystemModelMessage[];
 }
 /**
  * Context shared across model middleware hooks for a single step.
@@ -584,6 +610,7 @@ interface ModelCallContext {
     model: LanguageModel;
     toolNames: string[];
     mcpToolNames: string[];
+    scope?: ScopeSnapshot;
 }
 /**
  * Return this from `model.input(...)` to stop an LLM call entirely.
@@ -849,4 +876,4 @@ declare class MiddlewareRunner {
     }): Promise<void>;
 }
 
-export { type AgentEvent as A, type BlockedModelCall as B, type EnhancedTools as E, type InstructionFile as I, MiddlewareRunner as M, type PromptConfig as P, type StreamChunk as S, type ToolCallDecision as T, type PromptBuildContext as a, type PromptSection as b, type ModelFamily as c, type ProcessorResult as d, type StreamProvider as e, type ModelCallInput as f, type AgentTurnBoundaryKind as g, type AgentMiddleware as h, type AgentModelHooks as i, type AgentStatus as j, type ApprovalEvent as k, type EnvironmentInfo as l, type ModelCallContext as m, type ModelCallOutput as n, type StreamInput as o, type StreamProviderConfig as p, type StreamProviderFactory as q, type StreamProviderInput as r, type StreamProviderResult as s };
+export { type AgentEvent as A, type BlockedModelCall as B, type EnhancedTools as E, type InstructionFile as I, MiddlewareRunner as M, type PromptConfig as P, type StreamChunk as S, type ToolCallDecision as T, type PromptBuildContext as a, type PromptSection as b, type ModelFamily as c, type StreamProvider as d, type ModelCallInput as e, type StepProcessingResult as f, type AgentTurnBoundaryKind as g, type AgentMiddleware as h, type AgentModelHooks as i, type AgentStatus as j, type ApprovalEvent as k, type EnvironmentInfo as l, type ModelCallContext as m, type ModelCallOutput as n, type ProcessorResult as o, type StreamInput as p, type StreamProviderConfig as q, type StreamProviderFactory as r, type StreamProviderInput as s, type StreamProviderResult as t };

package/dist/runtime/index.d.ts

@@ -1,13 +1,45 @@
-import { A as AgentEvent } from '../runner-G1wxEgac.js';
+import { A as AgentEvent } from '../runner-DSKaEz3z.js';
 import { T as TokenUsage, M as Message } from '../messages-BYWGn8TY.js';
-import { n as AgentTurnStepCommitSnapshot, t as CreateAgentTurnStepCommitBatchOptions, f as AgentTurnCommitBatch, J as PrepareModelStepOptions, K as PreparedAgentModelStep, S as RunModelStepOptions, a as ProcessorOutput, U as RunToolBatchOptions, V as RunToolBatchResult, C as CommitOutputOptions, r as CommitStepOptions, l as AgentTurnState, p as AgentTurnStepCommitToolResult, o as AgentTurnStepCommitToolCall } from '../types-BWo810L_.js';
-export { b as AgentTurnActiveToolCall, c as AgentTurnBoundaryMetadata, d as AgentTurnBoundarySnapshot, e as AgentTurnCommitApplier, g as AgentTurnCommitOptions, h as AgentTurnEngine, i as AgentTurnEngineOptions, j as AgentTurnPhase, k as AgentTurnResolvedToolCall, m as AgentTurnStateAdvanceOptions, q as AgentTurnStepRuntimeConfig, s as CreateAgentTurnStateOptions, X as advanceAgentTurnState, Z as createAgentTurnEngine, _ as createAgentTurnState, a1 as failAgentTurnState } from '../types-BWo810L_.js';
+import { b as ScopeSnapshot } from '../types-9jGQUjqW.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-CqDZTh4d.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-CqDZTh4d.js';
+import { A as AnyInferenceResult } from '../types-FRpzzg_9.js';
 import { ModelMessage } from 'ai';
-import '../tool-pFAnJc5Y.js';
+import '@ai-sdk/provider-utils';
+import '../tool-Db1Ue-1U.js';
 import 'zod';
-import '../tool-DYp6-cC3.js';
+import '../tool-HUtkiVBx.js';
+import '../types-CHiPh8U2.js';
 import '../types-CQaXbRsS.js';
 
+/**
+ * Doom loop error thrown when repeated tool calls are detected.
+ */
+declare class DoomLoopError extends Error {
+    readonly toolName: string;
+    readonly repeatCount: number;
+    readonly input: unknown;
+    constructor(toolName: string, repeatCount: number, input: unknown);
+}
+
+/**
+ * Context overflow error.
+ */
+declare class ContextOverflowError extends Error {
+    readonly inputTokens: number;
+    readonly limit: number;
+    constructor(inputTokens: number, limit: number);
+}
+
+/**
+ * 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;
 
 /**
@@ -18,7 +50,7 @@ declare function prepareModelStep(options: PrepareModelStepOptions): PreparedAge
 /**
  * Execute exactly one model/tool step and stream its events.
  */
-declare function runModelStep(options: RunModelStepOptions): AsyncGenerator<AgentEvent, ProcessorOutput>;
+declare function runModelStep(options: RunModelStepOptions): AsyncGenerator<AgentEvent, StepProcessingOutput>;
 
 /**
  * Execute planned tool calls outside the AI SDK loop.
@@ -82,6 +114,7 @@ interface AgentTaskExecutionRun<TPayload extends AgentTaskPayload = AgentTaskPay
     context: Readonly<AgentTaskExecutionContext>;
     sessionId: string;
     startedAt: string;
+    scope?: ScopeSnapshot;
 }
 interface AgentTaskExecutionSnapshot {
     sessionId: string;
@@ -98,6 +131,7 @@ interface AgentTaskExecutionSnapshot {
     startedAt: string;
     updatedAt: string;
     turnState: AgentTurnState;
+    scope?: ScopeSnapshot;
 }
 interface AgentTaskExecutionCheckpoint<TPayload extends AgentTaskPayload = AgentTaskPayload> {
     run: AgentTaskExecutionRun<TPayload>;
@@ -354,4 +388,4 @@ declare function failAgentWorkflowTurnState(state: AgentWorkflowTurnState, error
  */
 declare function convertAgentMessagesToModelMessages(messages: Message[]): ModelMessage[];
 
-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, CreateAgentTurnStepCommitBatchOptions, type CreateAgentWorkflowTurnStateOptions, PrepareModelStepOptions, PreparedAgentModelStep, RunModelStepOptions, RunToolBatchOptions, RunToolBatchResult, applyAgentWorkflowCommitResult, applyAgentWorkflowModelStepResult, applyAgentWorkflowToolBatchResult, applyAgentWorkflowToolCallResult, cloneAgentWorkflowTurnState, commitOutput, commitStep, convertAgentMessagesToModelMessages, createAgentTaskRunner, createAgentTurnStepCommitBatch, createAgentWorkflowTurnState, defaultAgentTaskCheckpointStrategy, failAgentWorkflowTurnState, planNextAgentWorkflowOperation, prepareModelStep, 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 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 };

package/dist/runtime/index.js

@@ -1,5 +1,7 @@
 import {
   AgentTurnEngine,
+  ContextOverflowError,
+  DoomLoopError,
   advanceAgentTurnState,
   applyAgentWorkflowCommitResult,
   applyAgentWorkflowModelStepResult,
@@ -19,6 +21,8 @@ import {
   failAgentWorkflowTurnState,
   planNextAgentWorkflowOperation,
   prepareModelStep,
+  processStepStream,
+  processStream,
   recordAgentWorkflowReplayDecision,
   restoreAgentWorkflowMessage,
   restoreAgentWorkflowMessages,
@@ -26,15 +30,18 @@ import {
   runToolBatch,
   snapshotAgentWorkflowMessage,
   snapshotAgentWorkflowMessages
-} from "../chunk-3C4VKG4P.js";
-import "../chunk-FG4MD5MU.js";
+} from "../chunk-3HNO5SVI.js";
+import "../chunk-BNSHUWCV.js";
+import "../chunk-5K7AQVOU.js";
+import "../chunk-ZPMACVZK.js";
+import "../chunk-IEFIQENH.js";
+import "../chunk-N7P4PN3O.js";
 import "../chunk-VEKUXUVF.js";
-import "../chunk-QAQADS4X.js";
-import "../chunk-X635CM2F.js";
-import "../chunk-QWFMX226.js";
-import "../chunk-DWYX7ASF.js";
+import "../chunk-QGOGIP7T.js";
 export {
   AgentTurnEngine,
+  ContextOverflowError,
+  DoomLoopError,
   advanceAgentTurnState,
   applyAgentWorkflowCommitResult,
   applyAgentWorkflowModelStepResult,
@@ -54,6 +61,8 @@ export {
   failAgentWorkflowTurnState,
   planNextAgentWorkflowOperation,
   prepareModelStep,
+  processStepStream,
+  processStream,
   recordAgentWorkflowReplayDecision,
   restoreAgentWorkflowMessage,
   restoreAgentWorkflowMessages,

package/dist/scope/index.d.ts

@@ -0,0 +1,10 @@
+import { S as ScopeOptions, a as Scope, b as ScopeSnapshot } from '../types-9jGQUjqW.js';
+export { c as ScopeAttributeValue, d as ScopeAttributes, e as ScopeKind } from '../types-9jGQUjqW.js';
+
+declare function currentScope(): Scope | undefined;
+declare function snapshotScope(scope?: Scope | undefined): ScopeSnapshot | undefined;
+declare function createScope(options: ScopeOptions): Scope;
+declare function withinScope<T>(options: ScopeOptions, fn: () => T | Promise<T>): Promise<T>;
+declare function restoreScope<T>(snapshot: ScopeSnapshot | undefined, fn: () => T | Promise<T>): Promise<T>;
+
+export { Scope, ScopeOptions, ScopeSnapshot, createScope, currentScope, restoreScope, snapshotScope, withinScope };

package/dist/scope/index.js

@@ -0,0 +1,14 @@
+import {
+  createScope,
+  currentScope,
+  restoreScope,
+  snapshotScope,
+  withinScope
+} from "../chunk-N7P4PN3O.js";
+export {
+  createScope,
+  currentScope,
+  restoreScope,
+  snapshotScope,
+  withinScope
+};