agentfootprint 1.22.0 → 2.0.1

package/dist/types/core/RunnerBase.d.ts

@@ -0,0 +1,95 @@
+/**
+ * RunnerBase — shared implementation of the Runner interface.
+ *
+ * Pattern: Template Method (GoF). Subclasses override `buildChart()` and
+ *          optionally `onBeforeRun()` / `onAfterRun()`; the base handles
+ *          dispatcher, recorder attachment, custom emit, and subscription.
+ * Role:    Base class for LLMCall, Agent, Sequence, Parallel, Conditional, Loop.
+ * Emits:   Nothing directly — its attached recorders do.
+ */
+import type { CombinedRecorder, FlowChart, FlowChartExecutor, FlowchartCheckpoint, RunOptions } from 'footprintjs';
+import { EventDispatcher } from '../events/dispatcher.js';
+import type { RunnerPauseOutcome } from './pause.js';
+import type { EventListener, ListenOptions, Unsubscribe, WildcardListener, WildcardSubscription } from '../events/dispatcher.js';
+import type { AgentfootprintEventType } from '../events/registry.js';
+import type { EventMeta } from '../events/types.js';
+import type { EnableNamespace, Runner } from './runner.js';
+/**
+ * Make a unique run id. Exported for tests; internal use normally.
+ */
+export declare function makeRunId(): string;
+export declare abstract class RunnerBase<TIn = unknown, TOut = unknown> implements Runner<TIn, TOut> {
+    protected readonly dispatcher: EventDispatcher;
+    protected readonly attachedRecorders: CombinedRecorder[];
+    /**
+     * Build the footprintjs FlowChart for this runner. Subclass supplies
+     * its specific structure (slot subflows, callLLM stage, routing, etc.).
+     */
+    abstract toFlowChart(): FlowChart;
+    /**
+     * Execute the runner. Subclass may override for specialized input
+     * mapping, but default invokes toFlowChart() + FlowChartExecutor.
+     */
+    abstract run(input: TIn, options?: RunOptions): Promise<TOut | RunnerPauseOutcome>;
+    /**
+     * Resume a paused run from its checkpoint. Default behavior: rebuild the
+     * chart, wire the same core recorders + consumer recorders, call
+     * `executor.resume(checkpoint, input)`, and emit `pause.resume` before
+     * returning. Subclass overrides only if it needs specialized behavior.
+     */
+    abstract resume(checkpoint: FlowchartCheckpoint, input?: unknown, options?: RunOptions): Promise<TOut | RunnerPauseOutcome>;
+    /**
+     * Inspect an executor result. On pause, emits `pause.request` and returns
+     * a `RunnerPauseOutcome`. Otherwise returns `undefined` and the subclass
+     * continues its normal result-shape handling (string vs BranchResults vs
+     * Error).
+     *
+     * Subclasses call this BEFORE their own type checks, so pause is never
+     * misinterpreted as "unexpected result shape".
+     */
+    protected detectPause(executor: FlowChartExecutor, result: unknown): RunnerPauseOutcome | undefined;
+    /**
+     * Emit `agentfootprint.pause.request` through the dispatcher. Called by
+     * `detectPause()`. Subclasses should not emit this directly.
+     */
+    private emitPauseRequest;
+    /**
+     * Emit `agentfootprint.pause.resume` through the dispatcher. Called from
+     * concrete runners' `resume()` BEFORE invoking `executor.resume()`.
+     */
+    protected emitPauseResume(checkpoint: FlowchartCheckpoint, input: unknown): void;
+    on<K extends AgentfootprintEventType>(type: K, listener: EventListener<K>, options?: ListenOptions): Unsubscribe;
+    on(type: WildcardSubscription, listener: WildcardListener, options?: ListenOptions): Unsubscribe;
+    off<K extends AgentfootprintEventType>(type: K, listener: EventListener<K>): void;
+    off(type: WildcardSubscription, listener: WildcardListener): void;
+    once<K extends AgentfootprintEventType>(type: K, listener: EventListener<K>): Unsubscribe;
+    once(type: WildcardSubscription, listener: WildcardListener): Unsubscribe;
+    attach(recorder: CombinedRecorder): Unsubscribe;
+    readonly enable: EnableNamespace;
+    /**
+     * Emit a consumer-defined custom event.
+     *
+     * If `name` matches a registered event type, this routes exactly like a
+     * library-emitted event (via the typed EventMap). Otherwise it flows
+     * through to wildcard listeners (`'*'`) as an opaque CustomEvent with
+     * minimal meta. Library events remain reserved under `agentfootprint.*`.
+     */
+    emit(name: string, payload: Record<string, unknown>): void;
+    /**
+     * Build a minimal EventMeta for a consumer-level emit OUTSIDE a stage
+     * context. Real stage code uses `buildEventMeta` with a TraversalContext.
+     */
+    protected minimalMeta(): EventMeta;
+    /**
+     * Composition ancestry for this runner. Subclass may override to append
+     * its own identity (e.g. `'Sequence:bot'`).
+     */
+    protected compositionPath(): readonly string[];
+    /**
+     * Provide access to the internal dispatcher for internal recorders.
+     * NOT part of the public Runner contract — internal recorders (e.g.
+     * ContextRecorder) receive this at construction.
+     */
+    protected getDispatcher(): EventDispatcher;
+}
+//# sourceMappingURL=RunnerBase.d.ts.map

