attention-manifest-protocol 0.4.2 → 0.4.3

package/src/boundary/frame.ts

@@ -1,322 +0,0 @@
-/**
- * Frame boundary: the only place a `Frame` may be constructed.
- *
- * The reference runtime builds frames from object literals, so a frame can
- * currently cite a target that does not exist, omit a reason, or carry an
- * unbounded exclusion list. This module turns those into rejections and returns
- * the part of the exclusion list that does not fit as `deferred`, so nothing is
- * silently dropped.
- *
- * The frame is not extended with new fields: `frame.schema.json` sets
- * `additionalProperties: false`, so aggregates belong to a later capacity layer,
- * not to this object.
- */
-import type { Id, Ref, Timestamp } from "../types/common.ts";
-import type { Frame, FrameBudget, FrameMode, Ignored, Impasse, Slot } from "../frame/frame.ts";
-
-import { digestOf } from "../semantic/canonical.ts";
-import { isId } from "./ids.ts";
-import { BoundaryRejection } from "../error/boundaryRejection.ts";
-import type { RefTable } from "./refTable.ts";
-
-/**
- * Draft accepted by {@link frameFrom}; `digest` is computed here, never supplied.
- */
-export interface FrameDraft {
-    id: Id;
-    agent: Id;
-    cycle: number;
-    ts?: Timestamp;
-    parent?: Ref;
-    mode: FrameMode;
-    goal?: Ref;
-    slots: Slot[];
-    ignored?: Ignored[];
-    budget: FrameBudget;
-    open_questions?: Ref[];
-    impasse?: Impasse;
-    note?: string;
-}
-
-export interface FrameBoundaryOptions {
-    /**
-     * May lower the schema ceiling of 9, never raise it. Defaults to 9.
-     */
-    maxSlots?: number;
-    /**
-     * Visible exclusions kept on the frame; the rest is returned as `deferred`. Defaults to 50.
-     */
-    maxIgnored?: number;
-    /**
-     * Clock for `ts` when the draft omits it. Hosts should pass their ledger clock.
-     */
-    now?: () => Timestamp;
-}
-
-export interface FrameBoundaryResult {
-    frame: Frame;
-    /**
-     * Exclusions beyond `maxIgnored`, in input order. Never silently dropped.
-     */
-    deferred: Ignored[];
-}
-
-const SchemaMaxSlots: number = 9;
-const DefaultMaxIgnored: number = 50;
-
-const BudgetDimensions: readonly string[] = ["tokens", "ms", "calls", "interrupts", "money"];
-const FrameModes: readonly FrameMode[] = ["explore", "exploit", "triage", "reflect", "rest"];
-const SlotRoles: readonly Slot["role"][] = ["goal", "question", "evidence", "concept", "process", "tool", "memory", "self", "other", "threat", "artifact"];
-const SlotStates: readonly Slot["state"][] = ["active", "released", "evicted", "done"];
-const IgnoredReasons: readonly Ignored["reason"][] = ["low_voi", "out_of_scope", "untrusted", "budget", "blocked", "habituated", "deferred"];
-const ImpasseStates: readonly Impasse["state"][] = ["TIE", "STUCK", "STALLED", "CONFLICT", "INFEASIBLE", "UNKNOWN", "UNVERIFIED", "DRIFT", "BUDGET"];
-const Tiers: readonly NonNullable<Slot["tier"]>[] = ["T0", "T1", "T2", "T3", "T4"];
-
-type ProblemChecker = (value: unknown, at: string, problems: string[]) => void;
-
-type RefTableChecker = (value: unknown, refs: RefTable, at: string, problems: string[]) => void;
-
-type FrameBoundaryBuilder = (draft: FrameDraft, refs: RefTable, options?: FrameBoundaryOptions) => FrameBoundaryResult;
-
-const isRecord: (value: unknown) => value is Record<string, unknown> = (value: unknown): value is Record<string, unknown> =>
-    typeof(value) === "object" && value !== null && !Array.isArray(value);
-
-const checkBudget: ProblemChecker = (value: unknown, at: string, problems: string[]): void => {
-    if (!isRecord(value)) {
-        problems.push(`${at} must be an object`);
-        return;
-    }
-    const budgetKeys: string[] = Object.keys(value);
-    for (let keyIndex: number = 0; keyIndex < budgetKeys.length; keyIndex += 1) {
-        const key: string = budgetKeys[keyIndex];
-        const amount: unknown = value[key];
-        if (!BudgetDimensions.includes(key)) {
-            problems.push(`${at}.${key} is not a budget dimension`);
-            continue;
-        }
-        if (typeof(amount) !== "number" || !Number.isFinite(amount) || amount < 0) {
-            problems.push(`${at}.${key} must be a non-negative finite number`);
-            continue;
-        }
-        if (key !== "money" && !Number.isInteger(amount)) {
-            problems.push(`${at}.${key} must be an integer`);
-        }
-    }
-};
-
-const checkRef: RefTableChecker = (value: unknown, refs: RefTable, at: string, problems: string[]): void => {
-    if (!isRecord(value)) {
-        problems.push(`${at} must be a Ref object`);
-        return;
-    }
-    if (typeof(value.kind) !== "string" || !isId(value.id)) {
-        problems.push(`${at} must have a string kind and a valid id`);
-        return;
-    }
-    if (!refs.has(value as unknown as Ref)) {
-        const problem: string | undefined = refs.check(value as unknown as Ref);
-        if (problem !== (void 0)) {
-            problems.push(`${at} ${problem}`);
-        }
-    }
-};
-
-const checkSlot: RefTableChecker = (value: unknown, refs: RefTable, at: string, problems: string[]): void => {
-    if (!isRecord(value)) {
-        problems.push(`${at} must be an object`);
-        return;
-    }
-    checkRef(value.target, refs, `${at}.target`, problems);
-    if (typeof(value.role) !== "string" || !SlotRoles.includes(value.role as Slot["role"])) {
-        problems.push(`${at}.role is not a slot role`);
-    }
-    const salience: unknown = value.salience;
-    if (typeof(salience) !== "number" || salience < 0 || salience > 1) {
-        problems.push(`${at}.salience must be in [0,1]`);
-    }
-    if (typeof(value.why) !== "string" || value.why.trim().length === 0) {
-        problems.push(`${at}.why is empty`);
-    }
-    checkBudget(value.cost, `${at}.cost`, problems);
-    if (typeof(value.state) !== "string" || !SlotStates.includes(value.state as Slot["state"])) {
-        problems.push(`${at}.state is not a slot state`);
-    }
-    if (value.tier !== (void 0) && (typeof(value.tier) !== "string" || !Tiers.includes(value.tier as NonNullable<Slot["tier"]>))) {
-        problems.push(`${at}.tier is not a tier`);
-    }
-    const voi: unknown = value.voi;
-    if (voi !== (void 0) && (typeof(voi) !== "number" || voi < 0 || voi > 1)) {
-        problems.push(`${at}.voi must be in [0,1]`);
-    }
-    if (value.budget !== (void 0)) {
-        checkBudget(value.budget, `${at}.budget`, problems);
-    }
-    const ttlTurns: unknown = value.ttl_turns;
-    if (ttlTurns !== (void 0) && (typeof(ttlTurns) !== "number" || !Number.isInteger(ttlTurns) || ttlTurns < 0)) {
-        problems.push(`${at}.ttl_turns must be a non-negative integer`);
-    }
-};
-
-const checkIgnored: RefTableChecker = (value: unknown, refs: RefTable, at: string, problems: string[]): void => {
-    if (!isRecord(value)) {
-        problems.push(`${at} must be an object`);
-        return;
-    }
-    checkRef(value.target, refs, `${at}.target`, problems);
-    if (typeof(value.reason) !== "string" || !IgnoredReasons.includes(value.reason as Ignored["reason"])) {
-        problems.push(`${at}.reason is not an ignored reason`);
-    }
-    if (typeof(value.revisit_if) !== "string" || value.revisit_if.trim().length === 0) {
-        problems.push(`${at}.revisit_if is empty`);
-    }
-};
-
-const checkImpasse: ProblemChecker = (value: unknown, at: string, problems: string[]): void => {
-    if (!isRecord(value)) {
-        problems.push(`${at} must be an object`);
-        return;
-    }
-    if (typeof(value.state) !== "string" || !ImpasseStates.includes(value.state as Impasse["state"])) {
-        problems.push(`${at}.state is not an impasse state`);
-    }
-    if (value.detail !== (void 0) && typeof(value.detail) !== "string") {
-        problems.push(`${at}.detail must be a string`);
-    }
-};
-
-/**
- * Validate a draft and return the only frame it permits.
- *
- * @throws BoundaryRejection `invalid_frame` with every problem found.
- */
-export const frameFrom: FrameBoundaryBuilder = (draft: FrameDraft, refs: RefTable, options: FrameBoundaryOptions = {}): FrameBoundaryResult => {
-    const problems: string[] = [];
-
-    if (!isId(draft.id)) {
-        problems.push("id is not a valid AMP id");
-    }
-    if (!isId(draft.agent)) {
-        problems.push("agent is not a valid AMP id");
-    }
-    if (!Number.isSafeInteger(draft.cycle) || draft.cycle < 0) {
-        problems.push("cycle must be a non-negative integer");
-    }
-    if (!FrameModes.includes(draft.mode)) {
-        problems.push("mode is not a frame mode");
-    }
-
-    const ts: Timestamp = draft.ts ?? (options.now ? options.now() : new Date().toISOString());
-    if (typeof(ts) !== "string" || Number.isNaN(Date.parse(ts))) {
-        problems.push("ts is not a date-time");
-    }
-
-    const requestedMaxSlots: number = options.maxSlots ?? SchemaMaxSlots;
-    if (!Number.isInteger(requestedMaxSlots) || requestedMaxSlots < 0 || requestedMaxSlots > SchemaMaxSlots) {
-        problems.push(`maxSlots must be an integer in [0,${SchemaMaxSlots}]`);
-    }
-    const maxSlots: number = Math.min(Math.max(0, requestedMaxSlots), SchemaMaxSlots);
-
-    const requestedMaxIgnored: number = options.maxIgnored ?? DefaultMaxIgnored;
-    if (!Number.isInteger(requestedMaxIgnored) || requestedMaxIgnored < 0) {
-        problems.push("maxIgnored must be a non-negative integer");
-    }
-    const maxIgnored: number = Math.max(0, requestedMaxIgnored);
-
-    if (!Array.isArray(draft.slots)) {
-        problems.push("slots must be an array");
-    } else {
-        if (draft.slots.length > maxSlots) {
-            problems.push(`slots has ${draft.slots.length} entries, max is ${maxSlots}`);
-        }
-        draft.slots.forEach((slot, index) => checkSlot(slot, refs, `slots[${index}]`, problems));
-    }
-
-    const declaredIgnored: unknown = draft.ignored;
-    const ignored: Ignored[] = Array.isArray(declaredIgnored) ? declaredIgnored : [];
-    if (declaredIgnored !== (void 0) && !Array.isArray(declaredIgnored)) {
-        problems.push("ignored must be an array");
-    }
-    ignored.forEach((item, index) => checkIgnored(item, refs, `ignored[${index}]`, problems));
-
-    const budgetValue: unknown = draft.budget;
-    if (!isRecord(budgetValue)) {
-        problems.push("budget must be an object");
-    } else {
-        const allocated: unknown = budgetValue.allocated;
-        const spent: unknown = budgetValue.spent;
-        checkBudget(allocated, "budget.allocated", problems);
-        checkBudget(spent, "budget.spent", problems);
-        if (isRecord(allocated) && isRecord(spent)) {
-            if (Object.keys(allocated).length === 0) {
-                problems.push("budget.allocated must set at least one dimension");
-            }
-            for (let dimensionIndex: number = 0; dimensionIndex < BudgetDimensions.length; dimensionIndex += 1) {
-                const key: string = BudgetDimensions[dimensionIndex];
-                const limit: unknown = allocated[key];
-                const used: unknown = spent[key];
-                if (typeof(limit) === "number" && typeof(used) === "number" && used > limit) {
-                    problems.push(`budget.spent.${key} exceeds budget.allocated.${key}`);
-                }
-            }
-        }
-    }
-
-    if (draft.parent !== (void 0)) {
-        checkRef(draft.parent, refs, "parent", problems);
-    }
-    if (draft.goal !== (void 0)) {
-        checkRef(draft.goal, refs, "goal", problems);
-    }
-    if (draft.open_questions !== (void 0)) {
-        if (!Array.isArray(draft.open_questions)) {
-            problems.push("open_questions must be an array");
-        } else {
-            draft.open_questions.forEach((ref, index) => checkRef(ref, refs, `open_questions[${index}]`, problems));
-        }
-    }
-    if (draft.impasse !== (void 0)) {
-        checkImpasse(draft.impasse, "impasse", problems);
-    }
-    if (draft.note !== (void 0) && typeof(draft.note) !== "string") {
-        problems.push("note must be a string");
-    }
-
-    if (problems.length > 0) {
-        throw new BoundaryRejection("invalid_frame", problems);
-    }
-
-    const visible: Ignored[] = ignored.slice(0, maxIgnored);
-    const deferred: Ignored[] = ignored.slice(maxIgnored);
-    const body: Omit<Frame, "digest"> = {
-        amp: "0.1",
-        kind: "frame",
-        id: draft.id,
-        agent: draft.agent,
-        cycle: draft.cycle,
-        ts,
-        mode: draft.mode,
-        slots: [...draft.slots],
-        budget: { allocated: { ...draft.budget.allocated }, spent: { ...draft.budget.spent } },
-    };
-    if (draft.parent !== (void 0)) {
-        body.parent = draft.parent;
-    }
-    if (draft.goal !== (void 0)) {
-        body.goal = draft.goal;
-    }
-    if (visible.length > 0) {
-        body.ignored = visible;
-    }
-    if (draft.open_questions !== (void 0)) {
-        body.open_questions = [...draft.open_questions];
-    }
-    if (draft.impasse !== (void 0)) {
-        body.impasse = draft.impasse;
-    }
-    if (draft.note !== (void 0)) {
-        body.note = draft.note;
-    }
-
-    const frame: Frame = { ...body, digest: digestOf(body) };
-    return { frame, deferred };
-};

