@cuylabs/agent-core 0.8.0 → 0.9.0

package/dist/plugin/index.d.ts

@@ -0,0 +1,414 @@
+import { A as AgentMiddleware, c as PromptSection } from '../types-DTSkxakL.js';
+import { T as Tool } from '../tool-CZWN3KbO.js';
+import { ZodType } from 'zod';
+import { Jiti } from 'jiti';
+import 'ai';
+import '@ai-sdk/provider-utils';
+import '../events-CE72w8W4.js';
+import '../messages-BYWGn8TY.js';
+import '../types-BfNpU8NS.js';
+import '../types-CQL-SvTn.js';
+import '../tool-DkhSCV2Y.js';
+import '../types-CHiPh8U2.js';
+import '../types-CQaXbRsS.js';
+
+/**
+ * PluginEventBus — string-keyed pub/sub for inter-plugin communication.
+ *
+ * Channel names are namespaced by convention:
+ * "finance:transaction-created", "crm:contact-updated".
+ */
+/** Remove a previously registered listener. */
+type PluginUnsubscribe = () => void;
+/** Listener function for a specific channel. */
+type PluginEventHandler = (data: unknown) => void;
+/**
+ * Minimal event bus interface. Plugins depend only on this.
+ */
+interface PluginEventBusAPI {
+    emit(channel: string, data: unknown): void;
+    on(channel: string, handler: PluginEventHandler): PluginUnsubscribe;
+}
+/**
+ * In-process event bus. Dispatches synchronously.
+ * Listener errors are caught silently.
+ */
+declare class PluginEventBus implements PluginEventBusAPI {
+    private readonly channels;
+    emit(channel: string, data: unknown): void;
+    on(channel: string, handler: PluginEventHandler): PluginUnsubscribe;
+    /** Number of active channels. */
+    get size(): number;
+    /** Remove all listeners. */
+    clear(): void;
+}
+
+/**
+ * Plugin types — contracts for the extension system.
+ *
+ * Plugins contribute tools, middleware, commands, prompt sections,
+ * and lifecycle hooks to an agent without coupling to a specific host.
+ */
+
+/** Static metadata about a plugin (from package.json or inline). */
+interface PluginCompatibility {
+    /** Expected plugin API version supported by the host (exact match). */
+    apiVersion?: string;
+    /** Supported Node.js version range (supports exact or comparator syntax). */
+    node?: string;
+}
+interface PluginManifest {
+    /** Unique plugin identifier (e.g. "brave-search", "finance") */
+    id: string;
+    /** Human-readable display name */
+    name?: string;
+    /** Short description */
+    description?: string;
+    /** SemVer string */
+    version?: string;
+    /** Compatibility requirements validated by the host at load time. */
+    compatibility?: PluginCompatibility;
+}
+/** A user-facing command registered by a plugin. Host-dependent surfacing. */
+interface PluginCommand {
+    /** Command name (without leading slash) */
+    name: string;
+    /** Optional aliases */
+    alias?: string[];
+    /** One-line description shown in help */
+    summary: string;
+    /** Execute the command. Return the text to display, or null for silent. */
+    execute: (args: string) => Promise<string | null>;
+}
+type PluginSettingsSchema<T = unknown> = ZodType<T>;
+interface PluginSettingsDefinition<T = unknown> {
+    /** Settings namespace. Defaults to the plugin ID. */
+    namespace?: string;
+    /** Whether missing settings are allowed. Defaults to true. */
+    optional?: boolean;
+    /** Zod schema used to validate the resolved settings object. */
+    schema: PluginSettingsSchema<T>;
+}
+/** Namespace-isolated config access. The host injects the implementation. */
+interface PluginSettingsProvider {
+    /**
+     * Read the config value for a given namespace.
+     *
+     * @param namespace  Plugin's config key (e.g. "brave-search")
+     * @returns The config object, or undefined if not configured.
+     */
+    get<T = unknown>(namespace: string): T | undefined;
+    /**
+     * Read and validate a namespace with a schema.
+     *
+     * Returns undefined when the namespace is not configured.
+     */
+    parse<T>(namespace: string, schema: PluginSettingsSchema<T>): T | undefined;
+    /**
+     * Read and validate a namespace with a schema.
+     *
+     * Throws when the namespace is missing or invalid.
+     */
+    require<T>(namespace: string, schema: PluginSettingsSchema<T>): T;
+}
+/** Session lifecycle hooks a plugin can register. */
+interface PluginLifecycleHooks {
+    activate?: (ctx: PluginSessionContext) => Promise<void> | void;
+    deactivate?: () => Promise<void> | void;
+}
+/** Context available during plugin activation. */
+interface PluginSessionContext {
+    /** Agent's working directory */
+    cwd: string;
+    /** Session ID (if session-based) */
+    sessionId?: string;
+}
+/** The API surface passed to a plugin's entry function. */
+interface PluginContext {
+    /** Working directory of the agent (project root) */
+    cwd: string;
+    /** Plugin's own manifest (id, name, version). Read-only. */
+    manifest: Readonly<PluginManifest>;
+    /** Register a tool the LLM can call */
+    addTool(tool: Tool.AnyInfo): void;
+    /** Register middleware (model hooks, tool guards, prompt sections) */
+    addMiddleware(mw: AgentMiddleware): void;
+    /** Register a user-facing command (host-dependent) */
+    addCommand(cmd: PluginCommand): void;
+    /** Add a dynamic prompt section injected at system-prompt build time. */
+    addPromptSection(section: PromptSection): void;
+    /** Inter-plugin event bus (string-keyed pub/sub). */
+    events: PluginEventBus;
+    /** Plugin-namespaced settings from the host. */
+    settings: PluginSettingsProvider;
+    /** Register an activation hook (fires when the agent session starts). */
+    onActivate(fn: (ctx: PluginSessionContext) => Promise<void> | void): void;
+    /** Register a deactivation hook (fires when the agent session ends). */
+    onDeactivate(fn: () => Promise<void> | void): void;
+}
+/** The function shape a plugin file must default-export. */
+type PluginInit = (ctx: PluginContext) => void | Promise<void>;
+/** Aggregated contributions from all loaded plugins. */
+interface PluginContributions {
+    /** Tools to add to the agent's tool set */
+    tools: Tool.AnyInfo[];
+    /** Middleware to prepend to the agent's middleware stack */
+    middleware: AgentMiddleware[];
+    /** User-facing commands (host-dependent surfacing) */
+    commands: PluginCommand[];
+    /** Dynamic prompt sections */
+    promptSections: PromptSection[];
+    /** Loader / plugin errors (non-fatal — the rest of the system keeps working) */
+    errors: Array<{
+        pluginId: string;
+        error: string;
+    }>;
+}
+
+/**
+ * Plugin settings — namespace-isolated layered configuration.
+ */
+
+/** Settings provider that always returns undefined. */
+declare class NullSettings implements PluginSettingsProvider {
+    get<T = unknown>(_namespace: string): T | undefined;
+    parse<T>(_namespace: string, _schema: PluginSettingsSchema<T>): T | undefined;
+    require<T>(namespace: string, _schema: PluginSettingsSchema<T>): T;
+}
+/** Settings provider backed by a plain object. Top-level keys are plugin namespaces. */
+declare class StaticSettings implements PluginSettingsProvider {
+    private readonly data;
+    constructor(data: Record<string, unknown>);
+    get<T = unknown>(namespace: string): T | undefined;
+    parse<T>(namespace: string, schema: PluginSettingsSchema<T>): T | undefined;
+    require<T>(namespace: string, schema: PluginSettingsSchema<T>): T;
+}
+/** Merges multiple settings sources in priority order (later layers win). */
+declare class LayeredSettings implements PluginSettingsProvider {
+    private readonly layers;
+    constructor(layers: PluginSettingsProvider[]);
+    get<T = unknown>(namespace: string): T | undefined;
+    parse<T>(namespace: string, schema: PluginSettingsSchema<T>): T | undefined;
+    require<T>(namespace: string, schema: PluginSettingsSchema<T>): T;
+}
+/** Wraps a provider with validated overrides for specific namespaces. */
+declare class ValidatedSettings implements PluginSettingsProvider {
+    private readonly base;
+    private readonly overrides;
+    constructor(base: PluginSettingsProvider, overrides: Record<string, unknown>);
+    get<T = unknown>(namespace: string): T | undefined;
+    parse<T>(namespace: string, schema: PluginSettingsSchema<T>): T | undefined;
+    require<T>(namespace: string, schema: PluginSettingsSchema<T>): T;
+}
+
+/**
+ * Plugin loader — filesystem discovery and dynamic import via jiti.
+ *
+ * Scans `.cuylabs/plugins/` and explicit paths for plugin entries.
+ * Files starting with `_` are ignored. Each plugin must default-export
+ * a PluginInit function.
+ *
+ * Uses jiti for TypeScript-native loading — users drop raw `.ts` files
+ * and they work without a build step. Transpiled output is cached to
+ * disk for fast subsequent loads.
+ *
+ * Framework packages (`@cuylabs/*`) are auto-aliased so plugins can
+ * `import { ... } from "@cuylabs/agent-core"` without any user config.
+ * Resolution uses `import.meta.resolve` (ESM standard) with a monorepo
+ * workspace fallback for development.
+ */
+
+/** Options for configuring the plugin loader's jiti instance. */
+interface PluginLoaderOptions {
+    /** Extra module aliases (e.g. `{ "@my-lib": "./src/lib" }`). */
+    alias?: Record<string, string>;
+    /** Modules to skip transforming (already compiled). */
+    nativeModules?: string[];
+    /** Enable source maps in error stacks (default: true). */
+    sourceMaps?: boolean;
+    /** Enable jiti debug logging (default: false). */
+    debug?: boolean;
+    /**
+     * Disable automatic `@cuylabs/*` alias resolution.
+     * When false, plugins must resolve framework packages on their own.
+     * @default true
+     */
+    autoAlias?: boolean;
+}
+/**
+ * Auto-resolve `@cuylabs/*` packages to their filesystem paths.
+ *
+ * Uses two strategies in order:
+ * 1. `import.meta.resolve(specifier)` — standard ESM resolution.
+ *    Works when packages are in node_modules (installed via npm/pnpm).
+ * 2. Monorepo workspace fallback — walk up from this file to find
+ *    the workspace root, then check `packages/<name>/dist/index.js`.
+ *
+ * Results are cached for the process lifetime.
+ */
+declare function resolveFrameworkAliases(): Record<string, string>;
+/** Reset cached framework aliases (for testing). */
+declare function resetFrameworkAliases(): void;
+/** Get or create a shared jiti instance for plugin loading. */
+declare function getPluginLoader(options?: PluginLoaderOptions): Jiti;
+/** Reset the shared jiti instance (for testing). */
+declare function resetPluginLoader(): void;
+/** A discovered plugin file with its resolved entry path and manifest. */
+interface DiscoveredPlugin {
+    entryPath: string;
+    manifest: PluginManifest;
+}
+/** Discover plugin files on disk from convention dir and explicit paths. */
+declare function discoverPlugins(cwd: string, extraPaths?: string[]): Promise<DiscoveredPlugin[]>;
+/** Dynamically import a plugin file and extract its init function. */
+declare function loadPluginModule(entryPath: string, options?: PluginLoaderOptions): Promise<PluginInit>;
+
+/**
+ * Declarative plugin authoring — `definePlugin()`.
+ *
+ * Converts a static plugin definition into a `PluginInit` function.
+ * The registry and imperative layer stay unchanged; this is sugar
+ * that makes plugins inspectable, type-safe, and easier to author.
+ */
+
+/** Declarative plugin definition passed to `definePlugin()`. */
+interface PluginDefinition {
+    /** Unique plugin identifier. */
+    id: string;
+    /** Human-readable display name. */
+    name?: string;
+    /** Short description. */
+    description?: string;
+    /** SemVer string. */
+    version?: string;
+    /** Host/runtime compatibility validated before the plugin is committed. */
+    compatibility?: PluginCompatibility;
+    /** Optional settings schema to validate before the plugin is committed. */
+    settings?: PluginSettingsDefinition;
+    /** Tools the LLM can call. Statically declared — inspectable without execution. */
+    tools?: Tool.AnyInfo[];
+    /** Middleware hooks (model I/O, tool guards, prompt sections). */
+    middleware?: AgentMiddleware[];
+    /** User-facing commands. */
+    commands?: PluginCommand[];
+    /** Dynamic prompt sections injected at system-prompt build time. */
+    promptSections?: PromptSection[];
+    /**
+     * Imperative activation hook — runs when the agent session starts.
+     * Use for dynamic setup that can't be expressed declaratively
+     * (starting servers, loading config, managing state).
+     */
+    activate?: (ctx: PluginActivateContext) => Promise<void> | void;
+    /**
+     * Imperative deactivation hook — runs when the agent session ends.
+     */
+    deactivate?: () => Promise<void> | void;
+    /**
+     * Full imperative escape hatch — runs during plugin loading.
+     * Receives the raw PluginContext for anything the declarative
+     * fields can't express. Runs after all declarative contributions
+     * have been registered.
+     */
+    setup?: (ctx: PluginContext) => void | Promise<void>;
+}
+/** Context passed to the declarative `activate` hook. */
+interface PluginActivateContext extends PluginSessionContext {
+    /** The plugin's own event bus. */
+    events: PluginContext["events"];
+    /** The plugin's settings provider. */
+    settings: PluginContext["settings"];
+}
+/**
+ * Create a plugin from a declarative definition.
+ *
+ * Returns a `PluginInit` function that the registry executes normally.
+ * The definition object is attached as `init.__definition` so the
+ * registry can inspect it without running the plugin.
+ */
+declare function definePlugin(def: PluginDefinition): PluginInit;
+/** A PluginInit created by `definePlugin()` — carries the static definition. */
+interface DefinePluginInit extends PluginInit {
+    __definition: PluginDefinition;
+}
+/** Type guard: check if a PluginInit was created by `definePlugin()`. */
+declare function isDefinedPlugin(init: PluginInit): init is DefinePluginInit;
+
+/**
+ * PluginRegistry — orchestrates the full plugin lifecycle.
+ *
+ * `loadAll` → `activate` → (agent runs) → `deactivate`.
+ * Owns the shared PluginEventBus and wires isolated PluginContext per plugin.
+ */
+
+interface PluginRegistryCompatibilityOptions {
+    /** Supported plugin API version (exact match). */
+    apiVersion?: string;
+    /** Runtime Node.js version. Defaults to the current process version. */
+    nodeVersion?: string;
+}
+interface PluginRegistryTimeoutOptions {
+    /** Maximum time allowed for a plugin init function. */
+    load?: number | false;
+    /** Maximum time allowed per activation hook. */
+    activate?: number | false;
+    /** Maximum time allowed per deactivation hook. */
+    deactivate?: number | false;
+}
+interface PluginRegistryOptions {
+    /** Settings provider. Defaults to NullSettings (no config). */
+    settings?: PluginSettingsProvider;
+    /** Shared event bus. A fresh one is created if omitted. */
+    events?: PluginEventBus;
+    /** Options for the jiti-powered plugin loader. */
+    loader?: PluginLoaderOptions;
+    /** Host compatibility context used to reject incompatible plugins. */
+    compatibility?: PluginRegistryCompatibilityOptions;
+    /** Timeouts applied to init and lifecycle hooks. */
+    timeouts?: PluginRegistryTimeoutOptions;
+}
+declare class PluginRegistry {
+    private readonly settings;
+    private readonly eventBus;
+    private readonly loaderOptions;
+    private readonly compatibilityContext;
+    private readonly timeouts;
+    private readonly plugins;
+    private readonly pluginIds;
+    private readonly commandOwners;
+    private readonly commandTokens;
+    private readonly _contributions;
+    private activated;
+    private activeSessionContext?;
+    constructor(options?: PluginRegistryOptions);
+    /** The shared event bus wired to all loaded plugins. */
+    get events(): PluginEventBus;
+    /** Read-only view of everything plugins have contributed. */
+    get contributions(): Readonly<PluginContributions>;
+    /** Number of successfully loaded plugins. */
+    get pluginCount(): number;
+    /** Get the static definition for a plugin (if it used `definePlugin()`). */
+    getDefinition(pluginId: string): PluginDefinition | undefined;
+    /** Get all static definitions (only for declarative plugins). */
+    get definitions(): ReadonlyArray<Readonly<PluginDefinition>>;
+    /** Get the plugin ID that contributed a command. */
+    getCommandOwner(command: PluginCommand): string | undefined;
+    /** Record a host-level plugin error without throwing. */
+    recordError(pluginId: string, error: string): void;
+    /** Discover, load, and execute all plugins. */
+    loadAll(cwd: string, extraPaths?: string[]): Promise<void>;
+    /** Load a single plugin from its init function (programmatic / tests). */
+    loadOne(init: PluginInit, manifest: PluginManifest, cwd: string, entryPath?: string): Promise<void>;
+    /** Fire `onActivate` hooks sequentially in load order. */
+    activate(ctx: PluginSessionContext): Promise<void>;
+    /** Fire `onDeactivate` hooks in reverse load order. */
+    deactivate(): Promise<void>;
+    private executePlugin;
+    private resolvePluginSettings;
+    private findCommandConflict;
+    private checkCommandTokenConflict;
+    private commitPlugin;
+    private runActivateHooks;
+    private runDeactivateHooks;
+}
+
+export { type DefinePluginInit, type DiscoveredPlugin, LayeredSettings, NullSettings, type PluginActivateContext, type PluginCommand, type PluginCompatibility, type PluginContext, type PluginContributions, type PluginDefinition, PluginEventBus, type PluginEventBusAPI, type PluginEventHandler, type PluginInit, type PluginLifecycleHooks, type PluginLoaderOptions, type PluginManifest, PluginRegistry, type PluginRegistryCompatibilityOptions, type PluginRegistryOptions, type PluginRegistryTimeoutOptions, type PluginSessionContext, type PluginSettingsDefinition, type PluginSettingsProvider, type PluginSettingsSchema, type PluginUnsubscribe, StaticSettings, ValidatedSettings, definePlugin, discoverPlugins, getPluginLoader, isDefinedPlugin, loadPluginModule, resetFrameworkAliases, resetPluginLoader, resolveFrameworkAliases };

