@llblab/pi-actors 0.29.2 → 0.30.0

package/dist/lib/actor-inspector-tui.js

@@ -7,7 +7,165 @@ import * as path from "node:path";
 import { visibleWidth } from "@earendil-works/pi-tui";
 import * as Limits from "./limits.js";
 import * as Paths from "./paths.js";
-import { readJsonFileResilient, readJsonlFileResilient } from "./state-readers.js";
+import { readJsonFileResilient, readJsonlFileResilient, } from "./state-readers.js";
+export const DEFAULT_ACTOR_INSPECTOR_ROWS = 12;
+export const ACTOR_INSPECTOR_COMMAND_DESCRIPTIONS = {
+    filter: "Filter actor inspector rows: all, room, direct, broadcast, unread, branch <name>, mention <text>",
+    inspect: "Inspect actor message by visible number",
+    toggle: "Toggle actor inspector widget; optional row count",
+};
+export function createActorInspectorControllerState() {
+    return {
+        readKeys: new Set(),
+        roomLimitPerRun: DEFAULT_ACTOR_INSPECTOR_ROWS,
+        rows: DEFAULT_ACTOR_INSPECTOR_ROWS,
+        unreadOnly: false,
+        visible: false,
+    };
+}
+export function getActorInspectorPreviewOptions(state, ownerId) {
+    return {
+        channels: state.channels,
+        currentRunOnly: true,
+        branch: state.branch,
+        mention: state.mention,
+        ownerId,
+        readKeys: state.readKeys,
+        roomLimitPerRun: state.roomLimitPerRun,
+        unreadOnly: state.unreadOnly,
+    };
+}
+export function handleActorInspectorToggle(state, args) {
+    const raw = Array.isArray(args) ? args[0] : String(args ?? "");
+    if (String(raw).trim()) {
+        const rows = Number.parseInt(String(raw), 10);
+        if (!Number.isFinite(rows) || rows <= 0) {
+            return {
+                notify: "Usage: /actors-inspector-toggle [rows] where rows > 0",
+                type: "warning",
+                update: false,
+            };
+        }
+        state.rows = rows;
+        state.roomLimitPerRun = rows;
+        state.selectedSequence = undefined;
+        state.visible = true;
+        return {
+            notify: `Actor inspector rows ${rows}`,
+            type: "info",
+            update: true,
+        };
+    }
+    if (state.selectedSequence !== undefined) {
+        state.selectedSequence = undefined;
+        state.visible = true;
+        return { notify: "Actor inspector table", type: "info", update: true };
+    }
+    if (state.visible)
+        state.visible = false;
+    else {
+        state.rows = DEFAULT_ACTOR_INSPECTOR_ROWS;
+        state.roomLimitPerRun = DEFAULT_ACTOR_INSPECTOR_ROWS;
+        state.visible = true;
+    }
+    return {
+        notify: `Actor inspector ${state.visible ? "shown" : "hidden"}`,
+        type: "info",
+        update: true,
+    };
+}
+export function handleActorInspectorFilter(state, args) {
+    const parts = Array.isArray(args)
+        ? args.map(String)
+        : String(args ?? "").split(/\s+/);
+    const mode = (parts[0] ?? "").trim().toLowerCase();
+    if (!mode || mode === "all" || mode === "clear") {
+        state.channels = undefined;
+        state.mention = undefined;
+        state.branch = undefined;
+        state.unreadOnly = false;
+    }
+    else if (mode === "room" || mode === "direct" || mode === "broadcast") {
+        state.channels = [mode];
+        state.mention = undefined;
+    }
+    else if (mode === "unread") {
+        state.unreadOnly = true;
+    }
+    else if (mode === "branch" || mode === "current-branch") {
+        const branch = parts.slice(1).join(" ").trim();
+        if (!branch) {
+            return {
+                notify: `Usage: /actors-inspector-filter ${mode} <branch-name>`,
+                type: "warning",
+                update: false,
+            };
+        }
+        state.branch = branch;
+    }
+    else if (mode === "mention") {
+        const mention = parts.slice(1).join(" ").trim();
+        if (!mention) {
+            return {
+                notify: "Usage: /actors-inspector-filter mention <text>",
+                type: "warning",
+                update: false,
+            };
+        }
+        state.channels = undefined;
+        state.mention = mention;
+    }
+    else {
+        return {
+            notify: "Usage: /actors-inspector-filter all|room|direct|broadcast|unread|branch <name>|mention <text>",
+            type: "warning",
+            update: false,
+        };
+    }
+    state.selectedSequence = undefined;
+    state.visible = true;
+    return {
+        notify: `Actor inspector filter ${mode || "all"}`,
+        type: "info",
+        update: true,
+    };
+}
+export function handleActorInspectorInspect(state, args, previews) {
+    const raw = Array.isArray(args) ? args[0] : String(args ?? "");
+    return selectActorInspectorSequence(state, Number.parseInt(String(raw), 10), previews);
+}
+export function selectActorInspectorSequence(state, sequence, previews) {
+    if (!Number.isFinite(sequence) || sequence <= 0) {
+        return {
+            notify: "Usage: /actors-inspect <number>",
+            type: "warning",
+            update: false,
+        };
+    }
+    const preview = previews.find((item) => item.sequence === sequence);
+    if (preview)
+        state.readKeys.add(inspectorPreviewReadKey(preview));
+    state.selectedSequence = sequence;
+    state.visible = true;
+    return {
+        notify: `Actor inspect item ${sequence}`,
+        type: "info",
+        update: true,
+    };
+}
+export function renderActorInspectorPanel(input) {
+    const previews = readActorInspectorPreviews(input.stateRoot, input.state.rows, getActorInspectorPreviewOptions(input.state, input.ownerId));
+    const rows = (input.state.selectedSequence !== undefined
+        ? renderInspectorItemView(previews, input.width, input.style, {
+            sequence: input.state.selectedSequence,
+        })
+        : renderInspectorWidget(previews, input.width, input.style)) ?? [];
+    const run = previews[0]?.run;
+    const roster = input.state.selectedSequence === undefined && run
+        ? renderInspectorRosterPanel(readActorInspectorRoster(input.stateRoot, run), input.width, input.style)
+        : undefined;
+    return roster ? [...roster, ...rows] : rows;
+}
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value