package/src/boundary/ids.ts

@@ -1,14 +0,0 @@
-/**
- * Identifier grammar from `docs/schemas/common.schema.json#/$defs/id`.
- *
- * An id that does not match this pattern cannot be referenced by any other AMP
- * object, so the boundary rejects it instead of creating an object nothing can
- * point at.
- */
-
-/**
- * Top-level data, hence PascalCase under the project's naming rule.
- */
-const IdPattern: RegExp = /^[a-z][a-z0-9._:-]{0,63}$/;
-
-export const isId: (value: unknown) => value is string = (value: unknown): value is string => typeof(value) === "string" && IdPattern.test(value);

package/src/boundary/index.ts

@@ -1,12 +0,0 @@
-/**
- * Boundary barrel: constructors that reject instead of returning invalid objects.
- */
-export { BoundaryRejection } from "../error/boundaryRejection.ts";
-export type { BoundaryCode } from "../error/boundaryRejection.ts";
-export { isId } from "./ids.ts";
-export { RefTable } from "./refTable.ts";
-export type { RefScope } from "./refTable.ts";
-export { frameFrom } from "./frame.ts";
-export type { FrameBoundaryOptions, FrameBoundaryResult, FrameDraft } from "./frame.ts";
-export { parseToolCall } from "./toolCall.ts";
-export type { ParsedToolCall, ToolSchema } from "./toolCall.ts";