package/dist/plugin/index.js

@@ -0,0 +1,32 @@
+import {
+  LayeredSettings,
+  NullSettings,
+  PluginEventBus,
+  PluginRegistry,
+  StaticSettings,
+  ValidatedSettings,
+  definePlugin,
+  discoverPlugins,
+  getPluginLoader,
+  isDefinedPlugin,
+  loadPluginModule,
+  resetFrameworkAliases,
+  resetPluginLoader,
+  resolveFrameworkAliases
+} from "../chunk-WGZAPU6N.js";
+export {
+  LayeredSettings,
+  NullSettings,
+  PluginEventBus,
+  PluginRegistry,
+  StaticSettings,
+  ValidatedSettings,
+  definePlugin,
+  discoverPlugins,
+  getPluginLoader,
+  isDefinedPlugin,
+  loadPluginModule,
+  resetFrameworkAliases,
+  resetPluginLoader,
+  resolveFrameworkAliases
+};

package/dist/presets/index.d.ts

@@ -1,9 +1,9 @@
-import { P as Preset, A as AppliedPreset } from '../types-BnpEOYV-.js';
-import { T as Tool } from '../tool-BHbyUAy3.js';
+import { P as Preset, A as AppliedPreset } from '../types-BlZwmnuW.js';
+import { T as Tool } from '../tool-CZWN3KbO.js';
 import 'ai';
 import '../types-CQaXbRsS.js';
 import 'zod';