package/dist/types/core/RunnerBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunnerBase.d.ts","sourceRoot":"","sources":["../../../src/core/RunnerBase.ts"],"names":[],"mappings":"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"}

package/dist/types/core/cost.d.ts

@@ -0,0 +1,39 @@
+/**
+ * cost — shared cost-accounting helper emitted by LLMCall + Agent.
+ *
+ * Pattern: Strategy (PricingTable port) + Event emission (typedEmit).
+ * Role:    core/ layer. When a runner is configured with a PricingTable,
+ *          every LLM response drives a `cost.tick` event carrying per-call
+ *          tokens/USD plus cumulative run totals. When a `costBudget` is
+ *          also set, the first crossing emits `cost.limit_hit` with
+ *          `action: 'warn'` (library never auto-aborts; consumers decide).
+ * Emits:   agentfootprint.cost.tick
+ *          agentfootprint.cost.limit_hit
+ */
+import type { PricingTable } from '../adapters/types.js';
+export interface CostAccountingScope {
+    cumTokensInput: number;
+    cumTokensOutput: number;
+    cumEstimatedUsd: number;
+    costBudgetHit: boolean;
+}
+type Usage = {
+    readonly input: number;
+    readonly output: number;
+    readonly cacheRead?: number;
+    readonly cacheWrite?: number;
+};
+/**
+ * Emit `cost.tick` for the just-completed LLM response and, if the
+ * consumer set a `costBudget`, emit a one-shot `cost.limit_hit` the first
+ * time cumulative USD crosses the budget. Does nothing when no
+ * `pricingTable` is configured — zero overhead on runs without costing.
+ *
+ * Scope must carry the running cumulative counters; callers seed them
+ * in their Seed stage.
+ */
+export declare function emitCostTick(scope: CostAccountingScope & {
+    $emit: (name: string, payload?: unknown) => void;
+}, pricingTable: PricingTable | undefined, costBudget: number | undefined, model: string, usage: Usage): void;
+export {};
+//# sourceMappingURL=cost.d.ts.map

package/dist/types/core/cost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost.d.ts","sourceRoot":"","sources":["../../../src/core/cost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,KAAK,KAAK,GAAG;IACX,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,mBAAmB,GAAG;IAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,IAAI,CAAA;CAAE,EACjF,YAAY,EAAE,YAAY,GAAG,SAAS,EACtC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,KAAK,GACX,IAAI,CAuCN"}

package/dist/types/core/pause.d.ts

