@dsh-cc/tools 0.5.0

package/lib/runtime-core.js

@@ -0,0 +1,33 @@
+/**
+ * Structural core shared by the ToolRuntime facade and its free-function
+ * collaborator modules: the runtime's state fields plus every method
+ * signature the collaborators call through their `rt` parameter. The facade
+ * instance satisfies this interface structurally; collaborators stay acyclic
+ * at import time — this module imports NO value from `index.ts` (the only
+ * value edges here are the leaf SDK renderer table below).
+ * @module
+ */
+import { renderToolsSdk } from "./ts-types.js";
+import { renderToolsSdkPy } from "./py-types.js";
+import { TOOL_RUNTIME_SCHEDULER } from "./scheduler.js";
+/**
+ * Language → SDK-section renderer. The registry looks up the loaded
+ * `ctx.codeRuntime.language` in this table when assembling the `tools:sdk`
+ * section under a non-native mode; a runtime whose language is not a key
+ * fails the assembly loudly (same idiom as `toolOrder` violations). Adding a
+ * new backend language is three parallel edits — a {@link CodeSdkLanguage}
+ * member, an entry here, and a `RUN_CODE_FLAVORS` entry in `code-mode.ts` for
+ * its `run_code` schema strings — plus the renderer function this table points
+ * at. The `satisfies` clause pins this table's key set to that union, which
+ * the flavor table is checked against too, so any of the three left out is a
+ * typecheck failure. What no check reaches is the prose that names the values
+ * instead of deriving them: the seam's `dsh-code-runtime` README pair, its
+ * `CodeRuntime.language` JSDoc, and `docs/subsystems/code-runtime.md`
+ * with its zh pair, plus this package's own README pair and the
+ * {@link Config.mode} JSDoc.
+ */
+export const SDK_RENDERERS = {
+    typescript: renderToolsSdk,
+    python: renderToolsSdkPy,
+};
+//# sourceMappingURL=runtime-core.js.map

package/lib/runtime-core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-core.js","sourceRoot":"","sources":["../src/runtime-core.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAE9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAEhD,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAKvD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,aAAa,GAAyD;IACjF,UAAU,EAAE,cAAc;IAC1B,MAAM,EAAE,gBAAgB;CAC+C,CAAA"}

package/lib/runtime-execute.d.ts