-import '../tool-DLXAR9Ce.js';
+import '../tool-DkhSCV2Y.js';
 import '../types-CHiPh8U2.js';
 import '../types-CQL-SvTn.js';
 

package/dist/presets/index.js

@@ -1,17 +1,19 @@
 import {
-  Presets,
   applyPreset,
+  createPreset,
+  filterTools,
+  mergePresets
+} from "../chunk-IYWQOJMQ.js";
+import {
+  Presets,
   careful,
   code,
-  createPreset,
   explore,
-  filterTools,
-  mergePresets,
   plan,
   quick,
   review,
   watch
-} from "../chunk-CAA7FHIH.js";
+} from "../chunk-EKR6PKXU.js";
 export {
   Presets,
   applyPreset,

package/dist/prompt/index.d.ts

@@ -1,18 +1,19 @@
-import { c as ModelFamily, g as EnvironmentInfo, I as InstructionFile } from '../runner-e2YRcUoX.js';
-export { a as PromptBuildContext, P as PromptConfig, b as PromptSection } from '../runner-e2YRcUoX.js';
+import { e as ModelFamily, h as EnvironmentInfo, I as InstructionFile } from '../types-DTSkxakL.js';
+export { P as PromptBuildContext, d as PromptConfig, c as PromptSection } from '../types-DTSkxakL.js';
 import { LanguageModel } from 'ai';
-export { P as PromptBuilder, c as createPromptBuilder } from '../builder-UpOWQMW3.js';
+export { P as PromptBuilder, c as createPromptBuilder } from '../builder-BgZ_j4Vs.js';
 export { d as SkillConfig } from '../types-BfNpU8NS.js';
 import '@ai-sdk/provider-utils';
 import '../events-CE72w8W4.js';
 import '../messages-BYWGn8TY.js';
 import '../types-CQL-SvTn.js';
-import '../tool-DLXAR9Ce.js';
+import '../tool-DkhSCV2Y.js';
 import '../types-CHiPh8U2.js';
-import '../tool-BHbyUAy3.js';
+import '../tool-CZWN3KbO.js';
 import 'zod';
 import '../types-CQaXbRsS.js';
 import '../registry-DwYqsQkX.js';
+import '../runner-CI-XeR16.js';
 
 /**
  * Prompt Templates — Base system prompts per model family

package/dist/prompt/index.js

@@ -19,8 +19,9 @@ import {
   getTemplate,
   loadGlobalInstructions,
   summarizeEnvironment
-} from "../chunk-IVUJDISU.js";
-import "../chunk-LRHOS4ZN.js";
+} from "../chunk-GFTW23FV.js";
+import "../chunk-SPILYYDF.js";
+import "../chunk-I6PKJ7XQ.js";
 export {
   DEFAULT_INSTRUCTION_PATTERNS,
   DEFAULT_MAX_DEPTH,

package/dist/runner-CI-XeR16.d.ts

@@ -0,0 +1,91 @@
+import { A as AgentMiddleware, M as ModelCallInput, a as ModelCallContext, B as BlockedModelCall, S as StreamChunk, b as ModelCallOutput, T as ToolCallDecision, P as PromptBuildContext, c as PromptSection } from './types-DTSkxakL.js';
+import { A as AgentEvent } from './events-CE72w8W4.js';
+import { T as TokenUsage } from './messages-BYWGn8TY.js';
+import { T as ToolContext } from './tool-DkhSCV2Y.js';
+import { T as Tool } from './tool-CZWN3KbO.js';
+
+/**
+ * Middleware Runner
+ *
+ * Executes middleware hooks in the correct order with proper
+ * error handling and short-circuit semantics.
+ *
+ * This is the internal engine — consumers never see it.
+ * They interact with middleware through AgentConfig.middleware.
+ */
+
+/**
+ * Middleware runner — holds an ordered list of middleware and
+ * exposes methods to run each hook type with correct semantics.
+ *
+ * Immutable after construction. Fork creates a new runner
+ * (with inherited + additional middleware).
+ */
+declare class MiddlewareRunner {
+    private readonly stack;
+    constructor(middleware?: AgentMiddleware[]);
+    /** Number of registered middleware */
+    get count(): number;
+    /** Whether any middleware is registered */
+    get hasMiddleware(): boolean;
+    /** Get the middleware list (for fork inheritance) */
+    getMiddleware(): readonly AgentMiddleware[];
+    runModelInput(input: ModelCallInput, ctx: ModelCallContext): Promise<ModelCallInput | BlockedModelCall>;
+    runModelChunk(chunk: StreamChunk, ctx: ModelCallContext): Promise<StreamChunk | undefined>;
+    runModelOutput(output: ModelCallOutput, ctx: ModelCallContext): Promise<ModelCallOutput>;
+    /**
+     * Run all `beforeToolCall` hooks in order.
+     *
+     * Returns `{ action: "allow" }` if all middleware allow (or have no hook).
+     * Returns `{ action: "deny", reason }` on first denial — remaining
+     * middleware are skipped.
+     */
+    runBeforeToolCall(tool: string, args: unknown, ctx: ToolContext): Promise<ToolCallDecision>;
+    /**
+     * Run all `afterToolCall` hooks in reverse order.
+     *
+     * Each hook receives the result from the previous hook (or the
+     * original tool result for the first hook). Errors are caught
+     * and logged — the original result passes through.
+     */
+    runAfterToolCall(tool: string, args: unknown, result: Tool.ExecuteResult, ctx: ToolContext): Promise<Tool.ExecuteResult>;
+    /**
+     * Collect prompt sections from all middleware.
+     *
+     * Returns a flat array of sections. Each middleware can return a single
+     * section, an array of sections, or undefined/empty.
+     */
+    collectPromptSections(ctx: PromptBuildContext): PromptSection[];
+    /**
+     * Broadcast an event to all middleware observers.
+     *
+     * Non-blocking — errors are caught and logged. This never
+     * slows down the streaming pipeline.
+     */
+    emitEvent(event: AgentEvent): void;
+    /**
+     * Get the OTel context for a session from the telemetry middleware.
+     * Returns undefined if no telemetry middleware is registered.
+     */
+    getOtelContext(sessionId: string): unknown | undefined;
+    /**
+     * Run all `onChatStart` hooks in order.
+     *
+     * Errors are caught and logged — a broken logger should not
+     * prevent the chat from starting.
+     */
+    runChatStart(sessionId: string, message: string): Promise<void>;
+    /**
+     * Run all `onChatEnd` hooks in order.
+     *
+     * Always called, even when the stream errored. Errors in handlers
+     * are caught and logged.
+     */
+    runChatEnd(sessionId: string, result: {
+        usage?: TokenUsage;
+        error?: Error;
+        output?: string;
+    }): Promise<void>;
+}
+
+export { MiddlewareRunner as M };

package/dist/runtime/index.d.ts

@@ -1,15 +1,16 @@
 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 { 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-DmDwi2zI.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-DmDwi2zI.js';
+import { A as AnyInferenceResult } from '../types-BlOKk-Bb.js';
 import { ModelMessage } from 'ai';
-import '../tool-BHbyUAy3.js';
+import '../tool-CZWN3KbO.js';
 import 'zod';
-import '../tool-DLXAR9Ce.js';
+import '../tool-DkhSCV2Y.js';
 import '../types-CHiPh8U2.js';
-import '../runner-e2YRcUoX.js';
+import '../runner-CI-XeR16.js';
+import '../types-DTSkxakL.js';
 import '@ai-sdk/provider-utils';
 import '../types-BfNpU8NS.js';
 import '../types-CQaXbRsS.js';

package/dist/runtime/index.js

@@ -30,16 +30,15 @@ import {
   runToolBatch,
   snapshotAgentWorkflowMessage,
   snapshotAgentWorkflowMessages
-} from "../chunk-4BDA7DQY.js";
+} from "../chunk-J4QDGZIA.js";
 import "../chunk-WWYYNWEW.js";
-import "../chunk-N6HWIEEA.js";
-import "../chunk-7VKQ4WPB.js";
+import "../chunk-WKHDSSXG.js";
+import "../chunk-H3FUYU52.js";
 import "../chunk-VEKUXUVF.js";
-import "../chunk-SQU2AJHO.js";
+import "../chunk-4QFNWPIF.js";
 import "../chunk-N7P4PN3O.js";
-import "../chunk-RZITT45F.js";
-import "../chunk-RFEKJKTO.js";
-import "../chunk-DWYX7ASF.js";
+import "../chunk-UDCZ673N.js";
+import "../chunk-I6PKJ7XQ.js";
 export {
   AgentTurnEngine,
   ContextOverflowError,

package/dist/safety/index.d.ts

@@ -28,7 +28,7 @@ declare class ApprovalTimeoutError extends Error {
  */
 declare function createApprovalHandler(config?: ApprovalConfig): {
     request: (sessionId: string, tool: string, args: unknown, customRisks?: Record<string, RiskLevel>) => Promise<void>;
-    cancelAll: (reason?: string) => void;
+    cancelAll: (_reason?: string) => void;
     addRule: (rule: ApprovalRule) => void;
     getRules: () => readonly ApprovalRule[];
     clearSessionRules: () => void;