@@ -0,0 +1,75 @@
+/**
+ * pause — runner-level pause/resume primitives.
+ *
+ * Pattern: Control-flow exception (PauseRequest) + typed outcome (RunnerPauseOutcome).
+ * Role:    core/ layer. Bridges footprintjs.s pause signal into the agentfootprint
+ *          Runner contract: tools call `pauseHere(data)` to raise a pause
+ *          intent; runners detect the paused executor result and return a
+ *          `RunnerPauseOutcome` instead of `TOut`. Consumers call
+ *          `runner.resume(checkpoint, input)` to continue.
+ * Emits:   N/A (types + helpers only). Event emission happens in RunnerBase.
+ *
+ * Why a control-flow "throw": tool.execute(args, ctx) doesn't receive the
+ * typed scope, so it cannot call `scope.$pause()` directly. A thrown
+ * `PauseRequest` is caught inside the Agent's tool-call stage, which then
+ * forwards the pause into the flowchart via `scope.$pause()`. This keeps
+ * the tool API clean (tools are pure-ish) while still supporting pause.
+ */
+import type { FlowchartCheckpoint } from 'footprintjs';
+/**
+ * Outcome returned by `runner.run()` / `runner.resume()` when execution
+ * has paused mid-flow. The shape mirrors footprintjs's `PausedResult` but
+ * surfaces `pauseData` as a first-class field for consumers who don't
+ * want to reach into the checkpoint.
+ */
+export interface RunnerPauseOutcome {
+    readonly paused: true;
+    /** Serializable checkpoint — store anywhere (Redis, Postgres, localStorage). */
+    readonly checkpoint: FlowchartCheckpoint;
+    /** Data passed to `scope.$pause()` / `pauseHere()`. Consumer-typed. */
+    readonly pauseData: unknown;
+}
+/** Type guard — discriminates `RunnerPauseOutcome` from a normal `TOut`. */
+export declare function isPaused<T>(result: T | RunnerPauseOutcome): result is RunnerPauseOutcome;
+/**
+ * Control-flow error raised by `pauseHere()` inside a tool's `execute()`.
+ * Caught by the Agent's tool-call stage, which forwards to `scope.$pause()`.
+ * Never propagates to the consumer.
+ */
+export declare class PauseRequest extends Error {
+    readonly data: unknown;
+    constructor(data: unknown);
+}
+/**
+ * Called from inside a tool's `execute()` to request a pause. Throws a
+ * `PauseRequest` that the Agent catches and forwards to the flowchart.
+ *
+ * @example
+ *   const approveTool: Tool<{ action: string }, string> = {
+ *     schema: { name: 'approve', description: 'Ask human', inputSchema: {...} },
+ *     execute: async (args) => {
+ *       pauseHere({ question: `Approve ${args.action}?`, risk: 'high' });
+ *       return ''; // unreachable — pauseHere always throws
+ *     },
+ *   };
+ */
+export declare function pauseHere(data: unknown): never;
+/** Type guard for a thrown `PauseRequest`. */
+export declare function isPauseRequest(err: unknown): err is PauseRequest;
+/**
+ * Ergonomic alias for `pauseHere(data)` — the human-in-the-loop name.
+ *
+ * `pauseHere` describes the mechanism (control-flow throw); `askHuman`
+ * describes the intent (ask a person to decide). Both work identically.
+ *
+ * @example
+ *   const approveRefund: Tool<{ amount: number }, string> = {
+ *     schema: { name: 'approve_refund', description: '...', inputSchema: {...} },
+ *     execute: async ({ amount }) => {
+ *       if (amount > 1000) askHuman({ question: `Approve $${amount}?` });
+ *       return 'auto-approved';
+ *     },
+ *   };
+ */
+export declare const askHuman: typeof pauseHere;
+//# sourceMappingURL=pause.d.ts.map

package/dist/types/core/pause.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pause.d.ts","sourceRoot":"","sources":["../../../src/core/pause.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,gFAAgF;IAChF,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IACzC,uEAAuE;IACvE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,kBAAkB,GAAG,MAAM,IAAI,kBAAkB,CAIxF;AAED;;;;GAIG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;gBACX,IAAI,EAAE,OAAO;CAO1B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,KAAK,CAE9C;AAED,8CAA8C;AAC9C,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,YAAY,CAOhE;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,QAAQ,kBAAY,CAAC"}

