@namzu/sdk 46.0.0 → 48.1.0

package/dist/toolsets/combine.d.ts

@@ -0,0 +1,44 @@
+import { RegistryCollisionError } from '../registry/collision.js';
+import type { ToolSource, Toolset } from './types.js';
+/**
+ * Two toolsets (or one toolset, twice) contributed a tool with the same
+ * name, and `combineToolsets` cannot decide which one wins.
+ *
+ * Named, and carrying both sources, for the reason `ToolNameCollisionError`
+ * (`registry/tool/execute.ts`) is: a caller that wants to handle this —
+ * rename one side, refuse the whole config — has to be able to catch it
+ * narrowly and read who collided, not match on message text. Extends
+ * `RegistryCollisionError` (`registry/collision.ts`) like every other
+ * `*CollisionError`, with `combineToolsets` as the "registry" name and the
+ * tool name as the colliding id; `firstSource`/`secondSource` are this
+ * class's own addition, since a plain `RegistryCollisionError` has nowhere
+ * to carry two whole sources.
+ */
+export declare class ToolsetConflictError extends RegistryCollisionError {
+    readonly toolName: string;
+    readonly firstSource: ToolSource;
+    readonly secondSource: ToolSource;
+    constructor(toolName: string, firstSource: ToolSource, secondSource: ToolSource);
+}
+/**
+ * Merge toolsets into one, under a new umbrella `source`.
+ *
+ * Atomic: `tools()` either returns the full merged list or throws
+ * {@link ToolsetConflictError} — never a partial list. Every call
+ * recomputes from the inner toolsets' current `tools()`, so this composes
+ * with live sources: a name that only collides after an inner toolset's
+ * `onChange` fires is caught the next time `tools()` is called, exactly
+ * like any other change.
+ *
+ * Order is deterministic: toolset order (as given), then each toolset's own
+ * tool order — the same rule `ToolManager` uses.
+ *
+ * `onChange`/`close` are defined only if at least one inner toolset defines
+ * them — this never fabricates a live capability none of its inputs have.
+ * `onChange`'s listener is handed straight to every inner toolset that has
+ * one; the returned unsubscribe tears down every one of those
+ * subscriptions, so a change three layers down still reaches it and
+ * unsubscribing here cleans up all of them.
+ */
+export declare function combineToolsets(source: ToolSource | string, toolsets: readonly Toolset[]): Toolset;
+//# sourceMappingURL=combine.d.ts.map

package/dist/toolsets/combine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"combine.d.ts","sourceRoot":"","sources":["../../src/toolsets/combine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAA;AAEjE,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAuB,MAAM,YAAY,CAAA;AAE1E;;;;;;;;;;;;;GAaG;AACH,qBAAa,oBAAqB,SAAQ,sBAAsB;IAC/D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAA;IAChC,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAA;gBAErB,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU;CAe/E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAC9B,MAAM,EAAE,UAAU,GAAG,MAAM,EAC3B,QAAQ,EAAE,SAAS,OAAO,EAAE,GAC1B,OAAO,CAgET"}

package/dist/toolsets/combine.js

