agentfootprint 1.22.0 → 2.0.1

package/dist/types/lib/loop/types.d.ts

@@ -1,281 +0,0 @@
-/**
- * Loop assembler types.
- *
- * The loop assembler wires the three API slots + call stages into a
- * looping flowchart: SystemPrompt → Messages → Tools → CallLLM →
- * ParseResponse → RouteResponse(decider) → {tool-calls | final}
- * → loopTo('call-llm').
- */
-import type { FlowChart } from 'footprintjs';
-import type { DecisionResult } from 'footprintjs';
-import type { StageFunction, SubflowMountOptions } from 'footprintjs/advanced';
-import type { LLMProvider, ResponseFormat } from '../../types';
-import type { ToolProvider } from '../../core';
-import type { ToolRegistry } from '../../tools';
-import type { Message } from '../../types/messages';
-import type { MemoryPipeline } from '../../memory/pipeline';
-import type { SystemPromptSlotConfig } from '../slots/system-prompt';
-import type { MessagesSlotConfig } from '../slots/messages';
-import type { ToolsSlotConfig } from '../slots/tools';
-import type { ResolvedInstruction, InstructionOverride, AgentInstruction } from '../instructions';
-import type { DecideFn } from '../call/helpers';
-/**
- * A single branch in a RoutingConfig — what happens for a given decider return value.
- *
- * Discriminated union ensures every branch has exactly one handler.
- */
-export type RoutingBranch = {
-    readonly id: string;
-    readonly kind: 'subflow';
-    readonly chart: FlowChart;
-    readonly name?: string;
-    readonly mount?: SubflowMountOptions;
-} | {
-    readonly id: string;
-    readonly kind: 'lazy-subflow';
-    readonly factory: () => FlowChart;
-    readonly name?: string;
-    readonly mount?: SubflowMountOptions;
-} | {
-    readonly id: string;
-    readonly kind: 'fn';
-    readonly fn: StageFunction;
-    readonly name?: string;
-    readonly description?: string;
-};
-/**
- * RoutingConfig — controls what happens after ParseResponse in the agent loop.
- *
- * The default agent loop uses `tool-calls | final` routing. Swarm uses
- * `specialist-A | specialist-B | swarm-tools | final`. Both are expressed
- * as RoutingConfig — one code path, zero forks in buildAgentLoop.
- *
- * **Ordering invariant:** The decider runs AFTER ParseResponse commits.
- * Scope contains `parsedResponse` with tool calls and response content.
- *
- * @internal Not exported from the public API. Consumer-facing builders
- * (Agent, Swarm) construct RoutingConfig internally.
- */
-export interface RoutingConfig {
-    /** Name for the decider stage (e.g., 'RouteResponse', 'RouteSpecialist'). */
-    readonly deciderName: string;
-    /** Stable ID for the decider node. */
-    readonly deciderId: string;
-    /** Description shown in narrative. */
-    readonly deciderDescription?: string;
-    /**
-     * Decider function — called after ParseResponse commits.
-     *
-     * Returns EITHER a branch-id string OR a `DecisionResult` from `decide()`.
-     * When returning `decide(...)`'s full result, footprintjs's DeciderHandler
-     * extracts the structured evidence and attaches it to `FlowRecorder.onDecision`
-     * — this is what enables "why did we take this branch?" audit queries.
-     * Returning only a bare string loses that evidence.
-     *
-     * Scope shape: see `parsedResponse`, `hasToolCalls`, `loopCount`, etc.
-     * maxIterations enforcement is handled structurally by buildAgentLoop —
-     * the decider does not need to check it.
-     */
-    readonly decider: (scope: any, breakFn: () => void, streamCb?: unknown) => string | DecisionResult | Promise<string | DecisionResult>;
-    /** Branch definitions — each maps to a subflow or inline function.
-     *  Order matters: branches are added to the decider in array order. */
-    readonly branches: readonly RoutingBranch[];
-    /** Default branch when decider returns an unknown key or maxIterations is reached.
-     *  This branch MUST call $break() or breakFn() to terminate the loop. */
-    readonly defaultBranch: string;
-}
-/**
- * Agent loop patterns — determines which stages re-evaluate between iterations.
- *
- * The pattern controls WHERE the loop jumps back to after tool execution:
- * - `Regular`: loops to CallLLM — slots resolve once before the loop
- * - `Dynamic`: loops to SystemPrompt — all three API slots re-evaluate each iteration
- *
- * @example
- * ```typescript
- * import { Agent, AgentPattern } from 'agentfootprint';
- *
- * // Standard ReAct — fixed prompt, tools, memory (default)
- * Agent.create({ provider }).build();
- *
- * // Dynamic ReAct — re-evaluate all slots each iteration
- * Agent.create({ provider })
- *   .pattern(AgentPattern.Dynamic)
- *   .build();
- * ```
- *
- * @example
- * ```typescript
- * // Dynamic ReAct use case: progressive tool authorization
- * // Turn 1: agent calls verify_identity → user is admin
- * // Turn 2: Tools subflow re-evaluates → admin tools now available
- * // Turn 3: agent can use admin tools that were hidden before
- * ```
- */
-export declare enum AgentPattern {
-    /**
-     * Standard ReAct loop — loops back to CallLLM.
-     *
-     * SystemPrompt, Messages, and Tools subflows resolve ONCE before the loop starts.
-     * Each iteration only re-runs: CallLLM → ParseResponse → RouteResponse → tools.
-     * Best for: most agent use cases with fixed prompt/tools/memory.
-     *
-     * ```
-     * [SystemPrompt] → [Messages] → [Tools] → AssemblePrompt
-     *   → CallLLM → Parse → Route → ExecuteTools → loopTo(CallLLM)
-     *         ↑                                         |
-     *         └─────────────────────────────────────────┘
-     * ```
-     */
-    Regular = "regular",
-    /**
-     * Dynamic ReAct loop — loops back to SystemPrompt.
-     *
-     * All three API slots (SystemPrompt, Messages, Tools) re-evaluate each iteration.
-     * Strategies receive updated context (messages now include tool results, loopCount
-     * incremented) and can return different prompt/tools/memory based on what happened.
-     * Best for: progressive authorization, adaptive prompts, context-dependent tool sets.
-     *
-     * ```
-     * [SystemPrompt] → [Messages] → [Tools] → AssemblePrompt
-     *   → CallLLM → Parse → Route → ExecuteTools → loopTo(SystemPrompt)
-     *  ↑                                                  |
-     *  └──────────────────────────────────────────────────┘
-     * ```
-     */
-    Dynamic = "dynamic"
-}
-/**
- * Full configuration for building an agent loop.
- */
-export interface AgentLoopConfig {
-    /** LLM provider for the CallLLM stage. */
-    readonly provider: LLMProvider;
-    /** SystemPrompt slot configuration. */
-    readonly systemPrompt: SystemPromptSlotConfig;
-    /** Messages slot configuration. */
-    readonly messages: MessagesSlotConfig;
-    /** Tools slot configuration. */
-    readonly tools: ToolsSlotConfig;
-    /** Tool registry for executing tool calls in the tool-calls branch. */
-    readonly registry: ToolRegistry;
-    /**
-     * Optional ToolProvider for remote tool execution (MCP, A2A).
-     * When present, tool execution tries provider.execute() before registry fallback.
-     */
-    readonly toolProvider?: ToolProvider;
-    /** Max loop iterations before force-finalize. Default: 10. */
-    readonly maxIterations?: number;
-    /**
-     * Loop pattern — controls where the loop jumps back to after tool execution.
-     *
-     * - `AgentPattern.Regular` (default): loops to CallLLM — slots resolve once
-     * - `AgentPattern.Dynamic`: loops to SystemPrompt — all slots re-evaluate each iteration
-     *
-     * @default AgentPattern.Regular
-     */
-    readonly pattern?: AgentPattern;
-    /**
-     * Memory pipeline — mounts the pipeline's read subflow before the
-     * loop body and the write subflow (if present) INSIDE the `final`
-     * branch. Flows from `AgentBuilder.memoryPipeline()`.
-     */
-    readonly memoryPipeline?: MemoryPipeline;
-    /**
-     * Callback when LLM instructions fire during tool execution.
-     * Used to connect InstructionRecorder to the instruction pipeline.
-     */
-    readonly onInstructionsFired?: (toolId: string, fired: ResolvedInstruction[]) => void;
-    /** Agent-level instruction overrides keyed by tool ID. */
-    readonly instructionOverrides?: ReadonlyMap<string, InstructionOverride>;
-    /**
-     * Agent-level instructions evaluated by the InstructionsToLLM subflow.
-     * When provided, the subflow is mounted BEFORE the 3 API slots.
-     * Instructions inject into system prompt, tools, and tool-result processing
-     * based on the current Decision Scope state.
-     */
-    readonly agentInstructions?: readonly AgentInstruction[];
-    /**
-     * Initial Decision Scope values. Written to `scope.decision` in the Seed stage.
-     * Tool handlers update these values; InstructionsToLLM reads them to evaluate
-     * `activeWhen` predicates.
-     */
-    readonly initialDecision?: Readonly<Record<string, unknown>>;
-    /**
-     * Pre-computed decide() functions keyed by instruction rule ID.
-     * Built once in AgentRunner constructor, passed through to avoid
-     * recomputing on every run(). Functions can't travel through scope
-     * (stripped on write), so they're captured as a closure map.
-     */
-    readonly decideFunctions?: ReadonlyMap<string, DecideFn>;
-    /** When true, CallLLM uses addStreamingFunction for token-by-token output. */
-    readonly streaming?: boolean;
-    /** Structured output format — passed to LLM provider as responseFormat option. */
-    readonly responseFormat?: ResponseFormat;
-    /**
-     * Run multiple tool calls within a single turn concurrently via Promise.all.
-     * Results are appended in the order the LLM requested them. Default: false.
-     * Only beneficial when the LLM requests 2+ independent tool calls in a turn.
-     */
-    readonly parallelTools?: boolean;
-    /**
-     * After this many consecutive identical (name, args) tool-call failures, the
-     * library injects a one-shot `escalation` field into the tool result content
-     * telling the LLM to change arguments, switch tools, or finalize. Fires
-     * exactly once per (name, args) key per conversation.
-     *
-     * Defaults to `REPEATED_FAILURE_ESCALATION_THRESHOLD` (3). Pass `0` (or any
-     * non-positive number) to disable.
-     */
-    readonly maxIdenticalFailures?: number;
-    /**
-     * Custom routing strategy — replaces the default RouteResponse decider.
-     *
-     * When provided, buildAgentLoop uses this RoutingConfig instead of the
-     * default `tool-calls | final` routing. Used by Swarm to route to
-     * specialist subflows.
-     *
-     * When omitted, the default agent routing is used automatically.
-     *
-     * @internal Consumers use Agent/Swarm builders, not this field directly.
-     */
-    readonly routing?: RoutingConfig;
-    /**
-     * User-defined routing branches prepended to the default `tool-calls | final` routing.
-     *
-     * Each extension's `when` predicate is evaluated (in order) before the default
-     * decider logic. If none match, the default routing applies. If the runner
-     * exposes `.toFlowChart()`, the branch is mounted as a subflow; otherwise the
-     * runner is wrapped as a stage function.
-     *
-     * Ignored when `routing` is also set (Swarm path).
-     *
-     * @example
-     * ```ts
-     * routeExtensions: [
-     *   { id: 'escalate', when: (s) => s.parsedResponse.content.includes('[ESCALATE]'), runner: humanAgent },
-     * ]
-     * ```
-     */
-    readonly routeExtensions?: readonly {
-        readonly id?: string;
-        readonly when: (scope: any) => boolean;
-        readonly runner: import('../../types/multiAgent').RunnerLike;
-    }[];
-}
-/**
- * Options for seeding the loop with initial state.
- */
-export interface AgentLoopSeedOptions {
-    /** Initial messages (e.g., [userMessage('hello')]). */
-    readonly messages: Message[];
-    /** Existing conversation history to prepend. Default: []. */
-    readonly existingMessages?: Message[];
-    /**
-     * When true, Seed stage reads `message` (string) from scope instead of
-     * using baked-in messages. Use this for subflow composition — the parent
-     * chart's inputMapper sets `message` in the subflow's scope.
-     */
-    readonly subflowMode?: boolean;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/types/lib/loop/types.d.ts.map

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

package/dist/types/lib/narrative/agentRenderer.d.ts

@@ -1,56 +0,0 @@
-/**
- * Agent NarrativeFormatter — LLM-optimized narrative for agent loop execution.
- *
- * Designed for LLM follow-up reasoning: the narrative answers "what happened?"
- * so a downstream LLM can ask informed questions about the agent's execution.
- *
- * Key design decisions:
- *   1. Enrichment keys (llmCall, responseType, resolvedTools, promptSummary)
- *      are promoted — their values ARE the narrative, shown directly.
- *   2. Internal keys (memory_*, loopCount, adapter internals) are suppressed.
- *   3. Core keys (messages, result) get smart formatting with counts/previews.
- *   4. Most reads are suppressed — writes tell the story, reads are noise.
- *      Exception: `parsedResponse` reads are shown in tool execution (tool names + args).
- *   5. Stage headers use agent terminology, not generic "The process began."
- *   6. Subflow boundaries use slot names: "Preparing system prompt."
- *   7. Loop/break use agent language: "Tool loop iteration N", "Agent completed."
- *
- * The entry types (stage, step, subflow, loop, break, error, condition, fork,
- * selector) and stageId/subflowId fields are preserved by the recorder — the
- * renderer only controls the text. Time-travel UI sync is unaffected.
- */
-import type { NarrativeRenderer } from 'footprintjs/recorders';
-export interface AgentRendererOptions {
-    /**
-     * When true, shows full values instead of truncated previews.
-     * System prompts, tool results, LLM outputs, and parsed responses
-     * are shown in full for debugging and grounding analysis.
-     * @default false
-     */
-    verbose?: boolean;
-}
-/**
- * Create an agent-optimized narrative formatter.
- *
- * Returns the `NarrativeRenderer` type (structurally identical to
- * footprintjs's new `NarrativeFormatter`). Once a newer footprintjs
- * release is consumed here, migrate the return type to
- * `NarrativeFormatter` — no behavioural change.
- *
- * Usage:
- * ```typescript
- * import { createAgentRenderer } from 'agentfootprint';
- *
- * executor.enableNarrative({ renderer: createAgentRenderer() });
- * ```
- *
- * Or with the narrative() factory:
- * ```typescript
- * import { narrative } from 'footprintjs/recorders';
- * import { createAgentRenderer } from 'agentfootprint';
- *
- * const rec = narrative({ renderer: createAgentRenderer() });
- * ```
- */
-export declare function createAgentRenderer(options?: AgentRendererOptions): NarrativeRenderer;
-//# sourceMappingURL=agentRenderer.d.ts.map

package/dist/types/lib/narrative/agentRenderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agentRenderer.d.ts","sourceRoot":"","sources":["../../../../src/lib/narrative/agentRenderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAQH,OAAO,KAAK,EACV,iBAAiB,EAWlB,MAAM,uBAAuB,CAAC;AA2E/B,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAmKD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,iBAAiB,CAwJrF"}

package/dist/types/lib/narrative/index.d.ts

@@ -1,3 +0,0 @@
-export { createAgentRenderer } from './agentRenderer.js';
-export type { AgentRendererOptions } from './agentRenderer.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/lib/narrative/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/narrative/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/types/lib/skills/defineSkill.d.ts

@@ -1,10 +0,0 @@
-/**
- * defineSkill — type-narrowing factory for a `Skill<TDecision>`.
- *
- * Mirrors `defineInstruction()` — a pure passthrough that gives
- * callers crisp inference for `TDecision` in downstream predicates
- * (`activeWhen(d) => ...` types `d` as `TDecision`).
- */
-import type { Skill } from './types';
-export declare function defineSkill<TDecision = unknown>(skill: Skill<TDecision>): Skill<TDecision>;
-//# sourceMappingURL=defineSkill.d.ts.map

package/dist/types/lib/skills/defineSkill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defineSkill.d.ts","sourceRoot":"","sources":["../../../../src/lib/skills/defineSkill.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,wBAAgB,WAAW,CAAC,SAAS,GAAG,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,CAe1F"}

package/dist/types/lib/skills/index.d.ts

@@ -1,6 +0,0 @@
-export type { Skill, SurfaceMode, ProviderHint, SkillRegistryOptions, AutoActivateOptions, SkillListEntry, GeneratedSkillTools, } from './types';
-export { defineSkill } from './defineSkill';
-export { SkillRegistry } from './registry';
-export { renderSkillBody, resolveSkillBody } from './renderBody';
-export { resolveSurfaceMode, parseAnthropicVersion, isClaudeStrongAdherence } from './surfaceMode';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/lib/skills/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/skills/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,KAAK,EACL,WAAW,EACX,YAAY,EACZ,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,GACpB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC"}

package/dist/types/lib/skills/registry.d.ts

@@ -1,98 +0,0 @@
-/**
- * SkillRegistry — a compiler from a set of `Skill`s into the three
- * existing primitives Agent already understands:
- *
- *   Skills  ──▶  AgentInstruction[]   (prompt + tools + onToolResult + activeWhen)
- *           ──▶  [list_skills, read_skill]  (auto-generated ToolDefinitions)
- *           ──▶  system-prompt fragment (when surface mode permits)
- *
- * Registry is in-process and immutable-after-build — panel #5 flagged
- * hot-swap as Phase 2. Registration is idempotent on `{id, version}`:
- * re-registering the same id+version is a no-op; re-registering the
- * same id with a different version replaces (with a dev warning).
- *
- * Events are emitted via the existing `$emit` channel; no new
- * observer system — panel #6.
- */
-import type { AgentInstruction } from '../instructions';
-import type { AutoActivateOptions, GeneratedSkillTools, Skill, SkillRegistryOptions, SurfaceMode } from './types';
-export declare class SkillRegistry<TDecision = unknown> {
-    private readonly skills;
-    private readonly options;
-    constructor(options?: SkillRegistryOptions);
-    /**
-     * True when `autoActivate` is configured — exposed so consumers
-     * writing custom builders can check without depending on the private
-     * options field.
-     */
-    get hasAutoActivate(): boolean;
-    /** The configured autoActivate (or undefined). Exposed for advanced use. */
-    get autoActivate(): AutoActivateOptions | undefined;
-    /**
-     * Register a skill.
-     *
-     * Behavior on duplicate `id`:
-     *   - Same `version`: silent no-op (idempotent — safe to call during
-     *     module init multiple times).
-     *   - Different `version`: REPLACES the existing entry AND fires a
-     *     dev-mode `console.warn`. Evals almost certainly need pinning
-     *     to one version at a time, so the warning nudges authors to
-     *     make the replacement intentional.
-     *
-     * Registration order is preserved by `list()` / `toPromptFragment()`.
-     *
-     * TODO(phase-2): when `refreshPolicy.afterTokens` lands, the registry
-     * must also expose a `hash` of its contents so the runtime can detect
-     * "registry changed since last read_skill surface" and re-inject.
-     */
-    register(skill: Skill<TDecision>): this;
-    /** Register multiple skills. */
-    registerAll(skills: readonly Skill<TDecision>[]): this;
-    /** Look up a skill by id. Returns undefined when unknown. */
-    getById(id: string): Skill<TDecision> | undefined;
-    /** All registered skills, in insertion order. */
-    list(): readonly Skill<TDecision>[];
-    /**
-     * Filter skills by scope tag and/or case-insensitive query over
-     * `title + description`. Used by the auto-generated `list_skills`
-     * tool — panel #3 (`scope` / `query` filtering in the signature
-     * from day one).
-     */
-    search(options?: {
-        scope?: string;
-        query?: string;
-    }): readonly Skill<TDecision>[];
-    /**
-     * Resolve the effective surface mode for this registry, consulting
-     * the provider hint when `'auto'`. Stable — consumers can call this
-     * once at build time.
-     */
-    effectiveSurfaceMode(): Exclude<SurfaceMode, 'auto'>;
-    /**
-     * Compile skills into the `AgentInstruction[]` the Agent loop already
-     * knows how to evaluate. Every Skill already extends AgentInstruction —
-     * this is a type-narrowed passthrough, with one augmentation:
-     *
-     * When `autoActivate` is configured AND a skill has no `activeWhen`
-     * of its own, the registry injects a default predicate of
-     *   `(d) => d[stateField] === skill.id`
-     * so the skill's tools / prompt / onToolResult rules gate themselves
-     * automatically on activation. Consumers who want custom activation
-     * logic simply declare `activeWhen` on the skill and the default is
-     * skipped.
-     */
-    toInstructions(): readonly AgentInstruction<TDecision>[];
-    /**
-     * Generate the `list_skills` + `read_skill` tool pair. Both tools go
-     * through `defineTool()` so they appear correctly in manifest /
-     * narrative / toOpenAPI output (panel #6).
-     */
-    toTools(): GeneratedSkillTools;
-    /**
-     * System-prompt fragment listing skills + their descriptions. Returns
-     * `null` when the effective surface mode is `'tool-only'` (no prompt
-     * injection) OR when the registry is empty (no ghost header).
-     */
-    toPromptFragment(): string | null;
-}
-//# sourceMappingURL=registry.d.ts.map

package/dist/types/lib/skills/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/lib/skills/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAIxD,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,KAAK,EAEL,oBAAoB,EACpB,WAAW,EACZ,MAAM,SAAS,CAAC;AAIjB,qBAAa,aAAa,CAAC,SAAS,GAAG,OAAO;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAC9D,OAAO,CAAC,QAAQ,CAAC,OAAO,CACsC;gBAElD,OAAO,GAAE,oBAAyB;IAS9C;;;;OAIG;IACH,IAAI,eAAe,IAAI,OAAO,CAE7B;IAED,4EAA4E;IAC5E,IAAI,YAAY,IAAI,mBAAmB,GAAG,SAAS,CAElD;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,IAAI;IAkBvC,gCAAgC;IAChC,WAAW,CAAC,MAAM,EAAE,SAAS,KAAK,CAAC,SAAS,CAAC,EAAE,GAAG,IAAI;IAKtD,6DAA6D;IAC7D,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,GAAG,SAAS;IAIjD,iDAAiD;IACjD,IAAI,IAAI,SAAS,KAAK,CAAC,SAAS,CAAC,EAAE;IAInC;;;;;OAKG;IACH,MAAM,CAAC,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,SAAS,KAAK,CAAC,SAAS,CAAC,EAAE;IAerF;;;;OAIG;IACH,oBAAoB,IAAI,OAAO,CAAC,WAAW,EAAE,MAAM,CAAC;IAIpD;;;;;;;;;;;;OAYG;IACH,cAAc,IAAI,SAAS,gBAAgB,CAAC,SAAS,CAAC,EAAE;IAkBxD;;;;OAIG;IACH,OAAO,IAAI,mBAAmB;IA0G9B;;;;OAIG;IACH,gBAAgB,IAAI,MAAM,GAAG,IAAI;CAWlC"}

package/dist/types/lib/skills/renderBody.d.ts

@@ -1,22 +0,0 @@
-/**
- * renderSkillBody — produce the tool-result text the model reads when
- * it calls `read_skill({ id })`.
- *
- * Panel #4 (Anthropic prompt engineer) specified the format:
- *   - First line is a recency anchor: "You are now following skill: X"
- *   - No "tools available" prose — tool availability is wired via
- *     activeWhen + AgentInstruction.tools, advertising it in text
- *     leads to hallucinated calls for unavailable tools.
- *   - Everything imperative, framed around the model.
- *   - `steps` as a numbered list (survives attention drift better
- *     than a paragraph).
- *
- * Panel #8 (security): escape `</memory>` AND `</tool_use>` in any
- * user-controlled field (title, description, steps, prompt) to prevent
- * tag-escape prompt injection.
- */
-import type { Skill } from './types';
-export declare function renderSkillBody<T>(skill: Skill<T>): string;
-/** Resolve the body override — string, async loader, or default render. */
-export declare function resolveSkillBody<T>(skill: Skill<T>): Promise<string>;
-//# sourceMappingURL=renderBody.d.ts.map

package/dist/types/lib/skills/renderBody.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"renderBody.d.ts","sourceRoot":"","sources":["../../../../src/lib/skills/renderBody.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAQrC,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAqB1D;AAED,2EAA2E;AAC3E,wBAAsB,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAO1E"}

package/dist/types/lib/skills/surfaceMode.d.ts

@@ -1,34 +0,0 @@
-/**
- * Resolve `'auto'` SurfaceMode to a concrete mode based on a provider
- * hint.
- *
- * Rules (panel #2 + #1):
- *   - Claude 3.5+ / Claude 4 / Claude 5 etc. → `'both'`
- *     (system-prompt adherence is strong; belt-and-braces delivery
- *     adds free correctness signal on long contexts)
- *   - Anthropic models older than 3.5 → `'tool-only'`
- *   - Everything else (openai, mock, ollama, bedrock, unknown) → `'tool-only'`
- *     (portable default; matches eval-on-mock == production-on-real semantics)
- */
-import type { ProviderHint, SurfaceMode } from './types';
-/**
- * Parse Anthropic model ids like `claude-3-5-sonnet-20240620`,
- * `claude-sonnet-4-5-20250514`, `claude-opus-4-7` into a `{major, minor}`
- * tuple. Returns `null` for ids we can't parse (unknown → fall back to
- * the pre-3.5 path, which is the safe default).
- *
- * Handles the two id formats Anthropic has shipped:
- *   - Legacy: `claude-3-5-sonnet` / `claude-3-opus` (major.minor before family)
- *   - Current: `claude-sonnet-4-5` / `claude-opus-4-7` (family before major.minor)
- */
-export declare function parseAnthropicVersion(modelId: string): {
-    major: number;
-    minor: number;
-} | null;
-/** True if the parsed version is Claude ≥ 3.5. */
-export declare function isClaudeStrongAdherence(version: {
-    major: number;
-    minor: number;
-} | null): boolean;
-export declare function resolveSurfaceMode(mode: SurfaceMode, hint?: ProviderHint): Exclude<SurfaceMode, 'auto'>;
-//# sourceMappingURL=surfaceMode.d.ts.map

package/dist/types/lib/skills/surfaceMode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"surfaceMode.d.ts","sourceRoot":"","sources":["../../../../src/lib/skills/surfaceMode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEzD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAkB9F;AAED,kDAAkD;AAClD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,OAAO,CAKjG;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,WAAW,EACjB,IAAI,CAAC,EAAE,YAAY,GAClB,OAAO,CAAC,WAAW,EAAE,MAAM,CAAC,CAW9B"}