@animalabs/agent-framework 0.19.0 → 0.20.0

package/dist/src/mcpl/tool-classes.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Tool classes (MCPL RFC-008) — a coarse, fixed vocabulary for what a tool
+ * DOES, used as a key for host policy (RFC-007's argument exclusions today;
+ * approvals, audit grouping and caps later).
+ *
+ * A class is a HINT at the tier of MCP `annotations`, never a grant: it
+ * confers no authority, gates no method, and never changes what the model
+ * sees. The providing server declares it on its MCP tool definition as
+ * `_meta["mcpl/class"]`; the host computes an EFFECTIVE class per tool from
+ * (in precedence order, first source that yields a class wins entirely):
+ *
+ *   1. operator override (FrameworkConfig.toolClassOverrides),
+ *   2. the host's own knowledge of tools it implements (BUILTIN_TOOL_CLASSES
+ *      plus FrameworkConfig.hostToolClasses for an embedding host's modules),
+ *   3. the server's declaration.
+ *
+ * An UNCLASSED tool is handled as the most restrictive class for every
+ * question asked of it (RFC-008 §5.2): classing is how a tool earns looser
+ * handling, never how it is denied. A tool with several classes gets the
+ * union of their restrictions (§5.3).
+ */
+export declare const TOOL_CLASSES: readonly ["comms", "memory", "notes", "files", "shell", "web", "computer", "media", "body", "control"];
+export type ToolClass = (typeof TOOL_CLASSES)[number];
+export declare function isToolClass(value: unknown): value is ToolClass;
+/** The `_meta` key a server declares a tool's class under (RFC-008 §3). */
+export declare const TOOL_CLASS_META_KEY = "mcpl/class";
+/**
+ * Classes whose arguments are ordinarily safe to show an observer (RFC-007
+ * §4.3's recommended default `inputs` policy). `memory`, `notes` and
+ * `control` are left to explicit operator choice; `comms` is never a choice.
+ */
+export declare const DEFAULT_INPUT_CLASSES: readonly ToolClass[];
+/**
+ * Classes of the tools this framework implements itself — the host's own
+ * knowledge (RFC-008 §5.1 source 2). Keys use the RFC-007 §6.2 pattern
+ * grammar over the model-facing tool name. Anything not listed here, not
+ * overridden and not declared by its server is UNCLASSED, which is the
+ * restrictive answer — so an omission here fails closed.
+ */
+export declare const BUILTIN_TOOL_CLASSES: Readonly<Record<string, readonly ToolClass[]>>;
+/**
+ * Read a server's class declaration from a tool definition's `_meta`.
+ * Returns the known classes it names (deduplicated, in order), or undefined
+ * when it names none — which makes the tool unclassed. Unknown strings are
+ * ignored for policy and logged (RFC-008 §3, vectors 3 and 4); a non-array
+ * value is malformed and ignored the same way.
+ */
+export declare function parseDeclaredClasses(meta: unknown, toolName?: string): ToolClass[] | undefined;
+/**
+ * Validate a pattern → classes table from configuration. Unknown class
+ * strings are dropped with a diagnostic; an entry left with no class is
+ * dropped entirely (it cannot classify anything).
+ */
+export declare function normalizeClassTable(table: Record<string, readonly string[]> | undefined, label: string): Array<[string, ToolClass[]]>;
+export type ToolClassSource = 'override' | 'host' | 'server' | 'none';
+export interface EffectiveToolClass {
+    /** Empty for an unclassed tool. */
+    classes: ToolClass[];
+    source: ToolClassSource;
+}
+/**
+ * Compute a tool's effective class (RFC-008 §5.1). `overrides` and `host`
+ * are ordered pattern tables (first matching pattern wins within a source);
+ * the first SOURCE that yields a class wins entirely — sources never merge,
+ * so an override can tighten or correct a server's declaration.
+ */
+export declare function resolveToolClass(toolName: string, declared: readonly ToolClass[] | undefined, tables: {
+    overrides: ReadonlyArray<readonly [string, readonly ToolClass[]]>;
+    host: ReadonlyArray<readonly [string, readonly ToolClass[]]>;
+}): EffectiveToolClass;
+//# sourceMappingURL=tool-classes.d.ts.map