@@ -0,0 +1,153 @@
+import { RegistryCollisionError } from '../registry/collision.js';
+/**
+ * Two toolsets (or one toolset, twice) contributed a tool with the same
+ * name, and `combineToolsets` cannot decide which one wins.
+ *
+ * Named, and carrying both sources, for the reason `ToolNameCollisionError`
+ * (`registry/tool/execute.ts`) is: a caller that wants to handle this —
+ * rename one side, refuse the whole config — has to be able to catch it
+ * narrowly and read who collided, not match on message text. Extends
+ * `RegistryCollisionError` (`registry/collision.ts`) like every other
+ * `*CollisionError`, with `combineToolsets` as the "registry" name and the
+ * tool name as the colliding id; `firstSource`/`secondSource` are this
+ * class's own addition, since a plain `RegistryCollisionError` has nowhere
+ * to carry two whole sources.
+ */
+export class ToolsetConflictError extends RegistryCollisionError {
+    toolName;
+    firstSource;
+    secondSource;
+    constructor(toolName, firstSource, secondSource) {
+        const detail = firstSource.id === secondSource.id
+            ? `toolset "${firstSource.id}" contributes it more than once`
+            : `it is contributed by both "${firstSource.id}" and "${secondSource.id}"`;
+        super('combineToolsets', toolName, `combineToolsets: tool name "${toolName}" is not unique — ${detail}. Wrap one contributor with prefixed(toolset, prefix) (or renamed(toolset, { ${toolName}: "..." })) before combining.`);
+        this.name = 'ToolsetConflictError';
+        this.toolName = toolName;
+        this.firstSource = firstSource;
+        this.secondSource = secondSource;
+    }
+}
+/**
+ * Merge toolsets into one, under a new umbrella `source`.
+ *
+ * Atomic: `tools()` either returns the full merged list or throws
+ * {@link ToolsetConflictError} — never a partial list. Every call
+ * recomputes from the inner toolsets' current `tools()`, so this composes
+ * with live sources: a name that only collides after an inner toolset's
+ * `onChange` fires is caught the next time `tools()` is called, exactly
+ * like any other change.
+ *
+ * Order is deterministic: toolset order (as given), then each toolset's own
+ * tool order — the same rule `ToolManager` uses.
+ *
+ * `onChange`/`close` are defined only if at least one inner toolset defines
+ * them — this never fabricates a live capability none of its inputs have.
+ * `onChange`'s listener is handed straight to every inner toolset that has
+ * one; the returned unsubscribe tears down every one of those
+ * subscriptions, so a change three layers down still reaches it and
+ * unsubscribing here cleans up all of them.
+ */
+export function combineToolsets(source, toolsets) {
+    const resolvedSource = typeof source === 'string' ? { id: source, kind: 'host_tool', name: source } : source;
+    // Omitted rather than set to `'active'`: absent already means `'active'`
+    // (`Toolset.availability`'s own doc comment), so this only adds the field
+    // for the one case worth stating explicitly — every input agreeing on
+    // `'deferred'`.
+    const availability = uniformAvailability(resolvedSource.id, toolsets);
+    const combined = {
+        source: resolvedSource,
+        tools: () => mergeTools(toolsets),
+        ...(availability === 'deferred' ? { availability } : {}),
+        ...(toolsets.some((inner) => inner.isReady)
+            ? { isReady: () => toolsets.every((inner) => inner.isReady?.() ?? true) }
+            : {}),
+    };
+    const liveOnChange = toolsets.filter((inner) => inner.onChange !== undefined);
+    if (liveOnChange.length > 0) {
+        combined.onChange = (listener) => {
+            const unsubscribes = [];
+            const unsubscribeAll = () => {
+                const errors = [];
+                for (const unsubscribe of unsubscribes.splice(0).reverse()) {
+                    try {
+                        unsubscribe();
+                    }
+                    catch (error) {
+                        errors.push(error);
+                    }
+                }
+                if (errors.length === 1)
+                    throw errors[0];
+                if (errors.length > 1)
+                    throw new AggregateError(errors, 'Toolset listener cleanup failed.');
+            };
+            try {
+                for (const inner of liveOnChange)
+                    unsubscribes.push(inner.onChange(listener));
+            }
+            catch (error) {
+                try {
+                    unsubscribeAll();
+                }
+                catch (cleanupError) {
+                    throw new AggregateError([error, cleanupError], 'Toolset subscription and cleanup failed.');
+                }
+                throw error;
+            }
+            return unsubscribeAll;
+        };
+    }
+    const closeFns = toolsets
+        .map((inner) => inner.close)
+        .filter((close) => close !== undefined);
+    if (closeFns.length > 0) {
+        combined.close = async () => {
+            await Promise.all(closeFns.map((close) => close()));
+        };
+    }
+    return combined;
+}
+/**
+ * The one `availability` a merged toolset may report, or `undefined` when
+ * there is nothing to report (no inputs).
+ *
+ * A `Toolset` has exactly one `availability` for every tool it contributes —
+ * there is no per-tool field, and `ToolManager` derives a name's default
+ * from whichever ARRAY ENTRY owns it (`manager.ts`'s `availability`; the
+ * same rule `runtime/query/index.ts` documents at its own two-entry
+ * `runtime:active`/`runtime:deferred` split, which it keeps unmerged for
+ * exactly this reason). Silently defaulting a mixed merge to `'active'`
+ * would misreport every `deferred` input's tools as always active, with
+ * nothing in the returned `Toolset` to say so. So a mix throws here,
+ * naming the two sources that disagree, rather than combining them.
+ */
+function uniformAvailability(combinedId, toolsets) {
+    let agreed;
+    for (const inner of toolsets) {
+        const availability = inner.availability ?? 'active';
+        if (!agreed) {
+            agreed = { availability, source: inner.source };
+            continue;
+        }
+        if (agreed.availability !== availability) {
+            throw new Error(`combineToolsets("${combinedId}"): "${agreed.source.id}" is ${agreed.availability} and "${inner.source.id}" is ${availability}. combineToolsets reports one availability for the whole merged toolset, so combining toolsets that disagree would silently report the deferred side's tools as active. Combine toolsets that share an availability, or keep the eager and deferred halves as separate entries in the caller's own toolsets array instead of merging them.`);
+        }
+    }
+    return agreed?.availability;
+}
+function mergeTools(toolsets) {
+    const ownerByToolName = new Map();
+    const merged = [];
+    for (const inner of toolsets) {
+        for (const tool of inner.tools()) {
+            const owner = ownerByToolName.get(tool.name);
+            if (owner)
+                throw new ToolsetConflictError(tool.name, owner, inner.source);
+            ownerByToolName.set(tool.name, inner.source);
+            merged.push(tool);
+        }
+    }
+    return merged;
+}
+//# sourceMappingURL=combine.js.map