package/dist/types/core/runner.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Runner — consumer-facing interface for every primitive/composition/pattern.
+ *
+ * Pattern: Facade (GoF) over ComposableRunner + EventDispatcher.
+ * Role:    The one object consumers hold. Exposes:
+ *            - `.run()` / `.toFlowChart()` (inherited from footprintjs
+ *              ComposableRunner — composition + execution)
+ *            - `.on() / .off() / .once()` (listener subscription)
+ *            - `.attach()` (attach custom CombinedRecorder)
+ *            - `.emit()` (consumer-defined custom events on the same
+ *              dispatcher, matches DOM CustomEvent)
+ * Emits:   N/A — this file defines the INTERFACE. Concrete runners
+ *          (LLMCall, Agent, Sequence, etc.) implement it.
+ */
+import type { CombinedRecorder, ComposableRunner, FlowchartCheckpoint, RunOptions } from 'footprintjs';
+import type { RunnerPauseOutcome } from './pause.js';
+import type { EventListener, ListenOptions, Unsubscribe, WildcardListener, WildcardSubscription } from '../events/dispatcher.js';
+import type { AgentfootprintEvent, AgentfootprintEventType } from '../events/registry.js';
+import type { LoggingOptions } from '../recorders/observability/LoggingRecorder.js';
+import type { ThinkingOptions } from '../recorders/observability/ThinkingRecorder.js';
+import type { FlowchartHandle, FlowchartOptions } from '../recorders/observability/FlowchartRecorder.js';
+/**
+ * High-level feature-enable methods. Each attaches a pre-built observability
+ * recorder and returns an Unsubscribe function. Additional methods land in
+ * Phase 5 (lens, tracing, cost, guardrails, ...).
+ */
+export interface EnableNamespace {
+    /** Claude-Code-style live status line. */
+    thinking(opts: ThinkingOptions): Unsubscribe;
+    /** Firehose-style structured logging of every event. */
+    logging(opts?: LoggingOptions): Unsubscribe;
+    /**
+     * Live composition graph — subflow / fork-branch / decision-branch
+     * nodes accumulate as execution unfolds. Hook into any graph renderer
+     * (React Flow, Cytoscape, D3) without touching footprintjs internals.
+     *
+     * Unlike thinking/logging which return a plain Unsubscribe, this
+     * returns a handle with `getSnapshot()` so the UI can query the graph
+     * at any time (not just via onUpdate).
+     */
+    flowchart(opts?: FlowchartOptions): FlowchartHandle;
+}
+/**
+ * Every primitive (LLMCall, Agent), every composition (Sequence, Parallel,
+ * Conditional, Loop), and every pattern factory result implements Runner.
+ * That makes them freely nestable: any runner can be a child of any
+ * composition.
+ */
+export interface Runner<TIn = unknown, TOut = unknown> extends Omit<ComposableRunner<TIn, TOut>, 'run'> {
+    /**
+     * Execute the runner. On happy-path completion, resolves with `TOut`.
+     * If any stage (Agent tool via `pauseHere`, nested runner, or consumer
+     * scope code) called `scope.$pause()`, resolves with a `RunnerPauseOutcome`
+     * carrying the serializable checkpoint. Discriminate with `isPaused()`.
+     */
+    run(input: TIn, options?: RunOptions): Promise<TOut | RunnerPauseOutcome>;
+    /**
+     * Resume a previously-paused execution from its checkpoint. `input` is
+     * delivered to the paused stage's resume handler. The same return shape
+     * as `run()`: `TOut` on completion, `RunnerPauseOutcome` if execution
+     * pauses again (e.g., a multi-step approval flow).
+     */
+    resume(checkpoint: FlowchartCheckpoint, input?: unknown, options?: RunOptions): Promise<TOut | RunnerPauseOutcome>;
+    /** Subscribe a typed listener. Returns unsubscribe. */
+    on<K extends AgentfootprintEventType>(type: K, listener: EventListener<K>, options?: ListenOptions): Unsubscribe;
+    /** Subscribe to a domain wildcard (e.g. 'agentfootprint.context.*') or '*'. */
+    on(type: WildcardSubscription, listener: WildcardListener, options?: ListenOptions): Unsubscribe;
+    /** Unsubscribe a previously-registered listener. */
+    off<K extends AgentfootprintEventType>(type: K, listener: EventListener<K>): void;
+    off(type: WildcardSubscription, listener: WildcardListener): void;
+    /** Subscribe a one-shot listener (fires once then auto-removes). */
+    once<K extends AgentfootprintEventType>(type: K, listener: EventListener<K>): Unsubscribe;
+    once(type: WildcardSubscription, listener: WildcardListener): Unsubscribe;
+    /**
+     * Attach a footprintjs CombinedRecorder to observe the execution.
+     * Returns an unsubscribe function — call it to detach the recorder
+     * from future runs. (Already-running executions continue using it.)
+     */
+    attach(recorder: CombinedRecorder): Unsubscribe;
+    /**
+     * Enable-namespace for high-level observability features. Each method
+     * attaches a pre-built CombinedRecorder and returns an unsubscribe
+     * function. Consumers write ONE line to enable rich observability,
+     * instead of N `.on()` subscriptions.
+     */
+    readonly enable: EnableNamespace;
+    /**
+     * Emit a consumer-defined custom event through the same dispatcher.
+     *
+     * Matches DOM CustomEvent. Useful for domain-specific events outside
+     * the 47-event registry (e.g. `myapp.billing.checkpoint`). Library
+     * events are reserved under the `agentfootprint.*` namespace.
+     */
+    emit(name: string, payload: Record<string, unknown>): void;
+}
+/** Kept for convenience — mirrors the RunOptions export from footprintjs. */
+export type { RunOptions };
+/**
+ * Union used in emit() for the `AgentfootprintEvent` type constraint. A
+ * consumer emitting a custom event passes a plain object payload; the
+ * dispatcher wraps it as AgentfootprintEvent only when the name is a
+ * registered type. Otherwise it flows through as an opaque custom event.
+ */
+export type EmittedEvent = AgentfootprintEvent;
+//# sourceMappingURL=runner.d.ts.map