package/dist/src/mcpl/tool-classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-classes.d.ts","sourceRoot":"","sources":["../../../src/mcpl/tool-classes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,eAAO,MAAM,YAAY,wGAWf,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAItD,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAE9D;AAED,2EAA2E;AAC3E,eAAO,MAAM,mBAAmB,eAAe,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAAS,SAAS,EAOrD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC,CAmC/E,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,SAAc,GAAG,SAAS,EAAE,GAAG,SAAS,CAiBnG;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,GAAG,SAAS,EACpD,KAAK,EAAE,MAAM,GACZ,KAAK,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,CAe9B;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEtE,MAAM,WAAW,kBAAkB;IACjC,mCAAmC;IACnC,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,MAAM,EAAE,eAAe,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAC1C,MAAM,EAAE;IACN,SAAS,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC,CAAC,CAAC;IAClE,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC,CAAC,CAAC;CAC9D,GACA,kBAAkB,CASpB"}

package/dist/src/mcpl/tool-classes.js

@@ -0,0 +1,170 @@
+/**
+ * Tool classes (MCPL RFC-008) — a coarse, fixed vocabulary for what a tool
+ * DOES, used as a key for host policy (RFC-007's argument exclusions today;
+ * approvals, audit grouping and caps later).
+ *
+ * A class is a HINT at the tier of MCP `annotations`, never a grant: it
+ * confers no authority, gates no method, and never changes what the model
+ * sees. The providing server declares it on its MCP tool definition as
+ * `_meta["mcpl/class"]`; the host computes an EFFECTIVE class per tool from
+ * (in precedence order, first source that yields a class wins entirely):
+ *
+ *   1. operator override (FrameworkConfig.toolClassOverrides),
+ *   2. the host's own knowledge of tools it implements (BUILTIN_TOOL_CLASSES
+ *      plus FrameworkConfig.hostToolClasses for an embedding host's modules),
+ *   3. the server's declaration.
+ *
+ * An UNCLASSED tool is handled as the most restrictive class for every
+ * question asked of it (RFC-008 §5.2): classing is how a tool earns looser
+ * handling, never how it is denied. A tool with several classes gets the
+ * union of their restrictions (§5.3).
+ */
+import { globMatch } from './tool-glob.js';
+export const TOOL_CLASSES = [
+    'comms',
+    'memory',
+    'notes',
+    'files',
+    'shell',
+    'web',
+    'computer',
+    'media',
+    'body',
+    'control',
+];
+const CLASS_SET = new Set(TOOL_CLASSES);
+export function isToolClass(value) {
+    return typeof value === 'string' && CLASS_SET.has(value);
+}
+/** The `_meta` key a server declares a tool's class under (RFC-008 §3). */
+export const TOOL_CLASS_META_KEY = 'mcpl/class';
+/**
+ * Classes whose arguments are ordinarily safe to show an observer (RFC-007
+ * §4.3's recommended default `inputs` policy). `memory`, `notes` and
+ * `control` are left to explicit operator choice; `comms` is never a choice.
+ */
+export const DEFAULT_INPUT_CLASSES = [
+    'computer',
+    'shell',
+    'files',
+    'web',
+    'media',
+    'body',
+];
+/**
+ * Classes of the tools this framework implements itself — the host's own
+ * knowledge (RFC-008 §5.1 source 2). Keys use the RFC-007 §6.2 pattern
+ * grammar over the model-facing tool name. Anything not listed here, not
+ * overridden and not declared by its server is UNCLASSED, which is the
+ * restrictive answer — so an omission here fails closed.
+ */
+export const BUILTIN_TOOL_CLASSES = {
+    // Synthesized channel tools: speech to and from people (RFC-008 §4:
+    // speech that reaches a person is comms, wherever it goes).
+    'channel_*': ['comms'],
+    // Deliberately staying silent in a conversation is still about that
+    // conversation; its reason text can quote it.
+    skip_reply: ['comms'],
+    // The agent's private interior.
+    think: ['memory'],
+    journal: ['memory'],
+    // Host and agent settings, wake policy, routing help.
+    utils: ['control'],
+    agent_settings: ['control'],
+    gate_status: ['control'],
+    tune_out: ['control'],
+    sleep: ['control'],
+    wake: ['control'],
+    wake_add_rule: ['control'],
+    wake_remove_rule: ['control'],
+    event_tags: ['control'],
+    prose_help: ['control'],
+    // Files and blobs in the agent's own stores.
+    save_recent_image: ['files'],
+    read_image: ['files'],
+    // RFC-005 references resolve to the agent's own or private documents, not
+    // the public network (RFC-008 §4: private fetches are files/notes).
+    fetch_reference: ['files'],
+    // Runs code that may do anything: the class describes the tool.
+    code_execution: ['shell'],
+    // Built-in modules.
+    'discord--*': ['comms'],
+    'history--*': ['memory'],
+    'workspace--*': ['files'],
+    'health--*': ['control'],
+    'api--*': ['control'],
+};
+/**
+ * Read a server's class declaration from a tool definition's `_meta`.
+ * Returns the known classes it names (deduplicated, in order), or undefined
+ * when it names none — which makes the tool unclassed. Unknown strings are
+ * ignored for policy and logged (RFC-008 §3, vectors 3 and 4); a non-array
+ * value is malformed and ignored the same way.
+ */
+export function parseDeclaredClasses(meta, toolName = '(unnamed)') {
+    if (!meta || typeof meta !== 'object')
+        return undefined;
+    const raw = meta[TOOL_CLASS_META_KEY];
+    if (raw === undefined)
+        return undefined;
+    if (!Array.isArray(raw)) {
+        console.error(`[mcpl] ${toolName}: _meta["${TOOL_CLASS_META_KEY}"] is not an array — treated as unclassed`);
+        return undefined;
+    }
+    const out = [];
+    for (const value of raw) {
+        if (isToolClass(value)) {
+            if (!out.includes(value))
+                out.push(value);
+        }
+        else {
+            console.error(`[mcpl] ${toolName}: unknown tool class ${JSON.stringify(value)} ignored (RFC-008 §3)`);
+        }
+    }
+    return out.length > 0 ? out : undefined;
+}
+/**
+ * Validate a pattern → classes table from configuration. Unknown class
+ * strings are dropped with a diagnostic; an entry left with no class is
+ * dropped entirely (it cannot classify anything).
+ */
+export function normalizeClassTable(table, label) {
+    if (!table)
+        return [];
+    const out = [];
+    for (const [pattern, classes] of Object.entries(table)) {
+        const known = [];
+        for (const c of Array.isArray(classes) ? classes : []) {
+            if (isToolClass(c)) {
+                if (!known.includes(c))
+                    known.push(c);
+            }
+            else {
+                console.error(`[mcpl] ${label}["${pattern}"]: unknown tool class ${JSON.stringify(c)} ignored`);
+            }
+        }
+        if (known.length > 0)
+            out.push([pattern, known]);
+    }
+    return out;
+}
+/**
+ * Compute a tool's effective class (RFC-008 §5.1). `overrides` and `host`
+ * are ordered pattern tables (first matching pattern wins within a source);
+ * the first SOURCE that yields a class wins entirely — sources never merge,
+ * so an override can tighten or correct a server's declaration.
+ */
+export function resolveToolClass(toolName, declared, tables) {
+    for (const [pattern, classes] of tables.overrides) {
+        if (globMatch(pattern, toolName))
+            return { classes: [...classes], source: 'override' };
+    }
+    for (const [pattern, classes] of tables.host) {
+        if (globMatch(pattern, toolName))
+            return { classes: [...classes], source: 'host' };
+    }
+    if (declared && declared.length > 0)
+        return { classes: [...declared], source: 'server' };
+    return { classes: [], source: 'none' };
+}
+//# sourceMappingURL=tool-classes.js.map