package/dist/toolsets/combine.js.map

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

package/dist/toolsets/manager.d.ts

@@ -0,0 +1,201 @@
+import type { ToolResultGuardrailSpec } from '../types/guardrail/index.js';
+import type { Message, ToolRevealReceipt } from '../types/message/index.js';
+import type { LLMToolSchema, PreparedToolExecution, ToolAvailability, ToolContext, ToolDefinition, ToolExecutionResult, ToolPreparationResult, ToolTierConfig, ToolsView } from '../types/tool/index.js';
+import type { ToolSourceRef, Toolset } from './types.js';
+export type { ToolExecutionResult };
+/**
+ * What `refresh()` reports after re-resolving a live toolset's change.
+ *
+ * `refused` is a newly-contributed name that would have collided with a name
+ * already served by another toolset — the incumbent keeps serving and the
+ * newcomer never reaches the manager, unlike a construction-time collision,
+ * which throws instead (nothing was serving anyone yet, so there is nothing
+ * to protect by continuing).
+ */
+export interface ToolsetChangeReport {
+    /** Names a toolset started contributing that nobody else already served. */
+    readonly added: readonly string[];
+    /** Names whose owning toolset stopped contributing them, with no other toolset picking them up. */
+    readonly removed: readonly string[];
+    /**
+     * Names whose OWNING toolset now returns a different `ToolDefinition`
+     * object under the same name. The previously admitted definition keeps
+     * serving — see the class doc on why identity, not content, is what
+     * `toLLMTools`'s prompt-cache stability depends on.
+     */
+    readonly drifted: readonly string[];
+    /** A new contributor for a name some other toolset already serves. Refused, not applied. */
+    readonly refused: readonly {
+        readonly name: string;
+        readonly reason: string;
+    }[];
+}
+export interface ToolManagerConfig {
+    readonly toolsets: readonly Toolset[];
+    /**
+     * Screens run against every tool result before anything downstream reads
+     * it. Wins over whatever the turn's own `ToolContext.toolResultGuardrails`
+     * supplies when this is present — including `[]`, which means none —
+     * because a manager built with an explicit policy has stated it. See
+     * `executeRetained` below.
+     */
+    readonly resultGuardrails?: readonly ToolResultGuardrailSpec[];
+    readonly tierConfig?: ToolTierConfig;
+    /**
+     * The turn's own message history, read fresh on every `availability`
+     * call rather than captured once — see {@link ToolManager.availability}.
+     */
+    readonly messages: () => readonly Message[];
+}
+/**
+ * The runtime-owned resolver of {@link Toolset}s.
+ *
+ * It is built once from a fixed list of toolsets and never mutates its own
+ * membership: a toolset changing live (`onChange`) is only adopted when the caller calls
+ * {@link refresh}, at an iteration boundary the caller chooses — never
+ * mid-call. This is what keeps `toLLMTools`'s wire rendering byte-stable
+ * between refreshes: `toolWireSchema` (`registry/tool/schema.ts`) memoizes a
+ * tool's rendered schema by the object identity of `ToolDefinition.inputSchema`,
+ * not by anything owned by whichever object resolved the tool, so returning
+ * the SAME `ToolDefinition` object for the same name across calls — which a
+ * fixed, never-mutated resolution trivially does — is what keeps the cache
+ * hit.
+ *
+ * Availability has no stored, mutable map (unlike `ToolRegistry.availability`).
+ * It is DERIVED: an unready source is suspended; otherwise a tool is
+ * deferred iff its owner declared `deferred()` and no source-bound receipt
+ * in the turn's post-compaction history has loaded its schema. See
+ * {@link ToolManager.availability}.
+ *
+ * The execution pipeline below (`prepareExecution`/`executePrepared`/
+ * `execute`/`executeRetained`) is copied from `ToolRegistry`'s, per plan.md
+ * §2: "Diff it line by line; the only permitted changes are where it read
+ * `this.availability`, `tool.provenance` or registry identity." Those three
+ * substitutions are exactly: `this.availability(name)` (derived, above) for
+ * `this.getAvailability(name)`; `this.sourceOf(name)` for `tool.provenance`;
+ * and `this.toolsByName` for `this.items`. Every check, in the same order,
+ * with the same messages, is unchanged.
+ */
+export declare class ToolManager {
+    private readonly toolsets;
+    private readonly resultGuardrails?;
+    private readonly tierConfig?;
+    private readonly messagesAccessor;
+    private readonly log;
+    private toolsByName;
+    private ownerToolsetByName;
+    private defaultAvailabilityByName;
+    /**
+     * The object each name's owning toolset returned the LAST time `refresh()`
+     * (or construction) observed it — distinct from `toolsByName`, which holds
+     * whatever was first admitted under that name and never changes on drift.
+     * `refresh()` diffs against this map, not `toolsByName`, so a name that
+     * drifted once and has been stable ever since is not reported as drifted
+     * again just because some unrelated toolset's change forced a re-walk.
+     */
+    private lastObservedByName;
+    private dirty;
+    private readonly unsubscribeToolsetChanges;
+    private disposed;
+    private readonly preparations;
+    constructor(config: ToolManagerConfig);
+    /** Stop observing live toolsets when this manager's owner finishes; the host owns their connections. */
+    dispose(): void;
+    /**
+     * First resolution, at construction. Toolset order, then tool order,
+     * matching `combineToolsets` (`./combine.ts`) — a name contributed by two
+     * sources throws {@link ToolsetConflictError} naming both, because
+     * nothing has served anyone yet: unlike {@link refresh}, there is no
+     * incumbent to protect by refusing the newcomer instead.
+     */
+    /**
+     * The checks `ToolRegistry.registerOne` used to run before admitting a
+     * tool, copied verbatim: a legal name; `enforceModelInput` requires a
+     * `modelInputSchema` (nothing to constrain generation against
+     * otherwise) and that schema must itself fit the strict-decoding subset
+     * `assertStrictSchema` checks (existing is not enough — it also has to
+     * be sendable); a declared `tier` must be one `this.tierConfig` lists.
+     */
+    private assertAdmissible;
+    private resolveInitial;
+    /**
+     * Re-resolve iff a toolset signalled change (`onChange`) since
+     * construction or the last `refresh()` — otherwise returns `undefined`
+     * without re-walking anything, so a caller that refreshes every
+     * iteration boundary pays nothing on the common case where nothing
+     * changed.
+     *
+     * Three outcomes per name, matching plan.md §2:
+     *  - A name only ONE current toolset contributes, that nobody served
+     *    before: `added`.
+     *  - A name a toolset served before and stopped, with no other toolset
+     *    now contributing it: `removed`.
+     *  - A name still contributed by its ORIGINAL owning toolset, under a
+     *    `ToolDefinition` object different from the one that toolset returned
+     *    the LAST time it was observed (construction, or the previous
+     *    `refresh()`): `drifted` — the previously admitted definition keeps
+     *    serving; the new object is held, not adopted, so `toolWireSchema`'s
+     *    identity-keyed cache (see the class doc) survives a live toolset's
+     *    own internal change. Comparing against the last OBSERVATION, not
+     *    the served object, means a name that drifted once and has been
+     *    stable since is reported only on the refresh where it actually
+     *    changed, not again on every later refresh some unrelated toolset's
+     *    change happens to trigger.
+     *  - A name some OTHER toolset starts contributing while its incumbent
+     *    owner still serves it: `refused` — the incumbent wins regardless of
+     *    toolset order; the newcomer is reported, never applied.
+     */
+    refresh(): ToolsetChangeReport | undefined;
+    has(name: string): boolean;
+    get(name: string): ToolDefinition | undefined;
+    listNames(): string[];
+    /** Where `name` came from. Throws for an unknown name, like {@link getOrThrow}. */
+    sourceOf(name: string): ToolSourceRef;
+    private getOrThrow;
+    /**
+     * `'suspended'` when the owning toolset is unready; otherwise `'deferred'`
+     * when it declared deferred and no matching receipt exists in the
+     * post-compaction history; otherwise `'active'`.
+     *
+     * Nothing here is stored: this is a pure read of the toolset's own
+     * declaration plus a scan of `messages()`, recomputed on every call — the
+     * same "safe to call repeatedly, byte-identical between calls" property
+     * `toLLMTools` already has. The scan is bounded to the window AFTER the
+     * last compaction summary (`compaction/summary.ts`'s
+     * `isCompactionMessage` — the one marker a compacted history carries, a
+     * system message whose content starts with `COMPACTION_HEADER`):
+     * compaction is the one deliberate "forget" boundary a derivation like
+     * this one needs, the same way it is the one boundary namzu's own
+     * summarisation treats as a reset. A tool message's own `revealedTools`
+     * (`types/message/index.ts`) is written by the executor from
+     * `ToolResult.reveals`, persisted like any other message field — there is
+     * no separate store to keep in sync, restore on resume, or lose across a
+     * fork.
+     */
+    availability(name: string): ToolAvailability;
+    private wasRevealed;
+    /** Bind a reveal to the source currently serving the named tool. */
+    revealReceipt(name: string): ToolRevealReceipt;
+    private getByAvailability;
+    /**
+     * Ranked lexical search over deferred tools — same scoring
+     * `ToolRegistry.searchDeferred` used (exact name 12 / name-substring 8 /
+     * description 5 / argument-name 3, generic tokens stopped), extended
+     * with an optional cap so a caller does not have to slice the result
+     * itself.
+     */
+    searchDeferred(query: string, limit?: number): readonly ToolDefinition[];
+    private searchByAvailability;
+    toLLMTools(names?: readonly string[]): LLMToolSchema[];
+    toPromptSection(names?: readonly string[]): string;
+    toTierGuidance(): string | null;
+    /** What `ToolContext` gives a running tool: read-only, no mutation. */
+    view(): ToolsView;
+    prepareExecution(toolName: string, rawInput: unknown): ToolPreparationResult;
+    executePrepared(prepared: PreparedToolExecution, context: ToolContext): Promise<ToolExecutionResult>;
+    execute(toolName: string, rawInput: unknown, context: ToolContext): Promise<ToolExecutionResult>;
+    private rejectPreparationWithClosedSpan;
+    private executeRetained;
+    private validationFailure;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/toolsets/manager.d.ts.map

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