package/src/boundary/refTable.ts

@@ -1,125 +0,0 @@
-/**
- * Reference resolution for the construction boundary.
- *
- * A `Ref` is only a pointer. Until it is resolved against a scope, nothing
- * prevents it from naming an object that does not exist — which is how a frame
- * ends up citing a tool, concept or claim that the ledger never held. The table
- * makes resolution explicit and gives the scope a name, so "unresolvable" is a
- * rejection rather than a silent dangling pointer.
- *
- * Canonicalisation rules:
- * - `tool` and `capability` share one namespace; the `mcp.` prefix is transport
- *   detail, not identity.
- * - `self` resolves to the agent id registered for the scope.
- */
-import type { Id, Ref, RefKind } from "../types/common.ts";
-
-import { isId } from "./ids.ts";
-import { BoundaryRejection } from "../error/boundaryRejection.ts";
-
-/**
- * Where a reference is expected to resolve.
- */
-export type RefScope = "run" | "ledger" | "bundle";
-
-/**
- * Kinds that name something outside the ledger. They still need a valid id and
- * a kind, but they cannot be required to resolve here: a human, an org or an
- * external entity lives in a directory the host owns, not in the run.
- */
-const DefaultOpaqueKinds: readonly RefKind[] = ["human", "org", "entity", "other"];
-
-const stripToolPrefix = (id: string): string => (id.startsWith("mcp.") ? id.slice(4) : id);
-
-const canonicalId = (kind: RefKind, id: string): string => `${kind}:${kind === "tool" ? stripToolPrefix(id) : id}`;
-
-export class RefTable {
-    readonly scope: RefScope;
-    readonly opaqueKinds: ReadonlySet<RefKind>;
-    private readonly entries: Map<string, unknown>;
-
-    constructor(scope: RefScope, agentId?: string, opaqueKinds: readonly RefKind[] = DefaultOpaqueKinds) {
-        this.scope = scope;
-        this.opaqueKinds = new Set<RefKind>(opaqueKinds);
-        this.entries = new Map<string, unknown>();
-        if (agentId !== (void 0)) {
-            this.entries.set(`agent:${agentId}`, { kind: "self", id: agentId });
-        }
-    }
-
-    static forScope(scope: RefScope, agentId?: string, opaqueKinds?: readonly RefKind[]): RefTable {
-        return new RefTable(scope, agentId, opaqueKinds);
-    }
-
-    /**
-     * Register an object under its reference key.
-     *
-     * @throws BoundaryRejection `invalid_id` when the id cannot be referenced,
-     * `duplicate_ref` when the same key is registered twice.
-     */
-    add(kind: RefKind, id: Id, value: unknown): this {
-        if (!isId(id)) {
-            throw new BoundaryRejection("invalid_id", [`${kind}:${id} is not a valid AMP id`]);
-        }
-        const key: string = canonicalId(kind, id);
-        if (this.entries.has(key)) {
-            throw new BoundaryRejection("duplicate_ref", [`${key} is already registered in scope ${this.scope}`]);
-        }
-        this.entries.set(key, value);
-        return this;
-    }
-
-    resolve(ref: Ref): unknown | undefined {
-        if (!isId(ref.id)) {
-            return (void 0);
-        }
-        const direct: unknown = this.entries.get(canonicalId(ref.kind, ref.id));
-        if (direct !== (void 0)) {
-            return direct;
-        }
-        if (ref.kind === "tool") {
-            return this.entries.get(`capability:${stripToolPrefix(ref.id)}`);
-        }
-        if (ref.kind === "self") {
-            return this.entries.get(`agent:${ref.id}`);
-        }
-        return (void 0);
-    }
-
-    /**
-     * Resolve or reject. The message names the scope so a host can tell a
-     * missing run object from a missing federated object.
-     */
-    require(ref: Ref): unknown {
-        const hit: unknown = this.resolve(ref);
-        if (hit === (void 0)) {
-            throw new BoundaryRejection("unresolvable_ref", [`${ref.kind}:${ref.id} is not present in scope ${this.scope}`]);
-        }
-        return hit;
-    }
-
-    has(ref: Ref): boolean {
-        return this.resolve(ref) !== (void 0);
-    }
-
-    /**
-     * Resolution verdict used by `frameFrom`.
-     *
-     * Opaque kinds pass on shape alone; every other kind must be present in the
-     * scope. Returns a problem string instead of throwing so callers can report
-     * every dangling reference at once.
-     */
-    check(ref: Ref): string | undefined {
-        if (this.opaqueKinds.has(ref.kind)) {
-            return (void 0);
-        }
-        if (this.resolve(ref) !== (void 0)) {
-            return (void 0);
-        }
-        return `${ref.kind}:${ref.id} is not present in scope ${this.scope}`;
-    }
-
-    get size(): number {
-        return this.entries.size;
-    }
-}