package/dist/src/mcpl/tool-classes.js.map

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

package/dist/src/mcpl/tool-glob.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The portable pattern grammar of MCPL RFC-007 §6.2, used for `tools/observe`
+ * filters and (RFC-007 §17 open question 2) for this host's own tool-lifecycle
+ * narrowing and tool-class tables:
+ *
+ *   - `*` matches any sequence of zero or more characters;
+ *   - every other character matches itself (no escapes, no other metachars);
+ *   - matching is against the whole string, case-sensitive.
+ *
+ * Patterns are server-supplied, so matching must not backtrack without bound
+ * (RFC-007 §10 "Matching cost"). This is the classic two-pointer wildcard
+ * match: it remembers only the most recent `*`, so it runs in
+ * O(pattern × subject) worst case and never recurses.
+ */
+export declare function globMatch(pattern: string, subject: string): boolean;
+//# sourceMappingURL=tool-glob.d.ts.map

package/dist/src/mcpl/tool-glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-glob.d.ts","sourceRoot":"","sources":["../../../src/mcpl/tool-glob.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAqBnE"}

package/dist/src/mcpl/tool-glob.js

@@ -0,0 +1,41 @@
+/**
+ * The portable pattern grammar of MCPL RFC-007 §6.2, used for `tools/observe`
+ * filters and (RFC-007 §17 open question 2) for this host's own tool-lifecycle
+ * narrowing and tool-class tables:
+ *
+ *   - `*` matches any sequence of zero or more characters;
+ *   - every other character matches itself (no escapes, no other metachars);
+ *   - matching is against the whole string, case-sensitive.
+ *
+ * Patterns are server-supplied, so matching must not backtrack without bound
+ * (RFC-007 §10 "Matching cost"). This is the classic two-pointer wildcard
+ * match: it remembers only the most recent `*`, so it runs in
+ * O(pattern × subject) worst case and never recurses.
+ */
+export function globMatch(pattern, subject) {
+    let p = 0;
+    let s = 0;
+    let star = -1;
+    let mark = 0;
+    while (s < subject.length) {
+        if (p < pattern.length && pattern[p] !== '*' && pattern[p] === subject[s]) {
+            p++;
+            s++;
+        }
+        else if (p < pattern.length && pattern[p] === '*') {
+            star = p++;
+            mark = s;
+        }
+        else if (star !== -1) {
+            p = star + 1;
+            s = ++mark;
+        }
+        else {
+            return false;
+        }
+    }
+    while (p < pattern.length && pattern[p] === '*')
+        p++;
+    return p === pattern.length;
+}
+//# sourceMappingURL=tool-glob.js.map