package/dist/types/core/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/core/runner.ts"],"names":[],"mappings":"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"}

package/dist/types/core/slots/buildMessagesSlot.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Messages slot subflow builder
+ *
+ * Pattern: Builder (returns a FlowChart mountable via addSubFlowChartNext).
+ * Role:    Layer-3 context engineering. Produces InjectionRecord[] from
+ *          the current conversation history. For LLMCall, that's one
+ *          user message. For Agent, it's user + assistant + tool-result
+ *          messages accumulated over iterations.
+ * Emits:   None directly; ContextRecorder sees the writes.
+ *
+ * Minimal scope for Phase 3e: pass-through of an input message history
+ * array. Full MessageStrategy (windowing, summarizing) arrives in Phase 5.
+ */
+import type { FlowChart } from 'footprintjs';
+import type { ContextRole } from '../../events/types.js';
+/**
+ * A single message supplied by the caller. Structurally matches the
+ * LLMMessage adapter type but local-aliased to keep this file free of
+ * adapter-layer coupling.
+ */
+export interface InputMessage {
+    readonly role: ContextRole;
+    readonly content: string;
+    readonly toolCallId?: string;
+    readonly toolName?: string;
+}
+export interface MessagesSlotConfig {
+    /** Budget cap (chars). Default: 10000. */
+    readonly budgetCap?: number;
+}
+/**
+ * Build the Messages slot subflow.
+ *
+ * Mount with:
+ *   builder.addSubFlowChartNext(SUBFLOW_IDS.MESSAGES, buildMessagesSlot(cfg), 'Messages', {
+ *     inputMapper: (parent) => ({ messages: parent.messages, iteration: parent.iteration }),
+ *     outputMapper: (sf) => ({ messagesInjections: sf.messagesInjections }),
+ *   })
+ */
+export declare function buildMessagesSlot(config?: MessagesSlotConfig): FlowChart;
+//# sourceMappingURL=buildMessagesSlot.d.ts.map

package/dist/types/core/slots/buildMessagesSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildMessagesSlot.d.ts","sourceRoot":"","sources":["../../../../src/core/slots/buildMessagesSlot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,aAAa,CAAC;AAEzD,OAAO,KAAK,EAAkB,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAMzE;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAMD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,kBAAuB,GAAG,SAAS,CA8D5E"}

package/dist/types/core/slots/buildSystemPromptSlot.d.ts

@@ -0,0 +1,42 @@
+/**
+ * System-Prompt slot subflow builder
+ *
+ * Pattern: Builder (returns a FlowChart mountable via addSubFlowChartNext).
+ * Role:    Layer-3 context engineering; inside Layer-5 primitives
+ *          (LLMCall, Agent). Ported from v1's buildSystemPromptSubflow
+ *          to InjectionRecord + SlotComposition shape.
+ * Emits:   None directly. Writes to conventional scope keys; ContextRecorder
+ *          observes and emits context.* events.
+ *
+ * Minimal scope for Phase 3e: static prompt string OR a dynamic function
+ * of the input. Full SystemPromptProvider / Skill / RAG integration
+ * arrives in Phase 5.
+ */
+import type { FlowChart } from 'footprintjs';
+/**
+ * Function that produces the system prompt string given runtime scope
+ * context. Receives the subflow's $getArgs() payload.
+ */
+export type SystemPromptFn = (args: {
+    readonly userMessage?: string;
+    readonly iteration?: number;
+}) => string | Promise<string>;
+export interface SystemPromptSlotConfig {
+    /** Static string OR a function. Empty string → no injection, empty slot. */
+    readonly prompt: string | SystemPromptFn;
+    /** Budget cap (chars). Default: 4000. */
+    readonly budgetCap?: number;
+    /** Optional description — where this prompt originated (e.g. "agent.system()"). */
+    readonly reason?: string;
+}
+/**
+ * Build the System-Prompt slot subflow.
+ *
+ * Mount with:
+ *   builder.addSubFlowChartNext(SUBFLOW_IDS.SYSTEM_PROMPT, buildSystemPromptSlot(cfg), 'System Prompt', {
+ *     inputMapper: (parent) => ({ userMessage: parent.userMessage, iteration: parent.iteration }),
+ *     outputMapper: (sf) => ({ systemPromptInjections: sf.systemPromptInjections }),
+ *   })
+ */
+export declare function buildSystemPromptSlot(config: SystemPromptSlotConfig): FlowChart;
+//# sourceMappingURL=buildSystemPromptSlot.d.ts.map