@@ -0,0 +1,82 @@
+/**
+ * ToolRuntime execution-pipeline collaborators: execution creation, the
+ * pre-execute/ask/guard policy stages, around-dispatch, and the scheduler's
+ * staged entry points. Bodies are verbatim moves from the former `ToolRuntime`
+ * methods with `this.` → `rt.`; reverse calls into other clusters (registry
+ * resolution, approval ask, result materialization) go through `rt`.
+ * @module
+ */
+import type { MutableToolRunContext, ScheduledToolDispatch, ScheduledToolPreparation, ToolExecutionInput, ToolExecutionResult, ToolRunContext } from './tool-types.ts';
+import type { ToolRuntimeCore } from './runtime-core.ts';
+/**
+ * Execute through pre-policy, guards, around-dispatch, post-policy,
+ * definition-owned content finalization, and final notification. Tool and
+ * listener failures resolve as materialized error results; an invisible tool
+ * reports `UNKNOWN_TOOL`. The returned outcome is the same lossless, frozen
+ * snapshot final observers receive. Cancellation
+ * arriving after entry and before final result materialization skips a
+ * not-yet-started body with `ABORTED_BEFORE_DISPATCH` or replaces a
+ * successful started outcome with `ABORTED`; already-started work is still
+ * drained and may retain a tool-owned structured error.
+ * @param rt - the owning runtime.
+ * @param exec - the typed same-process call input. The registry assigns its
+ *   correlation token before policy begins.
+ * @returns the materialized final result.
+ */
+export declare function execute(rt: ToolRuntimeCore, exec: ToolExecutionInput): Promise<ToolExecutionResult>;
+export declare function completeScheduledExecution(rt: ToolRuntimeCore, prepared: ScheduledToolPreparation): Promise<ToolExecutionResult>;
+export declare function createExecution(rt: ToolRuntimeCore, exec: ToolExecutionInput): ScheduledToolPreparation | {
+    kind: 'ready';
+    exec: MutableToolRunContext;
+};
+/**
+ * Run the ordered pre-execute and monotonic guard stages for the scheduler.
+ * @param rt - the owning runtime.
+ * @param input - the caller-supplied execution input.
+ * @returns the prepared execution plus the next scheduler stage.
+ * @internal
+ */
+export declare function prepareScheduledExecution(rt: ToolRuntimeCore, input: ToolExecutionInput): Promise<ScheduledToolPreparation>;
+export declare function prepareExecution<T>(rt: ToolRuntimeCore, input: ToolExecutionInput, next: (prepared: ScheduledToolPreparation) => T | PromiseLike<T>): Promise<T>;
+/** Whether the original caller signal is currently aborted. */
+export declare function callerCancelled(rt: ToolRuntimeCore, exec: ToolRunContext): boolean;
+/** Canonical cancellation outcome selected by whether the tool body started. */
+export declare function cancellationResult(rt: ToolRuntimeCore, exec: ToolRunContext, prior?: ToolExecutionResult): ToolExecutionResult;
+/**
+ * Dispatch the registered body with the original caller signal fused back
+ * into any around-wrapper replacement. Cancellation never abandons the body:
+ * a started promise reaches quiescence before its outcome becomes `ABORTED`.
+ */
+export declare function dispatchToolBody(rt: ToolRuntimeCore, exec: MutableToolRunContext): Promise<ToolExecutionResult>;
+/**
+ * Run around-dispatch and the tool body. Tool and unknown-tool failures still
+ * receive post-execute; pipeline failures are already final.
+ * @param rt - the owning runtime.
+ * @param exec - the prepared execution.
+ * @returns whether the result still needs post-execute.
+ * @internal
+ */
+export declare function dispatchScheduledExecution(rt: ToolRuntimeCore, exec: ToolRunContext): Promise<ScheduledToolDispatch>;
+/**
+ * Run ordered post-execute, then apply definition-owned content finalization,
+ * materialize, and notify the final outcome.
+ * @param rt - the owning runtime.
+ * @param exec - the prepared execution.
+ * @param result - dispatch/pre result that still needs post-execute.
+ * @returns the materialized final result.
+ * @internal
+ */
+export declare function finalizeScheduledExecution(rt: ToolRuntimeCore, exec: ToolRunContext, result: ToolExecutionResult): Promise<ToolExecutionResult>;
+/**
+ * Materialize the candidate, apply definition-owned content finalization,
+ * then materialize and notify the authoritative result.
+ * @param rt - the owning runtime.
+ * @param exec - the prepared execution.
+ * @param result - final result.
+ * @returns the materialized final result.
+ * @internal
+ */
+export declare function finishScheduledExecution(rt: ToolRuntimeCore, exec: ToolRunContext, result: ToolExecutionResult): ToolExecutionResult;
+/** Apply the snapshotted tool-owned content transform without exposing other result fields. */
+export declare function applyFinalContent(rt: ToolRuntimeCore, exec: ToolRunContext, result: ToolExecutionResult): ToolExecutionResult;
+//# sourceMappingURL=runtime-execute.d.ts.map

package/lib/runtime-execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-execute.d.ts","sourceRoot":"","sources":["../src/runtime-execute.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAQH,OAAO,KAAK,EAAE,qBAAqB,EAAmB,qBAAqB,EAAE,wBAAwB,EAAiC,kBAAkB,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEtN,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,OAAO,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAEzG;AAED,wBAAsB,0BAA0B,CAAC,EAAE,EAAE,eAAe,EAAE,QAAQ,EAAE,wBAAwB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAgBtI;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,kBAAkB,GAAG,wBAAwB,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,qBAAqB,CAAA;CAAE,CAuFxJ;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAAC,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAEjI;AAED,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,EAAE,EAAE,eAAe,EACnB,KAAK,EAAE,kBAAkB,EACzB,IAAI,EAAE,CAAC,QAAQ,EAAE,wBAAwB,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAC/D,OAAO,CAAC,CAAC,CAAC,CAyCZ;AAED,+DAA+D;AAC/D,wBAAgB,eAAe,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAKlF;AAED,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,mBAAmB,GAAG,mBAAmB,CAO9H;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA4BrH;AAED;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA8B1H;AAED;;;;;;;;GAQG;AACH,wBAAsB,0BAA0B,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAYrJ;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,mBAAmB,GAAG,mBAAmB,CAepI;AAED,+FAA+F;AAC/F,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,mBAAmB,GAAG,mBAAmB,CAK7H"}

