@dsh-cc/tools 0.5.0

package/lib/py-types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Code Mode codegen — Python flavor. The pure projection from registered tool schemas to the
+ * Python SDK text the model programs against under `runtime.language === 'python'`. Sibling of
+ * {@link ./ts-types.ts | ts-types.ts}; the two files are two projections of the same registry
+ * store, keyed by the loaded {@link @deepseek-ai/dsh-code-runtime#CodeRuntime.language | code
+ * runtime's language}.
+ *
+ * Under `mode: 'code'` the native tool schemas are omitted from the request, so this generated
+ * SDK is the model's ONLY source for each tool's argument names, required fields, types,
+ * descriptions, and canonical output shapes; under `mode: 'both'` the native schemas ship
+ * alongside it and it is one of two. Object-shaped arguments and outputs therefore render as one
+ * named `TypedDict` per tool (and per nested object), not an opaque `dict[str, Any]`, so the
+ * shape survives into the program under the mode that has nothing else to carry it.
+ *
+ * Line-budget layout: `py-names.ts` holds the shared naming/state/text-escape machinery,
+ * `py-render.ts` the {@link renderType} walker, `py-sdk-doc.ts` the `renderToolsSdkPy`
+ * document renderer; this file stays the public barrel — both exports re-exported here.
+ * @module @dsh-cc/tools/src/py-types
+ */
+export { renderToolsSdkPy } from './py-sdk-doc.ts';
+/**
+ * Map one JSON-Schema node to a context-free Python type expression from the
+ * `typing` module. Handles every unified schema construct — `object` (degraded
+ * to `dict[str, Any]`: naming a `TypedDict` requires the render context that
+ * {@link renderToolsSdkPy} supplies), `const`/`enum` (→ `Literal[...]`),
+ * `oneOf` (→ union), `string`/`number`/`integer`/`boolean`/`null`, `array`
+ * (`items` → `list[T]`) — and returns `Any` for an unsupported or malformed
+ * schema, matching the TS flavor's `unknown` fallback. Type annotations in the
+ * emitted SDK are advisory: Python does not enforce them at runtime.
+ * @param schema - the JSON-Schema node.
+ * @returns the Python type text.
+ */
+export declare function jsonSchemaToPy(schema: unknown): string;
+//# sourceMappingURL=py-types.d.ts.map

package/lib/py-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"py-types.d.ts","sourceRoot":"","sources":["../src/py-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAElD;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAKtD"}

package/lib/py-types.js

@@ -0,0 +1,40 @@
+/**
+ * Code Mode codegen — Python flavor. The pure projection from registered tool schemas to the
+ * Python SDK text the model programs against under `runtime.language === 'python'`. Sibling of
+ * {@link ./ts-types.ts | ts-types.ts}; the two files are two projections of the same registry
+ * store, keyed by the loaded {@link @deepseek-ai/dsh-code-runtime#CodeRuntime.language | code
+ * runtime's language}.
+ *
+ * Under `mode: 'code'` the native tool schemas are omitted from the request, so this generated
+ * SDK is the model's ONLY source for each tool's argument names, required fields, types,
+ * descriptions, and canonical output shapes; under `mode: 'both'` the native schemas ship
+ * alongside it and it is one of two. Object-shaped arguments and outputs therefore render as one
+ * named `TypedDict` per tool (and per nested object), not an opaque `dict[str, Any]`, so the
+ * shape survives into the program under the mode that has nothing else to carry it.
+ *
+ * Line-budget layout: `py-names.ts` holds the shared naming/state/text-escape machinery,
+ * `py-render.ts` the {@link renderType} walker, `py-sdk-doc.ts` the `renderToolsSdkPy`
+ * document renderer; this file stays the public barrel — both exports re-exported here.
+ * @module @dsh-cc/tools/src/py-types
+ */
+import { renderType } from "./py-render.js";
+export { renderToolsSdkPy } from "./py-sdk-doc.js";
+/**
+ * Map one JSON-Schema node to a context-free Python type expression from the
+ * `typing` module. Handles every unified schema construct — `object` (degraded
+ * to `dict[str, Any]`: naming a `TypedDict` requires the render context that
+ * {@link renderToolsSdkPy} supplies), `const`/`enum` (→ `Literal[...]`),
+ * `oneOf` (→ union), `string`/`number`/`integer`/`boolean`/`null`, `array`
+ * (`items` → `list[T]`) — and returns `Any` for an unsupported or malformed
+ * schema, matching the TS flavor's `unknown` fallback. Type annotations in the
+ * emitted SDK are advisory: Python does not enforce them at runtime.
+ * @param schema - the JSON-Schema node.
+ * @returns the Python type text.
+ */
+export function jsonSchemaToPy(schema) {
+    // A throwaway state whose class collector never escapes: an object with
+    // properties has nowhere to declare its TypedDict and degrades to
+    // dict[str, Any]. renderToolsSdkPy drives the named-TypedDict path.
+    return renderType(schema, '', { classes: [], usedClassNames: new Set(), nextClassCounter: new Map(), typing: new Set() });
+}
+//# sourceMappingURL=py-types.js.map

package/lib/py-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"py-types.js","sourceRoot":"","sources":["../src/py-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAElD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAAC,MAAe;IAC5C,wEAAwE;IACxE,kEAAkE;IAClE,oEAAoE;IACpE,OAAO,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,cAAc,EAAE,IAAI,GAAG,EAAE,EAAE,gBAAgB,EAAE,IAAI,GAAG,EAAE,EAAE,MAAM,EAAE,IAAI,GAAG,EAAE,EAAE,CAAC,CAAA;AAC3H,CAAC"}

package/lib/run-code-defs.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The model-facing `run_code` definition vocabulary: the tool name, its
+ * per-language schema flavors, and the failure error type shared by the
+ * Code Mode transport in {@link ./code-mode.ts}.
+ * @module dsh-tools/run-code-defs
+ */
+import { HarnessError } from '@deepseek-ai/dsh-llm';
+import type { CodeRuntime } from '@deepseek-ai/dsh-code-runtime';
+/** The model-facing name of the Code Mode tool. */
+export declare const RUN_CODE_NAME = "run_code";
+/** The `tools:sdk` section order: inside the 100–199 tool-guidance band, after per-tool guidance sections. */
+export declare const SDK_SECTION_ORDER = 150;
+/**
+ * The language-specific `run_code` schema text: the tool `description` and its
+ * `code` parameter description, kept together so a language's two model-facing
+ * strings share one source of truth. Keyed by `CodeRuntime.language`, mirroring
+ * `SDK_RENDERERS` in {@link ./index.ts}. The emitted flavor MUST match the
+ * semantics the same language's SDK instructions promise, so the model never
+ * receives a TypeScript schema beside a Python SDK (or vice versa).
+ */
+interface RunCodeFlavor {
+    /** The tool `description` the model sees for this language. */
+    readonly description: string;
+    /** The `code` parameter's description for this language. */
+    readonly codeDescription: string;
+}
+/**
+ * The TypeScript flavor: the fallback for a schema read with no runtime
+ * mounted ({@link resolveFlavor} owns which readers reach that). A real
+ * assembly always resolves a runtime first, so the model never sees this
+ * fallback outside its own language.
+ */
+export declare const TYPESCRIPT_FLAVOR: RunCodeFlavor;
+/**
+ * The languages Code Mode ships a presentation for. Both per-language tables —
+ * {@link RUN_CODE_FLAVORS} here and `SDK_RENDERERS` in {@link ./index.ts} — are
+ * checked against this union with `satisfies`, so a language added to one and
+ * not the other fails `typecheck` instead of waiting for a runtime that reports
+ * it. The tables stay declared `Record<string, …>` because `CodeRuntime.language`
+ * is an unconstrained `string`: this union pins what the harness ships, while the
+ * `Object.hasOwn` guards reject what a mounted runtime may report.
+ */
+export type CodeSdkLanguage = 'typescript' | 'python';
+/**
+ * The `description` parameter's model-facing description: language-independent
+ * (the UI label contract is the same for every runtime), shared between the
+ * static spec and the language-aware `parameters` getter so the two emissions
+ * can never drift.
+ */
+export declare const RUN_CODE_DESCRIPTION_PARAM_DESCRIPTION: string;
+/**
+ * Resolve the {@link RunCodeFlavor} for the loaded runtime's language, read at
+ * schema-emission time so the model-visible `run_code` schema always matches
+ * the SDK section's language. `peekRuntime` returns `undefined` only when no
+ * runtime is mounted, which reaches this function through definition readers
+ * and `schemas()` — the doc-catalog harvest is the only shipped one, and none
+ * of them feeds a model, because `wireSchemas` calls `requireCodeRuntime`
+ * before projecting — so that path degrades to {@link TYPESCRIPT_FLAVOR}. A
+ * mounted runtime whose language has no flavor entry fails loud, exactly as
+ * `requireCodeRuntime` rejects it at assembly. Keeping this table in step with
+ * `SDK_RENDERERS` is the compiler's job ({@link CodeSdkLanguage}); what this
+ * guard owns is the runtime-supplied language neither table knows, which never
+ * yields a wrong-language schema for a real runtime.
+ */
+export declare function resolveFlavor(peekRuntime: () => CodeRuntime | undefined): RunCodeFlavor;
+/**
+ * Thrown by `run_code` when the program run itself failed — a program
+ * exception, a budget expiry, an abort, or substrate death. Extends
+ * {@link HarnessError} (`code: 'CODE_RUN_FAILED'`); the registry's execution
+ * pipeline converts it into a structured `isError` result whose text carries
+ * the failure kind plus the captured logs, so the model can self-correct.
+ */
+export declare class CodeRunFailedError extends HarnessError {
+    constructor(message: string);
+}
+export {};
+//# sourceMappingURL=run-code-defs.d.ts.map

package/lib/run-code-defs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-code-defs.d.ts","sourceRoot":"","sources":["../src/run-code-defs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAEhE,mDAAmD;AACnD,eAAO,MAAM,aAAa,aAAa,CAAA;AAEvC,8GAA8G;AAC9G,eAAO,MAAM,iBAAiB,MAAM,CAAA;AAEpC;;;;;;;GAOG;AACH,UAAU,aAAa;IACrB,+DAA+D;IAC/D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,4DAA4D;IAC5D,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CACjC;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAQ/B,CAAA;AAiBD;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG,QAAQ,CAAA;AAQrD;;;;;GAKG;AACH,eAAO,MAAM,sCAAsC,QAGkC,CAAA;AAErF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,WAAW,GAAG,SAAS,GAAG,aAAa,CAiBvF;AAED;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,OAAO,EAAE,MAAM;CAI5B"}

package/lib/run-code-defs.js

@@ -0,0 +1,98 @@
+/**
+ * The model-facing `run_code` definition vocabulary: the tool name, its
+ * per-language schema flavors, and the failure error type shared by the
+ * Code Mode transport in {@link ./code-mode.ts}.
+ * @module dsh-tools/run-code-defs
+ */
+import { HarnessError } from '@deepseek-ai/dsh-llm';
+/** The model-facing name of the Code Mode tool. */
+export const RUN_CODE_NAME = 'run_code';
+/** The `tools:sdk` section order: inside the 100–199 tool-guidance band, after per-tool guidance sections. */
+export const SDK_SECTION_ORDER = 150;
+/**
+ * The TypeScript flavor: the fallback for a schema read with no runtime
+ * mounted ({@link resolveFlavor} owns which readers reach that). A real
+ * assembly always resolves a runtime first, so the model never sees this
+ * fallback outside its own language.
+ */
+export const TYPESCRIPT_FLAVOR = {
+    description: 'Execute a TypeScript program against the available tools. Takes two required '
+        + 'arguments: `code`, the BODY of an async function (erasable syntax only; top-level '
+        + '`await` and `return` work), and `description`, a short summary of what the program '
+        + 'does. Call tools as `await tools.name(args)` per the declarations in the system '
+        + 'prompt. Only what you print or return comes back — curate it.',
+    codeDescription: 'The program: the body of an async TypeScript function.',
+};
+/**
+ * The Python flavor: the body of an async function, top-level `await` and
+ * `return`, answer via `print` and/or the returned value, matching
+ * {@link ./py-types.ts}'s SDK instructions.
+ */
+const PYTHON_FLAVOR = {
+    description: 'Execute a Python program against the available tools. Takes two required '
+        + 'arguments: `code`, the BODY of an async function (top-level `await` and `return` '
+        + 'work), and `description`, a short summary of what the program does. Call tools as '
+        + '`await tools.name(args)` per the declarations in the system prompt. Answer '
+        + 'with `print(...)` and/or `return <value>` — only that comes back, so curate it.',
+    codeDescription: 'The program: the body of an async Python function.',
+};
+/** Per-language `run_code` schema flavors (see {@link RunCodeFlavor}); one entry per {@link CodeSdkLanguage}. */
+const RUN_CODE_FLAVORS = {
+    typescript: TYPESCRIPT_FLAVOR,
+    python: PYTHON_FLAVOR,
+};
+/**
+ * The `description` parameter's model-facing description: language-independent
+ * (the UI label contract is the same for every runtime), shared between the
+ * static spec and the language-aware `parameters` getter so the two emissions
+ * can never drift.
+ */
+export const RUN_CODE_DESCRIPTION_PARAM_DESCRIPTION = 'Clear, concise description of what this program does in active voice, '
+    + '5-10 words (shown in the UI). Examples: "Count TODO markers across packages"; '
+    + '"Read failing test and its fixture"; "Rename config key in every cordis.yml".';
+/**
+ * Resolve the {@link RunCodeFlavor} for the loaded runtime's language, read at
+ * schema-emission time so the model-visible `run_code` schema always matches
+ * the SDK section's language. `peekRuntime` returns `undefined` only when no
+ * runtime is mounted, which reaches this function through definition readers
+ * and `schemas()` — the doc-catalog harvest is the only shipped one, and none
+ * of them feeds a model, because `wireSchemas` calls `requireCodeRuntime`
+ * before projecting — so that path degrades to {@link TYPESCRIPT_FLAVOR}. A
+ * mounted runtime whose language has no flavor entry fails loud, exactly as
+ * `requireCodeRuntime` rejects it at assembly. Keeping this table in step with
+ * `SDK_RENDERERS` is the compiler's job ({@link CodeSdkLanguage}); what this
+ * guard owns is the runtime-supplied language neither table knows, which never
+ * yields a wrong-language schema for a real runtime.
+ */
+export function resolveFlavor(peekRuntime) {
+    const runtime = peekRuntime();
+    if (runtime === undefined) {
+        // No runtime mounted: reached by definition readers and `schemas()`, of
+        // which the doc-catalog harvest is the only shipped one. None feeds a
+        // model — `wireSchemas` calls `requireCodeRuntime` before projecting, so
+        // the assembly path never arrives here. Degrade to the TS default.
+        return TYPESCRIPT_FLAVOR;
+    }
+    // Own-property read: a language like `toString`/`constructor` would otherwise
+    // resolve an inherited Object.prototype member as a flavor.
+    const flavor = RUN_CODE_FLAVORS[runtime.language];
+    if (!Object.hasOwn(RUN_CODE_FLAVORS, runtime.language) || flavor === undefined) {
+        const known = Object.keys(RUN_CODE_FLAVORS).map(name => JSON.stringify(name)).join(', ');
+        throw new Error(`dsh-tools: no run_code schema flavor registered for runtime language ${JSON.stringify(runtime.language)} (known: ${known})`);
+    }
+    return flavor;
+}
+/**
+ * Thrown by `run_code` when the program run itself failed — a program
+ * exception, a budget expiry, an abort, or substrate death. Extends
+ * {@link HarnessError} (`code: 'CODE_RUN_FAILED'`); the registry's execution
+ * pipeline converts it into a structured `isError` result whose text carries
+ * the failure kind plus the captured logs, so the model can self-correct.
+ */
+export class CodeRunFailedError extends HarnessError {
+    constructor(message) {
+        super(message, 'CODE_RUN_FAILED');
+        this.name = 'CodeRunFailedError';
+    }
+}
+//# sourceMappingURL=run-code-defs.js.map

package/lib/run-code-defs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-code-defs.js","sourceRoot":"","sources":["../src/run-code-defs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAGnD,mDAAmD;AACnD,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAA;AAEvC,8GAA8G;AAC9G,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAG,CAAA;AAiBpC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAkB;IAC9C,WAAW,EACT,+EAA+E;UAC7E,oFAAoF;UACpF,qFAAqF;UACrF,kFAAkF;UAClF,+DAA+D;IACnE,eAAe,EAAE,wDAAwD;CAC1E,CAAA;AAED;;;;GAIG;AACH,MAAM,aAAa,GAAkB;IACnC,WAAW,EACT,2EAA2E;UACzE,mFAAmF;UACnF,oFAAoF;UACpF,6EAA6E;UAC7E,iFAAiF;IACrF,eAAe,EAAE,oDAAoD;CACtE,CAAA;AAaD,iHAAiH;AACjH,MAAM,gBAAgB,GAAkC;IACtD,UAAU,EAAE,iBAAiB;IAC7B,MAAM,EAAE,aAAa;CAC2B,CAAA;AAElD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,sCAAsC,GAC/C,wEAAwE;MACtE,gFAAgF;MAChF,+EAA+E,CAAA;AAErF;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,aAAa,CAAC,WAA0C;IACtE,MAAM,OAAO,GAAG,WAAW,EAAE,CAAA;IAC7B,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,wEAAwE;QACxE,sEAAsE;QACtE,yEAAyE;QACzE,mEAAmE;QACnE,OAAO,iBAAiB,CAAA;IAC1B,CAAC;IACD,8EAA8E;IAC9E,4DAA4D;IAC5D,MAAM,MAAM,GAAG,gBAAgB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;IACjD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,gBAAgB,EAAE,OAAO,CAAC,QAAQ,CAAC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QAC/E,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACxF,MAAM,IAAI,KAAK,CAAC,wEAAwE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,YAAY,KAAK,GAAG,CAAC,CAAA;IAC/I,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,OAAO,kBAAmB,SAAQ,YAAY;IAClD,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAA;QACjC,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAA;IAClC,CAAC;CACF"}

package/lib/runtime-code.d.ts

@@ -0,0 +1,65 @@
+/**
+ * ToolRuntime Code Mode collaborators: the reserved `run_code` transport
+ * factory wiring, the code-runtime resolver, the code-dispatch log waterfall,
+ * and the approval-seam `ask` resolution. Bodies are verbatim moves from the
+ * former `ToolRuntime` methods with `this.` → `rt.`.
+ * @module
+ */
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+import type { CodeRuntime } from '@deepseek-ai/dsh-code-runtime';
+import type { CodeDispatchLog, PreToolDecision, ToolDefinition, ToolExecution, ToolPresentationMode } from './tool-types.ts';
+import type { ToolAskResolution } from './tool-layer.ts';
+import type { ToolRuntimeCore } from './runtime-core.ts';
+/**
+ * The reserved `run_code` transport, built on first need.
+ *
+ * It never enters the global layer: per-agent restrictions must not remove
+ * it, and a scoped registration must not shadow it. The visibility resolver
+ * appends it after resolving the filterable global/scoped capability layers,
+ * and only for scopes whose mode actually presents it.
+ * @param rt - the owning runtime.
+ * @returns the shared transport definition.
+ */
+export declare function requireCodeTransport(rt: ToolRuntimeCore): ToolDefinition;
+/**
+ * Resolve the code runtime or throw the actionable misconfiguration error.
+ * Read at use time (assembly / run_code execution), NOT via static
+ * `inject`: an inject entry would hold `ctx.tools` — and every tool plugin
+ * behind it — hostage to a code runtime existing even under `mode:
+ * 'native'` (the loop's optional-backend idiom, same as
+ * `sessionPersistence`).
+ *
+ * Assembly and `run_code` execution read separately, so the language is not
+ * bound to a request. Harmless while one published backend exists — both
+ * reads return the same flavor — but a reload that swapped in a second
+ * language between them would hand a program written against one SDK to the
+ * other. Binding it is deferred until a second backend ships (the first
+ * point it is testable); rationale in the
+ * [language-dispatch note](../../../../.agents/notes/implemented/feature/2026-07-31-code-mode-language-dispatch.md).
+ */
+export declare function requireCodeRuntime(rt: ToolRuntimeCore, mode: ToolPresentationMode): CodeRuntime;
+/**
+ * Run the `tools/code-dispatch-log` waterfall over one settled sub-dispatch
+ * and return the content the bridge should log on `tool/code-dispatch`.
+ * Contained: when a listener throws, the method logs the original settled
+ * content; that failure must not fail the dispatch or omit the settle event. Private:
+ * the ONE consumer is the `run_code` bridge this registry constructs, which
+ * receives it as a capability parameter (the `requireRuntime` idiom) — the
+ * waterfall, not this invoker, is the public extension point.
+ */
+export declare function shapeDispatchLog(rt: ToolRuntimeCore, dispatch: CodeDispatchLog): Promise<ContentBlock[]>;
+/**
+ * Resolve an `ask` decision to allow/deny through the approval seam. The
+ * seam is consumed opportunistically with `ctx.get('approval')` — a
+ * deployment that composes no ApprovalService keeps the historical degrade
+ * to deny, and an unmount mid-session degrades the same way on the next ask.
+ * An agent-less execution also degrades: without an agent there is no
+ * session to audit to and no UI to route to. Otherwise the outcome maps
+ * one-to-one — `allowed-once` proceeds; the three non-grants deny with
+ * distinct reasons so the model can tell a human "no" from an absent
+ * approval channel.
+ */
+export declare function serviceAsk(rt: ToolRuntimeCore, exec: ToolExecution, ask: Extract<PreToolDecision, {
+    kind: 'ask';
+}>): Promise<ToolAskResolution>;
+//# sourceMappingURL=runtime-code.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-code.d.ts","sourceRoot":"","sources":["../src/runtime-code.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAExD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAMhE,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAC5H,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,eAAe,GAAG,cAAc,CAWxE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,oBAAoB,GAAG,WAAW,CAU/F;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,eAAe,EAAE,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAU9G;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,UAAU,CAC9B,EAAE,EAAE,eAAe,EACnB,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,GAC7C,OAAO,CAAC,iBAAiB,CAAC,CAqC5B"}

package/lib/runtime-code.js

@@ -0,0 +1,129 @@
+/**
+ * ToolRuntime Code Mode collaborators: the reserved `run_code` transport
+ * factory wiring, the code-runtime resolver, the code-dispatch log waterfall,
+ * and the approval-seam `ask` resolution. Bodies are verbatim moves from the
+ * former `ToolRuntime` methods with `this.` → `rt.`.
+ * @module
+ */
+import { scopeTarget } from '@deepseek-ai/dsh-scope';
+import { assertNever } from '@deepseek-ai/dsh-llm';
+import { createRunCodeTool } from "./code-mode.js";
+import { errorMessage } from "./abort-utils.js";
+import { SDK_RENDERERS } from "./runtime-core.js";
+/**
+ * The reserved `run_code` transport, built on first need.
+ *
+ * It never enters the global layer: per-agent restrictions must not remove
+ * it, and a scoped registration must not shadow it. The visibility resolver
+ * appends it after resolving the filterable global/scoped capability layers,
+ * and only for scopes whose mode actually presents it.
+ * @param rt - the owning runtime.
+ * @returns the shared transport definition.
+ */
+export function requireCodeTransport(rt) {
+    rt.codeTransport ??= createRunCodeTool(rt, {
+        requireRuntime: () => rt.requireCodeRuntime(rt.defaultMode),
+        // The language-aware description/parameters getters read the runtime
+        // without demanding one, so a native-default process can still project
+        // the transport for an agent that chose code.
+        peekRuntime: () => rt.ctx.get('codeRuntime'),
+        maxParallel: rt.maxParallelSubCalls,
+        shapeDispatchLog: dispatch => rt.shapeDispatchLog(dispatch),
+    });
+    return rt.codeTransport;
+}
+/**
+ * Resolve the code runtime or throw the actionable misconfiguration error.
+ * Read at use time (assembly / run_code execution), NOT via static
+ * `inject`: an inject entry would hold `ctx.tools` — and every tool plugin
+ * behind it — hostage to a code runtime existing even under `mode:
+ * 'native'` (the loop's optional-backend idiom, same as
+ * `sessionPersistence`).
+ *
+ * Assembly and `run_code` execution read separately, so the language is not
+ * bound to a request. Harmless while one published backend exists — both
+ * reads return the same flavor — but a reload that swapped in a second
+ * language between them would hand a program written against one SDK to the
+ * other. Binding it is deferred until a second backend ships (the first
+ * point it is testable); rationale in the
+ * [language-dispatch note](../../../../.agents/notes/implemented/feature/2026-07-31-code-mode-language-dispatch.md).
+ */
+export function requireCodeRuntime(rt, mode) {
+    const runtime = rt.ctx.get('codeRuntime');
+    if (!runtime) {
+        throw new Error(`dsh-tools: mode "${mode}" requires a code runtime — load a ctx.codeRuntime implementation (e.g. @deepseek-ai/dsh-code-runtime-worker-thread) or set tools mode to "native"`);
+    }
+    if (!Object.hasOwn(SDK_RENDERERS, runtime.language)) {
+        const known = Object.keys(SDK_RENDERERS).map(name => JSON.stringify(name)).join(', ');
+        throw new Error(`dsh-tools: no SDK renderer registered for runtime language ${JSON.stringify(runtime.language)} (known: ${known})`);
+    }
+    return runtime;
+}
+/**
+ * Run the `tools/code-dispatch-log` waterfall over one settled sub-dispatch
+ * and return the content the bridge should log on `tool/code-dispatch`.
+ * Contained: when a listener throws, the method logs the original settled
+ * content; that failure must not fail the dispatch or omit the settle event. Private:
+ * the ONE consumer is the `run_code` bridge this registry constructs, which
+ * receives it as a capability parameter (the `requireRuntime` idiom) — the
+ * waterfall, not this invoker, is the public extension point.
+ */
+export async function shapeDispatchLog(rt, dispatch) {
+    try {
+        return await rt.ctx.waterfall(scopeTarget(rt, dispatch.agent), 'tools/code-dispatch-log', dispatch, () => Promise.resolve(dispatch.content));
+    }
+    catch (error) {
+        rt.ctx.logger.warn(`tools: code-dispatch-log listener failed for ${dispatch.name}: ${errorMessage(error)}; logging the original settled content`);
+        return dispatch.content;
+    }
+}
+/**
+ * Resolve an `ask` decision to allow/deny through the approval seam. The
+ * seam is consumed opportunistically with `ctx.get('approval')` — a
+ * deployment that composes no ApprovalService keeps the historical degrade
+ * to deny, and an unmount mid-session degrades the same way on the next ask.
+ * An agent-less execution also degrades: without an agent there is no
+ * session to audit to and no UI to route to. Otherwise the outcome maps
+ * one-to-one — `allowed-once` proceeds; the three non-grants deny with
+ * distinct reasons so the model can tell a human "no" from an absent
+ * approval channel.
+ */
+export async function serviceAsk(rt, exec, ask) {
+    const approval = rt.ctx.get('approval');
+    if (approval === undefined) {
+        return {
+            decision: { kind: 'deny', reason: ask.reason ?? `tool "${exec.name}" requires approval (not yet supported)` },
+            approvalCancelled: false,
+        };
+    }
+    if (exec.agent === undefined) {
+        return {
+            decision: { kind: 'deny', reason: `tool "${exec.name}" requires approval, but the call has no agent to route it through` },
+            approvalCancelled: false,
+        };
+    }
+    const outcome = await approval.request({
+        agent: exec.agent,
+        toolName: exec.name,
+        callId: exec.callId,
+        ...ask.reason !== undefined ? { reason: ask.reason } : {},
+        signal: exec.signal,
+    });
+    switch (outcome) {
+        case 'allowed-once': return { decision: { kind: 'allow' }, approvalCancelled: false };
+        case 'rejected': return {
+            decision: { kind: 'deny', reason: `the user rejected tool "${exec.name}"` },
+            approvalCancelled: false,
+        };
+        case 'cancelled': return {
+            decision: { kind: 'deny', reason: `approval for tool "${exec.name}" was cancelled` },
+            approvalCancelled: true,
+        };
+        case 'unavailable': return {
+            decision: { kind: 'deny', reason: `tool "${exec.name}" requires approval, but no approval channel is available` },
+            approvalCancelled: false,
+        };
+        default: return assertNever(outcome, 'ApprovalOutcome');
+    }
+}
+//# sourceMappingURL=runtime-code.js.map

package/lib/runtime-code.js.map

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

package/lib/runtime-core.d.ts

@@ -0,0 +1,130 @@
+/**
+ * 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 type { Context } from '@deepseek-ai/cordis';
+import type { ScopeKey, ScopedLayers } from '@deepseek-ai/dsh-scope';
+import type { ContentBlock, ToolSchema } from '@deepseek-ai/dsh-llm';
+import type { UserMessage } from '@deepseek-ai/dsh-session';
+import type { ToolProviderResult } from '@deepseek-ai/dsh-system-prompt';
+import type { CodeRuntime } from '@deepseek-ai/dsh-code-runtime';
+import type { ToolSdkSchema } from './ts-types.ts';
+import { TOOL_RUNTIME_SCHEDULER } from './scheduler.ts';
+import type { ToolLayer } from './tool-layer.ts';
+import type { ToolAskResolution, ToolCancellationState } from './tool-layer.ts';
+import type { CodeDispatchLog, MutableToolRunContext, PreToolDecision, ScheduledToolDispatch, ScheduledToolPreparation, ToolDefinition, ToolExecution, ToolExecutionInput, ToolExecutionMode, ToolExecutionResult, ToolExecutionSuccess, ToolExecutionToken, ToolGuard, ToolPresentationMode, ToolRestriction, ToolRunContext, ToolRuntimeScheduler, ToolView } from './tool-types.ts';
+/**
+ * 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 declare const SDK_RENDERERS: Record<string, (schemas: ToolSdkSchema[]) => string>;
+/**
+ * The ToolRuntime state and pipeline surface, as consumed by the
+ * `runtime-*.ts` free-function collaborators. Every member is public on the
+ * facade class (former `private` members carry an `@internal` tag); the class
+ * remains the only constructed form.
+ */
+export interface ToolRuntimeCore {
+    /** Cordis context, inherited by the facade from `Service`. */
+    readonly ctx: Context;
+    /** Visibility layers: registration, reservation, restriction, guards. */
+    readonly layers: ScopedLayers<ToolLayer>;
+    /** Presentation for scopes that declare none; `modeFor` shadows it per scope. */
+    readonly defaultMode: ToolPresentationMode;
+    readonly maxParallelSubCalls: number;
+    /**
+     * Reserved presentation transport, kept outside the filterable registration
+     * layers. Built on first need rather than at construction: which agents run
+     * a code mode is no longer known when the service is constructed, and the
+     * transport is stateless beyond its closures over the runtime.
+     */
+    codeTransport: ToolDefinition | undefined;
+    /** Context deferred by a running tool body, keyed by its scheduler-owned execution. */
+    readonly deferredContexts: WeakMap<ToolRunContext, UserMessage[]>;
+    /** Executions whose tool body declared the current turn complete. */
+    readonly concludingExecutions: WeakSet<ToolExecution>;
+    /** Original caller cancellation, kept outside the wrapper-mutable execution object. */
+    readonly cancellationStates: WeakMap<ToolRunContext, ToolCancellationState>;
+    /** Definition-owned final content transform snapshotted before policy begins. */
+    readonly contentFinalizers: WeakMap<ToolRunContext, ToolDefinition['finalizeContent']>;
+    /** Registry-normalized results and the exact dispatch that validated each value. */
+    readonly canonicalResults: WeakMap<object, ToolExecutionToken>;
+    /** Internal staged view consumed by `dsh-agent-loop`'s parallel scheduler. */
+    readonly [TOOL_RUNTIME_SCHEDULER]: ToolRuntimeScheduler;
+    register(definition: ToolDefinition): () => void;
+    reserve(name: string): () => void;
+    isAdmitted(name: string, scope?: ScopeKey): boolean;
+    restrict(filter: ToolRestriction): () => void;
+    guard(guard: ToolGuard): () => void;
+    guardReason(exec: ToolExecution): string | undefined;
+    view(scope?: ScopeKey): ToolView;
+    get(name: string, scope?: ScopeKey): ToolDefinition | undefined;
+    resolveExecution(name: string, scope: ScopeKey | undefined, nested: boolean): ToolDefinition | undefined;
+    executionMode(exec: ToolExecutionInput): ToolExecutionMode;
+    collapseSection(): {
+        name: string;
+        order: number;
+        text: (context: {
+            scope?: ScopeKey;
+        }) => string;
+    };
+    sdkSection(): {
+        name: string;
+        order: number;
+        text: (context: {
+            scope?: ScopeKey;
+        }) => string;
+    };
+    modeFor(scope?: ScopeKey): ToolPresentationMode;
+    presentAs(mode: ToolPresentationMode): () => void;
+    wireSchemas(scope?: ScopeKey): ToolProviderResult;
+    schemas(scope?: ScopeKey): ToolSchema[];
+    sdkSchemas(scope?: ScopeKey): ToolSdkSchema[];
+    schemaOf(definition: ToolDefinition, detachParameters: boolean): ToolSchema;
+    collapses(name: string, scope: ScopeKey | undefined, nested: boolean): boolean;
+    execute(exec: ToolExecutionInput): Promise<ToolExecutionResult>;
+    completeScheduledExecution(prepared: ScheduledToolPreparation): Promise<ToolExecutionResult>;
+    createExecution(exec: ToolExecutionInput): ScheduledToolPreparation | {
+        kind: 'ready';
+        exec: MutableToolRunContext;
+    };
+    prepareScheduledExecution(input: ToolExecutionInput): Promise<ScheduledToolPreparation>;
+    prepareExecution<T>(input: ToolExecutionInput, next: (prepared: ScheduledToolPreparation) => T | PromiseLike<T>): Promise<T>;
+    callerCancelled(exec: ToolRunContext): boolean;
+    cancellationResult(exec: ToolRunContext, prior?: ToolExecutionResult): ToolExecutionResult;
+    dispatchToolBody(exec: MutableToolRunContext): Promise<ToolExecutionResult>;
+    dispatchScheduledExecution(exec: ToolRunContext): Promise<ScheduledToolDispatch>;
+    finalizeScheduledExecution(exec: ToolRunContext, result: ToolExecutionResult): Promise<ToolExecutionResult>;
+    finishScheduledExecution(exec: ToolRunContext, result: ToolExecutionResult): ToolExecutionResult;
+    applyFinalContent(exec: ToolRunContext, result: ToolExecutionResult): ToolExecutionResult;
+    notifyResult(exec: ToolExecution, result: ToolExecutionResult): void;
+    postExecute(exec: ToolExecution, result: ToolExecutionResult): Promise<ToolExecutionResult>;
+    markCanonical<T extends ToolExecutionResult>(exec: ToolExecution, result: T): T;
+    createSuccessResult(exec: ToolExecution, tool: ToolDefinition, candidate: unknown): ToolExecutionSuccess;
+    normalizeDispatchResult(exec: ToolExecution, result: ToolExecutionResult): ToolExecutionResult;
+    materializeFinalResult(result: ToolExecutionResult): ToolExecutionResult;
+    requireCodeTransport(): ToolDefinition;
+    requireCodeRuntime(mode: ToolPresentationMode): CodeRuntime;
+    shapeDispatchLog(dispatch: CodeDispatchLog): Promise<ContentBlock[]>;
+    serviceAsk(exec: ToolExecution, ask: Extract<PreToolDecision, {
+        kind: 'ask';
+    }>): Promise<ToolAskResolution>;
+}
+//# sourceMappingURL=runtime-core.d.ts.map

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

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