package/dist/src/mcpl/tool-glob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-glob.js","sourceRoot":"","sources":["../../../src/mcpl/tool-glob.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,SAAS,CAAC,OAAe,EAAE,OAAe;IACxD,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC;IACd,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;QAC1B,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;YAC1E,CAAC,EAAE,CAAC;YACJ,CAAC,EAAE,CAAC;QACN,CAAC;aAAM,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;YACpD,IAAI,GAAG,CAAC,EAAE,CAAC;YACX,IAAI,GAAG,CAAC,CAAC;QACX,CAAC;aAAM,IAAI,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC;YACvB,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC;YACb,CAAC,GAAG,EAAE,IAAI,CAAC;QACb,CAAC;aAAM,CAAC;YACN,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IACD,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG;QAAE,CAAC,EAAE,CAAC;IACrD,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC;AAC9B,CAAC"}

package/dist/src/mcpl/tool-lifecycle.d.ts

@@ -0,0 +1,253 @@
+/**
+ * Tool lifecycle (MCPL RFC-007): `tools/lifecycle` notifications about the
+ * agent's tool calls, and the `tools/observe` filter a server sets on them.
+ *
+ * Authority is the grant plus host narrowing; a server's filter is interest
+ * and only ever narrows. Per call and connection the host decides, in order
+ * (RFC-007 §6.4):
+ *
+ *   1. reported at all?     grant `toolLifecycle.observe` + its narrowing
+ *   2. reported to this server?  filter: first matching rule and its `report`
+ *                           (no filter → yes)
+ *   3. arguments requested? that rule's `input` (no filter → NO)
+ *   4. arguments allowed?   grant `toolLifecycle.inputs` + its narrowing,
+ *                           and never for `comms` or unclassed tools
+ *   5. which fields, how large?  the rule's field selection, then the bound
+ *
+ * Tool RESULTS are never carried — no field for them exists here.
+ *
+ * Delivery is best-effort like `inference/lifecycle` (SPEC §10.5): one
+ * terminal is attempted per opened call, to exactly the connections the
+ * opening went to, unless their grant or narrowing no longer covers the call
+ * (RFC-007 §4.5). A filter change never suppresses a terminal (§6.5).
+ */
+import { CapabilityGrant } from './capability-grant.js';
+import { type ToolClass } from './tool-classes.js';
+export declare const TOOL_LIFECYCLE_OBSERVE = "toolLifecycle.observe";
+export declare const TOOL_LIFECYCLE_INPUTS = "toolLifecycle.inputs";
+export type ToolPhase = 'pending' | 'started' | 'completed' | 'failed' | 'aborted';
+/** `tools/lifecycle` params (Host → Server, Notification). RFC-007 §3. */
+export interface ToolLifecycleParams {
+    toolCallId: string;
+    inferenceId: string;
+    conversationId: string;
+    tool: string;
+    class: ToolClass[];
+    serverId?: string;
+    serverTool?: string;
+    phase: ToolPhase;
+    input?: Record<string, unknown>;
+    inputAltered?: boolean;
+    inputWithheld?: boolean;
+    isError?: boolean;
+    durationMs?: number;
+}
+export interface ToolObserveMatch {
+    tool?: string;
+    serverTool?: string;
+    serverId?: string;
+    conversationId?: string;
+    class?: ToolClass;
+}
+/** One normalized `tools/observe` rule (RFC-007 §6.1). */
+export interface ToolObserveRule {
+    match: ToolObserveMatch;
+    report: boolean;
+    /** false = metadata only; true = all arguments; string[] = field paths. */
+    input: boolean | string[];
+}
+/**
+ * A narrowing attached to one `toolLifecycle.*` grant entry (RFC-007 §4.3).
+ * A call is inside it when it satisfies EVERY key stated. Patterns use the
+ * RFC-007 §6.2 grammar.
+ */
+export interface ToolLifecycleNarrowing {
+    /** Patterns over the model-facing tool name (`computer--*`). */
+    tools?: string[];
+    /** The tool's effective class must intersect this set. `'default'` is
+     *  DEFAULT_INPUT_CLASSES (computer, shell, files, web, media, body). */
+    classes?: ToolClass[] | 'default';
+    /** Patterns over `conversationId` (the agent name in this host). */
+    conversations?: string[];
+}
+/**
+ * Per-server tool-lifecycle policy (`McplServerConfig.toolLifecycle`).
+ *
+ * Both capability paths are DENIED BY DEFAULT. Stating `observe` (even as
+ * `{}`) or `inputs` here is the operator's explicit grant of that path, as
+ * is naming it in `enabledCapabilities`. `inputs` is never unconditional:
+ * without at least one `tools` or `classes` term it delivers no arguments
+ * (RFC-007 §4.3).
+ */
+export interface ToolLifecycleConfig {
+    observe?: ToolLifecycleNarrowing;
+    inputs?: ToolLifecycleNarrowing;
+    /** Serialized-size bound for `input` per notification. Default 16 KiB. */
+    maxInputBytes?: number;
+}
+export declare const DEFAULT_MAX_INPUT_BYTES: number;
+/** Accepted sizes for a `tools/observe` request (RFC-007 §6.6 asks hosts to
+ *  accept at least 64 rules, 64 paths per rule, 256-character strings). */
+export declare const TOOL_OBSERVE_LIMITS: {
+    readonly rules: 256;
+    readonly pathsPerRule: 256;
+    readonly stringLength: 256;
+};
+export type ToolObserveParseResult = {
+    ok: true;
+    rules: ToolObserveRule[] | null;
+} | {
+    ok: false;
+    message: string;
+    data?: Record<string, unknown>;
+};
+/**
+ * Validate `tools/observe` params. `rules` absent or null clears the filter
+ * (`{ok, rules: null}`); `[]` is a valid filter that reports nothing. Unknown
+ * members are REJECTED, not ignored: ignoring an unknown `match` member would
+ * make a rule match more than its author wrote.
+ */
+export declare function parseToolObserveParams(params: unknown): ToolObserveParseResult;
+/** What the host knows about one call, shared by every connection. */
+export interface ToolCallDescriptor {
+    /** Host-unique on every connection (RFC-007 §3). */
+    toolCallId: string;
+    inferenceId: string;
+    conversationId: string;
+    tool: string;
+    class: ToolClass[];
+    serverId?: string;
+    serverTool?: string;
+    input: unknown;
+}
+/**
+ * `observe` narrowing: absent means no narrowing (the grant is enough). A
+ * value that is not a narrowing object (`false`, `null`, a string) admits
+ * nothing: a setting that looks like "off" must never read as "everything".
+ */
+export declare function observeAdmits(config: ToolLifecycleConfig | undefined, call: ToolCallDescriptor): boolean;
+/**
+ * Does `inputs` narrowing say this call has no tool/class term at all? Such
+ * an entry is unconditional and therefore treated as narrowed to NO tools
+ * (RFC-007 §4.3 — the widest form is not producible by omission).
+ */
+export declare function inputsNarrowingIsUnconditional(n: ToolLifecycleNarrowing | undefined): boolean;
+/** Class exclusions that no narrowing overrides (RFC-007 §4.3, §5.4). */
+export declare function inputsExcludedByClass(call: ToolCallDescriptor): boolean;
+export declare function inputsAdmit(config: ToolLifecycleConfig | undefined, call: ToolCallDescriptor): boolean;
+export declare function ruleMatches(match: ToolObserveMatch, call: ToolCallDescriptor): boolean;
+/**
+ * Select field paths from an arguments object. `.` descends into nested
+ * objects; a path ending on an object or array selects it whole; a path that
+ * passes through a non-object or names a missing member selects nothing.
+ * Selected members keep their place in the structure. Only OWN properties
+ * are read and the output is built from null-prototype objects, so a path
+ * like `__proto__.x` can neither read nor write a prototype.
+ */
+export declare function selectFields(input: Record<string, unknown>, paths: readonly string[]): Record<string, unknown>;
+/**
+ * Bound `value` to `maxBytes` of serialized JSON (RFC-007 §5.2): first by
+ * replacing the longest strings with prefixes of themselves, then by removing
+ * the largest members. The result is always a JSON object. Returns null when
+ * nothing meaningful fits — the caller withholds instead.
+ */
+export declare function boundInput(value: Record<string, unknown>, maxBytes: number): {
+    value: Record<string, unknown>;
+    altered: boolean;
+} | null;
+/** What the emitter needs from a connection. */
+export interface ToolLifecycleObserver {
+    id: string;
+    grant?: CapabilityGrant;
+    toolObserveFilter?: ToolObserveRule[] | null;
+    /** Increments at every transport boundary (reconnect). Terminals go only
+     *  to the epoch the opening went to. Absent = 0. */
+    transportEpoch?: number;
+    sendToolLifecycle(params: ToolLifecycleParams): void;
+}
+/**
+ * The opening notification (`pending` or `started`) this connection should
+ * receive for `call`, or null when it receives nothing. Steps 1–5 of
+ * RFC-007 §6.4.
+ */
+export declare function openingFor(observer: ToolLifecycleObserver, config: ToolLifecycleConfig | undefined, call: ToolCallDescriptor, phase: 'pending' | 'started'): ToolLifecycleParams | null;
+/** Does this connection still get the terminal for a call it was opened to? */
+export declare function terminalStillAllowed(observer: ToolLifecycleObserver, config: ToolLifecycleConfig | undefined, call: ToolCallDescriptor): boolean;
+export interface ToolLifecycleHost {
+    /** Every live connection that might observe. */
+    observers(): Iterable<ToolLifecycleObserver>;
+    /** Host policy for one connection. */
+    configFor(serverId: string): ToolLifecycleConfig | undefined;
+    /** Class and provider for a model-facing tool name. */
+    describe(tool: string): {
+        class: ToolClass[];
+        serverId?: string;
+        serverTool?: string;
+    };
+}
+export declare class ToolLifecycleEmitter {
+    private readonly host;
+    private readonly now;
+    /** Opened calls awaiting their terminal, keyed by (agent, model call id). */
+    private readonly calls;
+    private readonly recentIds;
+    private readonly recentOrder;
+    private mintSeq;
+    constructor(host: ToolLifecycleHost, now?: () => number);
+    /** Nothing observes: skip all work on the hot path. */
+    private anyObserver;
+    /**
+     * A host-unique id for a call (RFC-007 §3): the model's own only where the
+     * provider guarantees it unique and it was not reported recently; minted
+     * otherwise. Minted ids carry a per-process counter, so they never repeat.
+     */
+    private hostCallId;
+    /**
+     * A model-issued call is about to be dispatched. Recorded, keyed by
+     * (agent, model call id) — never matched through the trace stream, so two
+     * agents' identical short ids cannot cross — but nothing is sent yet: the
+     * host may still refuse it (refuse()) before it executes.
+     */
+    register(agentName: string, inferenceId: string, call: {
+        id: string;
+        name: string;
+        input: unknown;
+    }): void;
+    /**
+     * The host refused the call before executing it — its provider is gone,
+     * host tool policy denies it, a conversation-bound agent reached outside
+     * its channel. Called from the refusal site itself, synchronously within
+     * dispatch, so the call is forgotten before open() would send anything:
+     * a refused call produces no events (RFC-007 §3).
+     */
+    refuse(agentName: string, callId: string): void;
+    /**
+     * Dispatch returned and the call was not refused: execution has begun.
+     * Send `started` to every connection that should see it. Refusal sites
+     * run synchronously inside dispatch, before this.
+     */
+    open(agentName: string, callId: string): void;
+    /**
+     * The host could not obtain a result for this call (its dispatch threw,
+     * the provider's transport failed, the request timed out). Its terminal
+     * will be `failed`. An error RESULT returned by the tool is not this: it
+     * is `completed` with `isError` (RFC-007 §3).
+     */
+    markDispatchFailure(agentName: string, callId: string): void;
+    private terminate;
+    /** A tool result reached the host: the call's terminal. */
+    onResult(agentName: string, callId: string, result: {
+        success?: boolean;
+        isError?: boolean;
+    } | undefined): void;
+    /**
+     * A stream ended: its calls still open were cancelled before a result.
+     * Scoped to the inference ids that stream minted, so a successor stream
+     * for the same agent (a budget restart overlapping this one's teardown)
+     * keeps its live calls. A result arriving later finds nothing.
+     */
+    abortOpen(agentName: string, inferenceIds: Iterable<string>): void;
+    /** For tests and diagnostics. */
+    get openCount(): number;
+}
+//# sourceMappingURL=tool-lifecycle.d.ts.map

package/dist/src/mcpl/tool-lifecycle.d.ts.map

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