package/lib/runtime-execute.js

@@ -0,0 +1,333 @@
+/**
+ * ToolRuntime execution-pipeline collaborators: execution creation, the
+ * pre-execute/ask/guard policy stages, around-dispatch, and the scheduler's
+ * staged entry points. Bodies are verbatim moves from the former `ToolRuntime`
+ * methods with `this.` → `rt.`; reverse calls into other clusters (registry
+ * resolution, approval ask, result materialization) go through `rt`.
+ * @module
+ */
+import { scopeTarget } from '@deepseek-ai/dsh-scope';
+import { assertNever, deepFreeze } from '@deepseek-ai/dsh-llm';
+import { snapshotJsonValue } from '@deepseek-ai/dsh-session';
+import { createExecutionToken, fuseToolSignals, isAborted, toolAbortedBeforeDispatchResult, toolAbortedResult, toolErrorResult, ToolNotFoundError } from "./abort-utils.js";
+import { RUN_CODE_NAME } from "./code-mode.js";
+/**
+ * Execute through pre-policy, guards, around-dispatch, post-policy,
+ * definition-owned content finalization, and final notification. Tool and
+ * listener failures resolve as materialized error results; an invisible tool
+ * reports `UNKNOWN_TOOL`. The returned outcome is the same lossless, frozen
+ * snapshot final observers receive. Cancellation
+ * arriving after entry and before final result materialization skips a
+ * not-yet-started body with `ABORTED_BEFORE_DISPATCH` or replaces a
+ * successful started outcome with `ABORTED`; already-started work is still
+ * drained and may retain a tool-owned structured error.
+ * @param rt - the owning runtime.
+ * @param exec - the typed same-process call input. The registry assigns its
+ *   correlation token before policy begins.
+ * @returns the materialized final result.
+ */
+export async function execute(rt, exec) {
+    return rt.prepareExecution(exec, prepared => rt.completeScheduledExecution(prepared));
+}
+export async function completeScheduledExecution(rt, prepared) {
+    switch (prepared.kind) {
+        case 'dispatch': {
+            const dispatched = await rt.dispatchScheduledExecution(prepared.exec);
+            return dispatched.kind === 'post-result'
+                ? await rt.finalizeScheduledExecution(prepared.exec, dispatched.result)
+                : rt.finishScheduledExecution(prepared.exec, dispatched.result);
+        }
+        case 'post-result':
+            return await rt.finalizeScheduledExecution(prepared.exec, prepared.result);
+        case 'final-result':
+            return rt.finishScheduledExecution(prepared.exec, prepared.result);
+        /* v8 ignore next -- closed-union exhaustiveness guard */
+        default:
+            return assertNever(prepared, 'scheduled tool preparation');
+    }
+}
+export function createExecution(rt, exec) {
+    const deferredContexts = [];
+    const token = createExecutionToken();
+    const callId = exec.callId;
+    const rootCallId = exec.rootCallId ?? callId;
+    const name = exec.name;
+    const agent = exec.agent;
+    const parent = exec.parent;
+    const signal = exec.signal;
+    // Distinguish a mode-collapsed call (visible in the scope, denied only by
+    // the `code` collapse) from a genuinely unknown tool. A collapsed call is
+    // deterministically denied, so it terminates BEFORE the extensible policy
+    // pipeline: pre-execute listeners, approval `ask`, and guards must never
+    // observe — or worse, approve — a call that can only fail. An unknown tool
+    // keeps the historical dispatch-stage `UNKNOWN_TOOL` path so policy
+    // listeners still see every name that reaches the registry.
+    const visible = rt.get(name, agent);
+    const collapsed = visible !== undefined && rt.collapses(name, agent, parent !== undefined);
+    const concludingExecutions = rt.concludingExecutions;
+    const base = {
+        token,
+        callId,
+        rootCallId,
+        name,
+        signal,
+        ...agent !== undefined ? { agent } : {},
+        ...parent !== undefined ? { parent } : {},
+        deferContext(context) {
+            deferredContexts.push(context);
+        },
+        concludeTurn() {
+            concludingExecutions.add(this);
+        },
+    };
+    // Capture the finalizer BEFORE argument materialization: the
+    // `finalizeContent` contract snapshots the callback when the call starts,
+    // and an arguments getter can replace or clear the registered callback
+    // during `snapshotJsonValue`. The collapse only decides whether the
+    // CAPTURED callback is retained: the pre-dispatch abort path keeps it
+    // (the cancellation contract routes aborted results through it — a getter
+    // that aborts mid-materialization before an invalid-args failure lands in
+    // the same retained path), while the `UNKNOWN_TOOL` denial and the
+    // invalid-args failure of a NON-ABORTED collapsed call drop it (the call
+    // could never execute).
+    const capturedFinalizer = visible?.finalizeContent?.bind(visible);
+    const finalizerFor = () => collapsed && !signal.aborted ? undefined : capturedFinalizer;
+    try {
+        const detached = snapshotJsonValue(exec.arguments);
+        if (detached === undefined) {
+            throw new TypeError('tool execution arguments must be losslessly JSON-serializable');
+        }
+        const execution = { ...base, arguments: deepFreeze(detached) };
+        rt.deferredContexts.set(execution, deferredContexts);
+        rt.contentFinalizers.set(execution, finalizerFor());
+        rt.cancellationStates.set(execution, {
+            callerSignal: signal,
+            bodyInvoked: false,
+        });
+        if (collapsed) {
+            // The collapse denies the call before the policy pipeline, but a
+            // pre-dispatch abort still keeps the established cancellation
+            // contract: `prepare`'s caller-cancellation check is skipped for
+            // final-results, so honor the abort here instead of surfacing
+            // `UNKNOWN_TOOL` on an already-cancelled call.
+            if (signal.aborted) {
+                return { kind: 'final-result', exec: execution, result: toolAbortedBeforeDispatchResult() };
+            }
+            // The name IS visible here, so the denial carries the route the model
+            // must take instead. Without it the model reads a bare `unknown tool`
+            // for a tool the prompt just declared and concludes the deployment is
+            // broken rather than correcting itself.
+            return {
+                kind: 'final-result',
+                exec: execution,
+                result: toolErrorResult(new ToolNotFoundError(name, `only \`${RUN_CODE_NAME}\` is callable directly — call \`${name}\` from inside a \`${RUN_CODE_NAME}\` program instead`)),
+            };
+        }
+        return { kind: 'ready', exec: execution };
+    }
+    catch (error) {
+        const execution = { ...base, arguments: undefined };
+        rt.contentFinalizers.set(execution, finalizerFor());
+        return { kind: 'final-result', exec: execution, result: toolErrorResult(error) };
+    }
+}
+/**
+ * Run the ordered pre-execute and monotonic guard stages for the scheduler.
+ * @param rt - the owning runtime.
+ * @param input - the caller-supplied execution input.
+ * @returns the prepared execution plus the next scheduler stage.
+ * @internal
+ */
+export async function prepareScheduledExecution(rt, input) {
+    return rt.prepareExecution(input, prepared => prepared);
+}
+export async function prepareExecution(rt, input, next) {
+    const created = rt.createExecution(input);
+    if (created.kind !== 'ready')
+        return next(created);
+    const exec = created.exec;
+    if (rt.callerCancelled(exec)) {
+        return next({ kind: 'final-result', exec, result: toolAbortedBeforeDispatchResult() });
+    }
+    try {
+        const carrier = scopeTarget(rt, exec.agent);
+        const gate = await rt.ctx.waterfall(carrier, 'tools/pre-execute', exec, () => Promise.resolve({ kind: 'allow' }));
+        const askResolution = gate.kind === 'ask'
+            ? await rt.serviceAsk(exec, gate)
+            : { decision: gate, approvalCancelled: false };
+        const { decision } = askResolution;
+        if (rt.callerCancelled(exec) && askResolution.approvalCancelled) {
+            return await next({ kind: 'post-result', exec, result: toolAbortedBeforeDispatchResult() });
+        }
+        const denialReason = decision.kind === 'allow'
+            ? rt.guardReason(exec)
+            : decision.reason;
+        if (denialReason !== undefined) {
+            return await next({
+                kind: 'post-result',
+                exec,
+                result: rt.materializeFinalResult({
+                    content: [{ type: 'text', text: `Error: ${denialReason}` }],
+                    isError: true,
+                    error: { message: denialReason },
+                }),
+            });
+        }
+        if (rt.callerCancelled(exec)) {
+            return await next({ kind: 'post-result', exec, result: toolAbortedBeforeDispatchResult() });
+        }
+        return await next({ kind: 'dispatch', exec });
+    }
+    catch (error) {
+        return next({ kind: 'final-result', exec, result: toolErrorResult(error) });
+    }
+}
+/** Whether the original caller signal is currently aborted. */
+export function callerCancelled(rt, exec) {
+    const state = rt.cancellationStates.get(exec);
+    /* v8 ignore next -- only registry-minted executions reach the staged scheduler methods */
+    if (state === undefined)
+        throw new Error('tool registry scheduler invariant violated: missing cancellation state');
+    return state.callerSignal.aborted;
+}
+/** Canonical cancellation outcome selected by whether the tool body started. */
+export function cancellationResult(rt, exec, prior) {
+    const state = rt.cancellationStates.get(exec);
+    /* v8 ignore next -- only registry-minted executions reach the staged scheduler methods */
+    if (state === undefined)
+        throw new Error('tool registry scheduler invariant violated: missing cancellation state');
+    return state.bodyInvoked
+        ? toolAbortedResult(prior)
+        : toolAbortedBeforeDispatchResult(prior);
+}
+/**
+ * Dispatch the registered body with the original caller signal fused back
+ * into any around-wrapper replacement. Cancellation never abandons the body:
+ * a started promise reaches quiescence before its outcome becomes `ABORTED`.
+ */
+export async function dispatchToolBody(rt, exec) {
+    const state = rt.cancellationStates.get(exec);
+    /* v8 ignore next -- only registry-minted executions reach the staged scheduler methods */
+    if (state === undefined)
+        throw new Error('tool registry scheduler invariant violated: missing cancellation state');
+    const wrapperSignal = exec.signal;
+    const fused = fuseToolSignals(state.callerSignal, wrapperSignal);
+    const signal = fused.signal;
+    if (isAborted(signal)) {
+        fused.dispose();
+        return toolAbortedBeforeDispatchResult();
+    }
+    exec.signal = signal;
+    try {
+        const tool = rt.resolveExecution(exec.name, exec.agent, exec.parent !== undefined);
+        if (!tool)
+            throw new ToolNotFoundError(exec.name);
+        state.bodyInvoked = true;
+        const returned = await tool.execute(exec.arguments, exec);
+        const result = rt.createSuccessResult(exec, tool, returned);
+        return isAborted(signal)
+            ? toolAbortedResult(result)
+            : result;
+    }
+    catch (error) {
+        return toolErrorResult(error);
+    }
+    finally {
+        fused.dispose();
+        exec.signal = wrapperSignal;
+    }
+}
+/**
+ * Run around-dispatch and the tool body. Tool and unknown-tool failures still
+ * receive post-execute; pipeline failures are already final.
+ * @param rt - the owning runtime.
+ * @param exec - the prepared execution.
+ * @returns whether the result still needs post-execute.
+ * @internal
+ */
+export async function dispatchScheduledExecution(rt, exec) {
+    try {
+        const mutableExec = exec;
+        const carrier = scopeTarget(rt, exec.agent);
+        const result = await rt.ctx.waterfall(carrier, 'tools/execute', mutableExec, () => rt.dispatchToolBody(mutableExec));
+        const normalized = rt.normalizeDispatchResult(exec, result);
+        const deferredContexts = rt.deferredContexts.get(exec);
+        /* v8 ignore next -- dispatch only receives executions minted by this registry's prepare stage */
+        if (deferredContexts === undefined)
+            throw new Error('tool registry scheduler invariant violated: unprepared execution');
+        const resultWithDeferredContexts = deferredContexts.length === 0
+            ? normalized
+            : rt.markCanonical(exec, {
+                ...normalized,
+                additionalContexts: [
+                    ...deferredContexts,
+                    ...normalized.additionalContexts ?? [],
+                ],
+            });
+        return {
+            kind: 'post-result',
+            result: rt.callerCancelled(exec) && !resultWithDeferredContexts.isError
+                ? rt.cancellationResult(exec, resultWithDeferredContexts)
+                : resultWithDeferredContexts,
+        };
+    }
+    catch (error) {
+        return { kind: 'final-result', result: toolErrorResult(error) };
+    }
+}
+/**
+ * Run ordered post-execute, then apply definition-owned content finalization,
+ * materialize, and notify the final outcome.
+ * @param rt - the owning runtime.
+ * @param exec - the prepared execution.
+ * @param result - dispatch/pre result that still needs post-execute.
+ * @returns the materialized final result.
+ * @internal
+ */
+export async function finalizeScheduledExecution(rt, exec, result) {
+    try {
+        const postResult = await rt.postExecute(exec, result);
+        return rt.finishScheduledExecution(exec, rt.callerCancelled(exec) && !postResult.isError
+            ? rt.cancellationResult(exec, postResult)
+            : postResult);
+    }
+    catch (error) {
+        return rt.finishScheduledExecution(exec, toolErrorResult(error));
+    }
+}
+/**
+ * Materialize the candidate, apply definition-owned content finalization,
+ * then materialize and notify the authoritative result.
+ * @param rt - the owning runtime.
+ * @param exec - the prepared execution.
+ * @param result - final result.
+ * @returns the materialized final result.
+ * @internal
+ */
+export function finishScheduledExecution(rt, exec, result) {
+    let materializedResult;
+    try {
+        materializedResult = rt.materializeFinalResult(result);
+    }
+    catch (error) {
+        materializedResult = rt.materializeFinalResult(toolErrorResult(error));
+    }
+    let finalResult;
+    try {
+        finalResult = rt.materializeFinalResult(rt.applyFinalContent(exec, materializedResult));
+    }
+    catch (error) {
+        finalResult = rt.materializeFinalResult(toolErrorResult(error));
+    }
+    rt.notifyResult(exec, finalResult);
+    return finalResult;
+}
+/** Apply the snapshotted tool-owned content transform without exposing other result fields. */
+export function applyFinalContent(rt, exec, result) {
+    const finalizeContent = rt.contentFinalizers.get(exec);
+    if (finalizeContent === undefined)
+        return result;
+    const content = finalizeContent(exec, result);
+    return content === undefined ? result : { ...result, content };
+}
+//# sourceMappingURL=runtime-execute.js.map