package/dist/types/core/slots/buildSystemPromptSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildSystemPromptSlot.d.ts","sourceRoot":"","sources":["../../../../src/core/slots/buildSystemPromptSlot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,aAAa,CAAC;AAOzD;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE;IAClC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAE/B,MAAM,WAAW,sBAAsB;IACrC,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAAC;IACzC,yCAAyC;IACzC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,mFAAmF;IACnF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAWD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,sBAAsB,GAAG,SAAS,CA8D/E"}

package/dist/types/core/slots/buildToolsSlot.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Tools slot subflow builder
+ *
+ * Pattern: Builder (returns a FlowChart mountable via addSubFlowChartNext).
+ * Role:    Layer-3 context engineering. Resolves the tools list the LLM
+ *          sees on this iteration — one InjectionRecord per exposed tool.
+ * Emits:   None directly; ContextRecorder sees the writes.
+ *
+ * Minimal scope for Phase 3e: static tool registry, all exposed every
+ * iteration. Full permission gating / skill activation / context-aware
+ * tool filtering arrives in Phase 5.
+ */
+import type { FlowChart } from 'footprintjs';
+import type { LLMToolSchema } from '../../adapters/types.js';
+export interface ToolsSlotConfig {
+    /** Tool registry exposed to the LLM. Empty → empty slot (LLMCall case). */
+    readonly tools: readonly LLMToolSchema[];
+    /** Budget cap (chars). Default: 2000. */
+    readonly budgetCap?: number;
+}
+/**
+ * Build the Tools slot subflow.
+ *
+ * Mount with:
+ *   builder.addSubFlowChartNext(SUBFLOW_IDS.TOOLS, buildToolsSlot(cfg), 'Tools', {
+ *     inputMapper: (parent) => ({ iteration: parent.iteration }),
+ *     outputMapper: (sf) => ({ toolsInjections: sf.toolsInjections, toolSchemas: sf.toolSchemas }),
+ *   })
+ */
+export declare function buildToolsSlot(config: ToolsSlotConfig): FlowChart;
+//# sourceMappingURL=buildToolsSlot.d.ts.map

package/dist/types/core/slots/buildToolsSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildToolsSlot.d.ts","sourceRoot":"","sources":["../../../../src/core/slots/buildToolsSlot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,aAAa,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAO7D,MAAM,WAAW,eAAe;IAC9B,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IACzC,yCAAyC;IACzC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAMD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAmEjE"}

package/dist/types/core/slots/helpers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared helpers for slot subflow builders.
+ *
+ * Pattern: utility module.
+ * Role:    Tiny pure functions the slot builders share — hash, truncate,
+ *          breakdown. Kept co-located to avoid cross-package import churn.
+ */
+import type { ContextSource, ContextSlot } from '../../events/types.js';
+import type { InjectionRecord, SlotComposition } from '../../recorders/core/types.js';
+/** Non-cryptographic stable hash — sufficient for InjectionRecord dedup. */
+export declare function fnv1a(input: string): string;
+/** Truncate with ellipsis for contentSummary fields. */
+export declare function truncate(s: string, n: number): string;
+/** Aggregate injection chars/count per source — payload for SlotComposition. */
+export declare function breakdown(injections: readonly InjectionRecord[]): Readonly<Partial<Record<ContextSource, {
+    chars: number;
+    count: number;
+}>>>;
+/**
+ * Build a SlotComposition summary record from injections + budget cap.
+ * Drop tracking is opt-in — pass `dropped` when the slot actually
+ * evicted anything during composition.
+ */
+export declare function composeSlot(slot: ContextSlot, iteration: number, injections: readonly InjectionRecord[], budgetCap: number, orderingStrategy?: string, dropped?: {
+    count: number;
+    summaries: readonly string[];
+}): SlotComposition;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/types/core/slots/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../src/core/slots/helpers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEtF,4EAA4E;AAC5E,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO3C;AAED,wDAAwD;AACxD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED,gFAAgF;AAChF,wBAAgB,SAAS,CACvB,UAAU,EAAE,SAAS,eAAe,EAAE,GACrC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAAC,CAe5E;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,WAAW,EACjB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,SAAS,EAAE,MAAM,EACjB,gBAAgB,CAAC,EAAE,MAAM,EACzB,OAAO,CAAC,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GACxD,eAAe,CAcjB"}