package/dist/lib/observability.d.ts

@@ -35,6 +35,32 @@ export interface RunSummary {
     runs: RunObservation[];
     total: number;
 }
+export interface RunUiObservationState {
+    eventLines: Map<string, number>;
+    frame: number;
+    observed: Map<string, RunObservedStatus>;
+    outboxEventIds: Map<string, Set<string>>;
+}
+export interface RunUiSnapshot {
+    outboxEvents: RunOutboxEvent[];
+    status: string | undefined;
+    summary: RunSummary;
+    transitions: RunTransition[];
+}
+export interface RunUiNotificationSink {
+    notify(message: string, level: "info" | "warning" | "error"): void;
+    sendFollowUp(message: {
+        customType: string;
+        content: string;
+        display: true;
+        details: unknown;
+    }): void;
+}
+export declare function createRunUiObservationState(): RunUiObservationState;
+export declare function readRunUiSnapshot(state: RunUiObservationState, ownerId: string): RunUiSnapshot;
+export declare function pruneRunUiObservationState(state: RunUiObservationState, snapshot: Pick<RunUiSnapshot, "summary" | "transitions">): void;
+export declare function deliverRunTransitionNotifications(transitions: RunTransition[], sink: RunUiNotificationSink): void;
+export declare function deliverRunOutboxNotifications(events: RunOutboxEvent[], sink: RunUiNotificationSink): void;
 export interface RunRetirementCandidate {
     activeSubagents: number;
     childRuns: number;
@@ -49,6 +75,14 @@ export interface RunRetirementExecution {
     run: string;
     stateDir: string;
 }
+export interface RunStateWatcher {
+    close(): void;
+    refresh(): void;
+}
+export declare function createRunStateWatcher(input: {
+    stateRoot?: string;
+    onChange: () => void;
+}): RunStateWatcher;
 export interface RunRetirementExecutorOptions {
     attempted?: Set<string>;
     cancelRun: (candidate: RunRetirementCandidate) => Record<string, unknown>;

package/dist/lib/observability.js

@@ -3,11 +3,113 @@
  * Zones: async runtime, ambient UI, diagnostics
  * Owns ambient summaries, terminal events, and run outbox delivery for detached command-template runs
  */
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, watch, } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, } from "node:path";
 import * as AsyncRuns from "./async-runs.js";
 import * as Paths from "./paths.js";
 import { readJsonlFileResilient } from "./state-readers.js";