package/lib/runtime-execute.js.map

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

package/lib/runtime-registry.d.ts

@@ -0,0 +1,131 @@
+/**
+ * ToolRuntime registry collaborators: registration, reservation, admission,
+ * restriction, guards, and per-scope view resolution. Every function takes
+ * the owning runtime as its `rt: ToolRuntimeCore` first parameter; bodies are
+ * verbatim moves from the former `ToolRuntime` methods with `this.` → `rt.`.
+ * @module
+ */
+import type { ScopeKey } from '@deepseek-ai/dsh-scope';
+import type { ToolDefinition, ToolExecution, ToolExecutionInput, ToolExecutionMode, ToolGuard, ToolRestriction, ToolView } from './tool-types.ts';
+import type { ToolRuntimeCore } from './runtime-core.ts';
+/**
+ * Register globally or in the calling agent scope. Scoped tools shadow
+ * globals; duplicates within one layer and the reserved `run_code` name fail.
+ * @param rt - the owning runtime.
+ * @param definition - tool schema, execution, and optional finalization/presentation callbacks.
+ * @returns the exact disposer that unregisters the tool.
+ */
+export declare function register(rt: ToolRuntimeCore, definition: ToolDefinition): () => void;
+/**
+ * Reserve a capability NAME in the calling layer without registering a
+ * visible definition. A reserved name joins the known/restrictable universe
+ * — a scope may later `restrict()` it away, and `toolOrder` may list it — but
+ * it never reaches the model-facing schema until a real `register()` supplies
+ * the definition. This is how a deferred-tool registry seeds the names a
+ * composition may gate before their heavy definitions load.
+ *
+ * The name stays out of the runtime's `get` and `schemas` views (only
+ * registered definitions are visible). Duplicate reservations within one
+ * layer fail, matching the duplicate-name rule for `register`.
+ * @param rt - the owning runtime.
+ * @param name - the capability name to make known without presenting.
+ * @returns the exact disposer that clears the reservation.
+ */
+export declare function reserve(rt: ToolRuntimeCore, name: string): () => void;
+/**
+ * Whether a global tool name passes every scoped restriction on the viewing
+ * scope's chain. The answer ignores registration: a reserved or not-yet-loaded
+ * name is admitted if no `allow`/`deny` on the chain masks it, so a caller can
+ * gate whether a deferred capability may load for one agent. A name masked by
+ * an `allow` list it is absent from, or present in a `deny` list, is not
+ * admitted. When a name has multiple restrictions, they intersect (all must
+ * admit it), matching registration visibility.
+ * @param rt - the owning runtime.
+ * @param name - the capability name to test.
+ * @param scope - the viewing scope (the agent); omitted for the global view, which has no restrictions.
+ * @returns whether the name may load for that scope.
+ */
+export declare function isAdmitted(rt: ToolRuntimeCore, name: string, scope?: ScopeKey): boolean;
+/**
+ * Restrict global tools for the calling agent scope. Empty filters, unknown
+ * names, scope-local names, and reserved transport names fail. Restrictions
+ * intersect; scoped registrations remain visible.
+ * @param rt - the owning runtime.
+ * @param filter - global-tool mask: `allow` (keep only) and/or `deny` (remove).
+ * @returns the exact disposer that lifts this restriction.
+ */
+export declare function restrict(rt: ToolRuntimeCore, filter: ToolRestriction): () => void;
+/**
+ * Register a monotonic guard after the extensible `tools/pre-execute`
+ * waterfall. A plain-context guard applies globally; one registered through
+ * `agent.ctx` applies only to that agent. Any matching guard may deny by
+ * returning a reason, while no guard can force-allow a call another guard
+ * denied. The exact effect disposer is returned for ordered ownership and
+ * HMR cleanup.
+ * @param rt - the owning runtime.
+ * @param guard - synchronous check; a returned string denies the execution.
+ * @returns the exact disposer that unregisters the guard.
+ */
+export declare function guard(rt: ToolRuntimeCore, guard: ToolGuard): () => void;
+/** First monotonic denial from the global then the scope chain's guard layers, farthest first. */
+export declare function guardReason(rt: ToolRuntimeCore, exec: ToolExecution): string | undefined;
+/**
+ * Resolve every registry fact one scope needs in one layer traversal. The
+ * visible map applies restrictions to the INHERITED surface, then the
+ * scope's own registrations and the reserved presentation transport; the
+ * other sets retain the pre-restriction facts needed by restriction and
+ * prompt-order validation.
+ *
+ * A restriction filters what a scope inherits — the global layer and every
+ * ancestor layer on its chain — and never what its OWN layer registers.
+ * That exemption is what a per-child capability filter has to keep intact:
+ * the delegation runtime registers a child's reporting and structured-output
+ * tools into the child's own layer, and a filter naming the capabilities the
+ * child may use must not strip the machinery it answers through.
+ *
+ * Reading the exempt set as "the global layer" instead of "not mine" held
+ * only while every model-facing tool sat in the host composition. Once
+ * presets moved them onto the agent plane they became an ANCESTOR
+ * contribution, so a child's filter silently stopped constraining anything
+ * it was given.
+ * @param rt - the owning runtime.
+ * @param scope - the viewing scope (the agent), or undefined for the global view.
+ * @returns the complete derived view for that scope.
+ */
+export declare function view(rt: ToolRuntimeCore, scope?: ScopeKey): ToolView;
+/**
+ * Look up a tool as one scope sees it (scoped
+ * shadows global; a restricted-away global reads as absent). Presenters pass
+ * the calling agent so the rendered card matches the definition that
+ * actually executed.
+ * @param rt - the owning runtime.
+ * @param name - the tool name as registered.
+ * @param scope - the viewing scope (the agent); omitted = the global view.
+ * @returns the definition the scope resolves, or undefined when none is visible.
+ */
+export declare function get(rt: ToolRuntimeCore, name: string, scope?: ScopeKey): ToolDefinition | undefined;
+/**
+ * Resolve the definition that MAY EXECUTE for a call, applying the mode
+ * collapse at the operation boundary that owns it. The registry view
+ * (`get`) is presentation-agnostic; here a MODEL-DIRECT call under `code`
+ * may only name the reserved `run_code` transport, while a nested
+ * sub-dispatch (a `parent` token set — the `run_code` SDK calling a tool
+ * it bound) may call any visible tool. Denial surfaces as `UNKNOWN_TOOL`
+ * through the executor, matching an absent definition.
+ * @param rt - the owning runtime.
+ * @param name - the tool name as registered.
+ * @param scope - the viewing scope (the agent); omitted = the global view.
+ * @param nested - whether the call is a transport sub-dispatch, not a model-direct call.
+ * @returns the definition that may run, or undefined when the call must be rejected.
+ */
+export declare function resolveExecution(rt: ToolRuntimeCore, name: string, scope: ScopeKey | undefined, nested: boolean): ToolDefinition | undefined;
+/**
+ * Classify a pending call through the caller's visible tool definition. Only
+ * an exact `true` is parallel; unknown, hidden, undeclared, invalid, or
+ * throwing classifiers are exclusive.
+ * @param rt - the owning runtime.
+ * @param exec - call name, parsed arguments, and optional agent scope.
+ * @returns the fail-closed scheduling mode.
+ */
+export declare function executionMode(rt: ToolRuntimeCore, exec: ToolExecutionInput): ToolExecutionMode;
+//# sourceMappingURL=runtime-registry.d.ts.map

package/lib/runtime-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-registry.d.ts","sourceRoot":"","sources":["../src/runtime-registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAGtD,OAAO,KAAK,EAA2B,cAAc,EAAE,aAAa,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,SAAS,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAC1K,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,eAAe,EAAE,UAAU,EAAE,cAAc,GAAG,MAAM,IAAI,CAyBpF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,IAAI,CASrE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,QAAQ,GAAG,OAAO,CAEvF;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,eAAe,EAAE,MAAM,EAAE,eAAe,GAAG,MAAM,IAAI,CA2BjF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,IAAI,CAMvE;AAED,kGAAkG;AAClG,wBAAgB,WAAW,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,aAAa,GAAG,MAAM,GAAG,SAAS,CASxF;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,IAAI,CAAC,EAAE,EAAE,eAAe,EAAE,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAkDpE;AAED;;;;;;;;;GASG;AACH,wBAAgB,GAAG,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,QAAQ,GAAG,cAAc,GAAG,SAAS,CAEnG;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,SAAS,EAAE,MAAM,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAK5I;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,kBAAkB,GAAG,iBAAiB,CAS9F"}