package/dist/types/core/tools.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Tool types — Agent's tool-call contract.
+ *
+ * Pattern: Strategy (GoF) — each Tool is a strategy for "how to execute
+ *          this named operation given these args".
+ * Role:    Consumer-facing shape. Agent.tool(...) accepts these.
+ * Emits:   N/A (types only).
+ */
+import type { LLMToolSchema } from '../adapters/types.js';
+/**
+ * One executable tool the Agent can call.
+ *
+ * - `schema` is what the LLM sees (name, description, JSON schema).
+ * - `execute` runs when the LLM requests this tool with the given args.
+ *   Returns anything JSON-serializable; the framework forwards it back
+ *   to the LLM as the tool result.
+ */
+export interface Tool<TArgs = Record<string, unknown>, TResult = unknown> {
+    readonly schema: LLMToolSchema;
+    execute(args: TArgs, ctx: ToolExecutionContext): Promise<TResult> | TResult;
+}
+/** Runtime context passed to tool.execute(). */
+export interface ToolExecutionContext {
+    /** Unique id of THIS tool invocation (matches stream.tool_start.toolCallId). */
+    readonly toolCallId: string;
+    /** Current iteration number of the ReAct loop. */
+    readonly iteration: number;
+    /** Abort signal propagated from run({ env: { signal } }). */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Internal: registry entry keyed by tool name.
+ * Consumer never sees this shape.
+ */
+export interface ToolRegistryEntry {
+    readonly name: string;
+    readonly tool: Tool;
+}
+/**
+ * Convenience input for `defineTool` — flatter than `Tool` itself.
+ * Consumers describe the tool inline; the helper assembles `schema`.
+ *
+ * `inputSchema` is a JSON Schema object (the same one the LLM will
+ * see). For tools that take no arguments, pass `{ type: 'object',
+ * properties: {} }` or omit and we'll default to that.
+ */
+export interface DefineToolOptions<TArgs, TResult> {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema?: Readonly<Record<string, unknown>>;
+    execute(args: TArgs, ctx: ToolExecutionContext): Promise<TResult> | TResult;
+}
+/**
+ * Ergonomic builder for `Tool`. Equivalent to constructing an object
+ * literal with `schema` + `execute`, but flatter and safer — the name
+ * + description live alongside the executor so they can't drift.
+ *
+ * @example
+ *   const weather = defineTool<{ city: string }, string>({
+ *     name: 'weather',
+ *     description: 'Get current weather for a city',
+ *     inputSchema: {
+ *       type: 'object',
+ *       properties: { city: { type: 'string' } },
+ *       required: ['city'],
+ *     },
+ *     execute: async ({ city }) => `${city}: 72°F sunny`,
+ *   });
+ *
+ *   const agent = Agent.create({ provider }).tool(weather).build();
+ */
+export declare function defineTool<TArgs = Record<string, unknown>, TResult = unknown>(options: DefineToolOptions<TArgs, TResult>): Tool<TArgs, TResult>;
+//# sourceMappingURL=tools.d.ts.map

package/dist/types/core/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/core/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;;;;;;GAOG;AACH,MAAM,WAAW,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO;IACtE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CAC7E;AAED,gDAAgD;AAChD,MAAM,WAAW,oBAAoB;IACnC,gFAAgF;IAChF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,kDAAkD;IAClD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB,CAAC,KAAK,EAAE,OAAO;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzD,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CAC7E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,EAC3E,OAAO,EAAE,iBAAiB,CAAC,KAAK,EAAE,OAAO,CAAC,GACzC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAStB"}