+export function createRunUiObservationState() {
+    return {
+        eventLines: new Map(),
+        frame: 0,
+        observed: new Map(),
+        outboxEventIds: new Map(),
+    };
+}
+export function readRunUiSnapshot(state, ownerId) {
+    const summary = summarizeRuns(undefined, ownerId);
+    const status = renderRunStatus(summary, state.frame++);
+    return {
+        outboxEvents: detectRunOutboxEvents(state.eventLines, summary, state.outboxEventIds),
+        status,
+        summary,
+        transitions: detectRunTransitions(state.observed, summary),
+    };
+}
+export function pruneRunUiObservationState(state, snapshot) {
+    pruneRunObservationState(state.observed, state.eventLines, snapshot.summary, snapshot.transitions.map((transition) => transition.stateDir ?? transition.run), state.outboxEventIds);
+}
+export function deliverRunTransitionNotifications(transitions, sink) {
+    for (const transition of transitions) {
+        if (!shouldNotifyRunTransition(transition))
+            continue;
+        const text = formatRunTransitionMessage(transition);
+        sink.notify(text, getRunTransitionNotificationType(transition));
+        if (!shouldSendRunTransitionFollowUp(transition))
+            continue;
+        sink.sendFollowUp({
+            customType: "pi-actors-run",
+            content: text,
+            display: true,
+            details: transition,
+        });
+    }
+}
+export function deliverRunOutboxNotifications(events, sink) {
+    for (const event of events) {
+        if (!shouldNotifyRunOutboxEvent(event))
+            continue;
+        const text = formatRunOutboxMessage(event);
+        sink.notify(text, getRunOutboxNotificationType(event));
+        if (!shouldSendRunOutboxFollowUp(event))
+            continue;
+        sink.sendFollowUp({
+            customType: "pi-actors-run-message",
+            content: text,
+            display: true,
+            details: event,
+        });
+    }
+}
+export function createRunStateWatcher(input) {
+    const stateRoot = input.stateRoot ?? Paths.getRunStateRoot();
+    let stateRootWatcher;
+    const runDirWatchers = new Map();
+    const close = () => {
+        stateRootWatcher?.close();
+        stateRootWatcher = undefined;
+        for (const watcher of runDirWatchers.values())
+            watcher.close();
+        runDirWatchers.clear();
+    };
+    const watchRunDir = (stateDir) => {
+        if (runDirWatchers.has(stateDir) || !existsSync(stateDir))
+            return;
+        try {
+            const watcher = watch(stateDir, input.onChange);
+            watcher.on("error", () => {
+                watcher.close();
+                runDirWatchers.delete(stateDir);
+            });
+            runDirWatchers.set(stateDir, watcher);
+        }
+        catch {
+            // Watching is best-effort; explicit inspect remains available.
+        }
+    };
+    function refresh() {
+        if (!existsSync(stateRoot))
+            return;
+        if (!stateRootWatcher) {
+            try {
+                stateRootWatcher = watch(stateRoot, input.onChange);
+                stateRootWatcher.on("error", () => {
+                    stateRootWatcher?.close();
+                    stateRootWatcher = undefined;
+                });
+            }
+            catch {
+                // Watching is best-effort; explicit inspect remains available.
+            }
+        }
+        for (const entry of readdirSync(stateRoot, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            watchRunDir(`${stateRoot}/${entry.name}`);
+        }
+    }
+    return { close, refresh };
+}
 const TERMINAL = new Set([
     "done",
     "failed",

package/dist/lib/paths.d.ts

@@ -4,9 +4,18 @@
  * Owns agent directory, tools config, recipe root, and actor run state root resolution
  */
 export declare function getAgentDir(env?: Record<string, string | undefined>): string;
+export interface ExtensionRuntimePaths {
+    configPath: string;
+    runStateRoot: string;
+    tempDir: string;
+}
 export declare function getConfigPath(agentDir?: string): string;
 export declare function getExtensionTmpDir(agentDir?: string, extensionName?: string): string;
 export declare function getRunStateRoot(agentDir?: string): string;
+export declare function getExtensionRuntimePaths(agentDir?: string): ExtensionRuntimePaths;
+export declare const EXTENSION_RUNTIME_PATHS: ExtensionRuntimePaths;
+export declare function getExtensionSkillsDir(extensionUrl: string): string;
+export declare function getExistingExtensionSkillPaths(extensionUrl: string): string[];
 export declare function getRecipeRoot(agentDir?: string): string;
 export declare function getRecipeCandidateRoot(agentDir?: string): string;
 export declare function getPackagedRecipeRoot(): string;

package/dist/lib/paths.js

@@ -21,6 +21,21 @@ export function getExtensionTmpDir(agentDir = getAgentDir(), extensionName = "pi
 export function getRunStateRoot(agentDir = getAgentDir()) {
     return join(getExtensionTmpDir(agentDir), "runs");
 }
+export function getExtensionRuntimePaths(agentDir = getAgentDir()) {
+    return {
+        configPath: getConfigPath(agentDir),
+        runStateRoot: getRunStateRoot(agentDir),
+        tempDir: getExtensionTmpDir(agentDir),
+    };
+}
+export const EXTENSION_RUNTIME_PATHS = getExtensionRuntimePaths();
+export function getExtensionSkillsDir(extensionUrl) {
+    return join(dirname(fileURLToPath(extensionUrl)), "skills");
+}
+export function getExistingExtensionSkillPaths(extensionUrl) {
+    const skillsDir = getExtensionSkillsDir(extensionUrl);
+    return existsSync(skillsDir) ? [skillsDir] : [];
+}
 export function getRecipeRoot(agentDir = getAgentDir()) {
     return join(agentDir, "recipes");
 }

package/dist/lib/pi.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Pi SDK adapter boundary.
+ * Zones: pi agent sdk boundary, extension host adapters
+ * Owns direct pi SDK imports and exposes narrow pi-actors-facing helpers/types for the composition root.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+export type { ExtensionAPI, ExtensionContext };
+export interface PiNotificationSink {
+    notify(message: string, level: "info" | "warning" | "error"): void;
+    sendFollowUp(message: {
+        customType: string;
+        content: string;
+        display: true;
+        details: unknown;
+    }): void;
+}
+export declare function getSessionId(ctx: ExtensionContext): string;
+export declare function createNotificationSink(pi: ExtensionAPI, ctx: ExtensionContext): PiNotificationSink;
+export declare function registerToolDefinitions(pi: ExtensionAPI, definitions: Iterable<unknown>): void;

package/dist/lib/pi.js

@@ -0,0 +1,21 @@
+/**
+ * Pi SDK adapter boundary.
+ * Zones: pi agent sdk boundary, extension host adapters
+ * Owns direct pi SDK imports and exposes narrow pi-actors-facing helpers/types for the composition root.
+ */
+export function getSessionId(ctx) {
+    return ctx.sessionManager.getSessionId();
+}
+export function createNotificationSink(pi, ctx) {
+    return {
+        notify: (message, level) => ctx.ui.notify(message, level),
+        sendFollowUp: (message) => pi.sendMessage(message, {
+            deliverAs: "followUp",
+            triggerTurn: true,
+        }),
+    };
+}
+export function registerToolDefinitions(pi, definitions) {
+    for (const definition of definitions)
+        pi.registerTool(definition);
+}

package/dist/lib/runtime.d.ts

@@ -33,4 +33,9 @@ export interface ToolRegistryRuntime {
     notify(ctx: RuntimeContext, message: string, type: "info" | "warning" | "error"): void;
     registerRuntimeTool(cfg: Config.RegisteredTool): void;
 }
+export interface RecipeToolReloadWatcher {
+    close(): void;
+    watch(ctx: RuntimeContext): void;
+}
 export declare function createAutoToolsRuntime(deps: ToolRegistryRuntimeDeps): ToolRegistryRuntime;
+export declare function createRecipeToolReloadWatcher(runtime: Pick<ToolRegistryRuntime, "loadTools">): RecipeToolReloadWatcher;

package/dist/lib/runtime.js

@@ -3,6 +3,7 @@
  * Zones: runtime coordination, registry loading, pi tools
  * Owns persisted tool loading, conflict detection, runtime registration, and warning notification
  */
+import { existsSync, watch } from "node:fs";
 import * as Paths from "./paths.js";
 import * as RecipeDiscovery from "./recipe-discovery.js";
 import * as Tools from "./tools.js";
@@ -123,3 +124,50 @@ export function createAutoToolsRuntime(deps) {
         registerRuntimeTool,
     };
 }
+export function createRecipeToolReloadWatcher(runtime) {
+    let reloadTimeout;
+    let rootWatcher;
+    let failureNotified = false;
+    const close = () => {
+        rootWatcher?.close();
+        rootWatcher = undefined;
+        if (reloadTimeout)
+            clearTimeout(reloadTimeout);
+        reloadTimeout = undefined;
+    };
+    const notifyFailure = (ctx) => {
+        if (failureNotified)
+            return;
+        failureNotified = true;
+        ctx.ui.notify("Recipe live reload watcher failed; restart the session or use register_tool again to refresh recipe tools.", "warning");
+    };
+    const scheduleReload = (ctx) => {
+        failureNotified = false;
+        if (reloadTimeout)
+            clearTimeout(reloadTimeout);
+        reloadTimeout = setTimeout(() => {
+            runtime.loadTools(ctx);
+            ctx.ui.notify("Recipe tools refreshed from ~/.pi/agent/recipes", "info");
+        }, 150);
+        reloadTimeout.unref?.();
+    };
+    return {
+        close,
+        watch(ctx) {
+            const recipeRoot = Paths.getRecipeRoot();
+            if (rootWatcher || !existsSync(recipeRoot))
+                return;
+            try {
+                rootWatcher = watch(recipeRoot, () => scheduleReload(ctx));
+                rootWatcher.on("error", () => {
+                    rootWatcher?.close();
+                    rootWatcher = undefined;
+                    notifyFailure(ctx);
+                });
+            }
+            catch {
+                notifyFailure(ctx);
+            }
+        },
+    };
+}

package/dist/lib/tools.d.ts

@@ -8,6 +8,14 @@ import * as Execution from "./execution.ts";
 import * as Registry from "./registry.ts";
 export type RegisterToolInput = Registry.RegisterToolInput;
 export type RegisterToolRuntimeDeps<TContext> = Registry.RegisterToolRuntimeDeps<TContext>;
+export interface CoreActorToolDefinitionDeps<TContext extends AsyncRunToolContext> {
+    configPath: string;
+    getActiveTools: () => string[];
+    getRuntimeTool: (name: string) => unknown;
+    registryRuntime: Pick<RegisterToolRuntimeDeps<TContext>, "getExternalToolConflict" | "getTools" | "notify" | "registerRuntimeTool">;
+    setActiveTools: (toolNames: string[]) => void;
+}
+export declare const RESERVED_TOOL_NAMES: Set<string>;
 type JsonSchema = Record<string, unknown>;
 export declare function createRegisterToolDefinition<TContext>(deps: RegisterToolRuntimeDeps<TContext>): {
     name: string;
@@ -35,5 +43,6 @@ export interface ActorMessageToolDeps<TContext = unknown> {
     getTool?: (name: string) => any | undefined;
 }
 export declare function createActorMessageToolDefinition<TContext = unknown>(deps?: ActorMessageToolDeps<TContext>): any;
+export declare function createCoreActorToolDefinitions<TContext extends AsyncRunToolContext>(deps: CoreActorToolDefinitionDeps<TContext>): any[];
 export declare function createRuntimeToolDefinition(cfg: RegisteredTool, exec: Execution.RegisteredToolExec): any;
 export {};

package/dist/lib/tools.js

@@ -18,6 +18,19 @@ import * as RecipeReferences from "./recipe-references.js";
 import * as RecipeUsage from "./recipe-usage.js";
 import * as Registry from "./registry.js";
 import * as Schema from "./schema.js";
+export const RESERVED_TOOL_NAMES = new Set([
+    "read",
+    "write",
+    "edit",
+    "bash",
+    "find",
+    "grep",
+    "ls",
+    "register_tool",
+    "message",
+    "spawn",
+    "inspect",
+]);
 function stringSchema(description) {
     return { description, type: "string" };
 }
@@ -359,9 +372,15 @@ function summarizeOtherSessions(currentSession, allRuns) {
 }
 function compactSessionRuns(session, runs, summary = {}) {
     const suffix = [
-        summary.other_sessions !== undefined ? `other_sessions=${String(summary.other_sessions)}` : "",
-        summary.other_runs !== undefined ? `other_runs=${String(summary.other_runs)}` : "",
-    ].filter(Boolean).join(" ");
+        summary.other_sessions !== undefined
+            ? `other_sessions=${String(summary.other_sessions)}`
+            : "",
+        summary.other_runs !== undefined
+            ? `other_runs=${String(summary.other_runs)}`
+            : "",
+    ]
+        .filter(Boolean)
+        .join(" ");
     if (runs.length === 0)
         return `\nsession=${session} runs=0${suffix ? ` ${suffix}` : ""}`;
     return `\nsession=${session} runs=${runs.length}${suffix ? ` ${suffix}` : ""}\n${runs
@@ -578,7 +597,9 @@ function formatToolActorFailure(tool, message, params, error) {
     });
 }
 function shadowedRecipeLaunchDiagnostic(recipe) {
-    if (typeof recipe !== "string" || recipe.includes("/") || recipe.includes("~"))
+    if (typeof recipe !== "string" ||
+        recipe.includes("/") ||
+        recipe.includes("~"))
         return undefined;
     const discovery = RecipeDiscovery.discoverRecipeSources([
         { root: Paths.getRecipeRoot(), defaultTool: true, mutableUsage: true },
@@ -604,7 +625,9 @@ function writeSpawnCandidateRecipe(input, meta) {
     if (process.env.NODE_TEST_CONTEXT &&
         process.env.PI_ACTORS_ENABLE_SPAWN_CANDIDATES_IN_TEST !== "1")
         return undefined;
-    if (input.template === undefined || input.file !== undefined || input.recipe !== undefined)
+    if (input.template === undefined ||
+        input.file !== undefined ||
+        input.recipe !== undefined)
         return undefined;
     const root = Paths.getRecipeCandidateRoot();
     mkdirSync(root, { recursive: true });
@@ -656,12 +679,15 @@ async function routeBranchEnvelope(stateDir, runId, recipient, message, _options
         return await AsyncRuns.sendRunMessage(runId, JSON.stringify(branchMessage));
     }
     catch (error) {
-        const record = error && typeof error === "object" ? error : {};
+        const record = error && typeof error === "object"
+            ? error
+            : {};
         if (record.queued === true) {
             return {
                 control_path: record.control_path,
                 control_type: record.control_type,
-                delivery_error: record.delivery_error ?? (error instanceof Error ? error.message : String(error)),
+                delivery_error: record.delivery_error ??
+                    (error instanceof Error ? error.message : String(error)),
                 inbox_id: record.inbox_id,
                 queued: true,
                 run: runId,
@@ -805,7 +831,10 @@ export function createInspectToolDefinition(deps = {}) {
             const target = String(input.target ?? "");
             const view = String(input.view ?? "");
             if (target === "recipes" || target === "recipe-registry") {
-                if (view !== "status" && view !== "summary" && view !== "doctor" && view !== "imports") {
+                if (view !== "status" &&
+                    view !== "summary" &&
+                    view !== "doctor" &&
+                    view !== "imports") {
                     throw new Error("inspect recipes supports view=status, view=summary, view=doctor, or view=imports.");
                 }
                 const discovered = RecipeDiscovery.discoverRecipeSources([
@@ -1257,6 +1286,27 @@ export function createActorMessageToolDefinition(deps = {}) {
         },
     };
 }
+export function createCoreActorToolDefinitions(deps) {
+    return [
+        createRegisterToolDefinition({
+            configPath: deps.configPath,
+            getActiveTools: deps.getActiveTools,
+            getExternalToolConflict: deps.registryRuntime.getExternalToolConflict,
+            getTools: deps.registryRuntime.getTools,
+            notify: deps.registryRuntime.notify,
+            registerRuntimeTool: deps.registryRuntime.registerRuntimeTool,
+            reservedToolNames: RESERVED_TOOL_NAMES,
+            setActiveTools: deps.setActiveTools,
+        }),
+        createSpawnToolDefinition(),
+        createActorMessageToolDefinition({
+            getTool: (name) => deps.getRuntimeTool(name),
+        }),
+        createInspectToolDefinition({
+            getTool: (name) => deps.getRuntimeTool(name),
+        }),
+    ];
+}
 export function createRuntimeToolDefinition(cfg, exec) {
     const paramSchema = {};
     const required = [];