package/src/boundary/toolCall.ts

@@ -1,212 +0,0 @@
-/**
- * Tool-call boundary: parse arguments before anything touches the world.
- *
- * The reference executor passes `Record<string, unknown>` straight to a server.
- * This module checks the arguments against the tool's `inputSchema` and returns
- * a digest of exactly what was accepted, so an approval can bind to the parsed
- * call instead of to a mutable object.
- *
- * The validator implements the subset of JSON Schema that MCP tool definitions
- * actually use: `type`, `properties`, `required`, `additionalProperties`,
- * `items`, `enum`, `const`, `anyOf`/`oneOf`/`allOf`, length and numeric bounds,
- * and `pattern`. Keywords outside that subset are ignored rather than guessed
- * at; a schema that needs more should be narrowed before it reaches this layer.
- */
-import type { Digest } from "../types/common.ts";
-
-import { canonical, digestOf } from "../semantic/canonical.ts";
-import { BoundaryRejection } from "../error/boundaryRejection.ts";
-
-export interface ToolSchema {
-    name: string;
-    inputSchema: unknown;
-}
-
-export interface ParsedToolCall {
-    tool: string;
-    args: Record<string, unknown>;
-    /**
-     * Digest of the accepted arguments; approvals bind to this value.
-     */
-    digest: Digest;
-}
-
-const isRecord: (value: unknown) => value is Record<string, unknown> = (value: unknown): value is Record<string, unknown> =>
-    typeof(value) === "object" && value !== null && !Array.isArray(value);
-
-const matchesType: (type: string, value: unknown) => boolean = (type: string, value: unknown): boolean => {
-    if (type === "null") {
-        return value === null;
-    }
-    if (type === "array") {
-        return Array.isArray(value);
-    }
-    if (type === "object") {
-        return isRecord(value);
-    }
-    if (type === "string") {
-        return typeof(value) === "string";
-    }
-    if (type === "boolean") {
-        return typeof(value) === "boolean";
-    }
-    if (type === "number") {
-        return typeof(value) === "number" && Number.isFinite(value);
-    }
-    if (type === "integer") {
-        return typeof(value) === "number" && Number.isInteger(value);
-    }
-    return true;
-};
-
-type SchemaCheck = (schema: unknown, value: unknown, at: string, depth: number, problems: string[]) => void;
-
-const checkSchema: SchemaCheck = (schema: unknown, value: unknown, at: string, depth: number, problems: string[]): void => {
-    if (depth > 32) {
-        problems.push(`${at}: schema nesting exceeds 32`);
-        return;
-    }
-    if (!isRecord(schema)) {
-        problems.push(`${at}: schema must be an object`);
-        return;
-    }
-
-    if ("const" in schema && canonical(schema.const) !== canonical(value)) {
-        problems.push(`${at} must equal the const value`);
-    }
-    if (Array.isArray(schema.enum) && !schema.enum.some((item) => canonical(item) === canonical(value))) {
-        problems.push(`${at} is not one of the allowed values`);
-    }
-    if (Array.isArray(schema.allOf)) {
-        schema.allOf.forEach((branch) => checkSchema(branch, value, at, depth + 1, problems));
-    }
-    if (Array.isArray(schema.anyOf) && !schema.anyOf.some((branch) => schemaMatches(branch, value, depth + 1))) {
-        problems.push(`${at} matches none of anyOf`);
-    }
-    if (Array.isArray(schema.oneOf)) {
-        const matched: number = schema.oneOf.filter((branch) => schemaMatches(branch, value, depth + 1)).length;
-        if (matched !== 1) {
-            problems.push(`${at} matches ${matched} of oneOf, expected exactly 1`);
-        }
-    }
-
-    const declared: unknown = schema.type;
-    const types: string[] = Array.isArray(declared)
-        ? declared.filter((item): item is string => typeof(item) === "string")
-        : typeof(declared) === "string"
-          ? [declared]
-          : [];
-    if (types.length > 0 && !types.some((type) => matchesType(type, value))) {
-        problems.push(`${at} expected ${types.join("|")}`);
-        return;
-    }
-
-    if (Array.isArray(value)) {
-        if (Array.isArray(schema.items)) {
-            schema.items.forEach((item, index) => {
-                if (index < value.length) {
-                    checkSchema(item, value[index], `${at}[${index}]`, depth + 1, problems);
-                }
-            });
-        } else if (schema.items !== (void 0)) {
-            value.forEach((item, index) => checkSchema(schema.items, item, `${at}[${index}]`, depth + 1, problems));
-        }
-        const minItems: unknown = schema.minItems;
-        const maxItems: unknown = schema.maxItems;
-        if (typeof(minItems) === "number" && value.length < minItems) {
-            problems.push(`${at} needs at least ${minItems} items`);
-        }
-        if (typeof(maxItems) === "number" && value.length > maxItems) {
-            problems.push(`${at} allows at most ${maxItems} items`);
-        }
-        return;
-    }
-
-    if (isRecord(value)) {
-        const required: unknown = schema.required;
-        if (Array.isArray(required)) {
-            for (let index: number = 0; index < required.length; index += 1) {
-                const name: unknown = required[index];
-                if (typeof(name) === "string" && !(name in value)) {
-                    problems.push(`${at}.${name} is required`);
-                }
-            }
-        }
-        const properties: unknown = schema.properties;
-        if (isRecord(properties)) {
-            const keys: string[] = Object.keys(value);
-            for (let index: number = 0; index < keys.length; index += 1) {
-                const key: string = keys[index];
-                const child: unknown = properties[key];
-                if (child !== (void 0)) {
-                    checkSchema(child, value[key], `${at}.${key}`, depth + 1, problems);
-                } else if (schema.additionalProperties === false) {
-                    problems.push(`${at}.${key} is not allowed`);
-                }
-            }
-        } else if (schema.additionalProperties === false && Object.keys(value).length > 0) {
-            problems.push(`${at} does not allow properties`);
-        }
-        return;
-    }
-
-    if (typeof(value) === "string") {
-        const minLength: unknown = schema.minLength;
-        const maxLength: unknown = schema.maxLength;
-        const pattern: unknown = schema.pattern;
-        if (typeof(minLength) === "number" && value.length < minLength) {
-            problems.push(`${at} is shorter than ${minLength}`);
-        }
-        if (typeof(maxLength) === "number" && value.length > maxLength) {
-            problems.push(`${at} is longer than ${maxLength}`);
-        }
-        if (typeof(pattern) === "string") {
-            try {
-                if (!new RegExp(pattern).test(value)) {
-                    problems.push(`${at} does not match ${pattern}`);
-                }
-            } catch {
-                problems.push(`${at} has an invalid pattern`);
-            }
-        }
-    }
-
-    if (typeof(value) === "number") {
-        const minimum: unknown = schema.minimum;
-        const maximum: unknown = schema.maximum;
-        if (typeof(minimum) === "number" && value < minimum) {
-            problems.push(`${at} is below ${minimum}`);
-        }
-        if (typeof(maximum) === "number" && value > maximum) {
-            problems.push(`${at} is above ${maximum}`);
-        }
-    }
-};
-
-const schemaMatches: (schema: unknown, value: unknown, depth: number) => boolean = (schema: unknown, value: unknown, depth: number): boolean => {
-    const problems: string[] = [];
-    checkSchema(schema, value, "$", depth, problems);
-    return problems.length === 0;
-};
-
-/**
- * Parse a tool call's arguments against its declared schema.
- *
- * @throws BoundaryRejection `invalid_tool_args` with every problem found.
- */
-export const parseToolCall: (tool: ToolSchema, raw: unknown) => ParsedToolCall = (tool: ToolSchema, raw: unknown): ParsedToolCall => {
-    const problems: string[] = [];
-    if (typeof(tool.name) !== "string" || tool.name.length === 0) {
-        problems.push("tool.name is empty");
-    }
-    if (!isRecord(raw)) {
-        problems.push("arguments must be an object");
-    } else {
-        checkSchema(tool.inputSchema, raw, "$", 0, problems);
-    }
-    if (problems.length > 0) {
-        throw new BoundaryRejection("invalid_tool_args", problems);
-    }
-    const args: Record<string, unknown> = raw as Record<string, unknown>;
-    return { tool: tool.name, args, digest: digestOf(args) };
-};