@llblab/pi-actors 0.32.0 → 0.34.0

package/lib/runtime.ts

@@ -9,8 +9,8 @@ import { existsSync, watch, type FSWatcher } from "node:fs";
 import * as Config from "./config.ts";
 import type { RegisteredToolExec } from "./execution.ts";
 import * as Paths from "./paths.ts";
-import * as RecipeDiscovery from "./recipe-discovery.ts";
-import * as Tools from "./tools.ts";
+import * as RecipesDiscovery from "./recipes-discovery.ts";
+import * as ToolsLocal from "./tools-local.ts";
 
 export interface RuntimeContext {
   hasUI: boolean;
@@ -31,7 +31,7 @@ export interface ToolRegistryRuntimeDeps {
   getActiveTools?: () => string[];
   getAllTools: () => ToolInfoLike[];
   registerTool: (
-    definition: ReturnType<typeof Tools.createRuntimeToolDefinition>,
+    definition: ReturnType<typeof ToolsLocal.createRuntimeToolDefinition>,
   ) => void;
   reservedToolNames: Set<string>;
   setActiveTools?: (toolNames: string[]) => void;
@@ -100,7 +100,7 @@ export function createAutoToolsRuntime(
   function registerRuntimeTool(cfg: Config.RegisteredTool) {
     const fingerprint = getToolFingerprint(cfg);
     if (runtimeToolFingerprints.get(cfg.name) === fingerprint) return;
-    deps.registerTool(Tools.createRuntimeToolDefinition(cfg, deps.exec));
+    deps.registerTool(ToolsLocal.createRuntimeToolDefinition(cfg, deps.exec));
     runtimeTools.add(cfg.name);
     runtimeToolFingerprints.set(cfg.name, fingerprint);
   }
@@ -148,7 +148,7 @@ export function createAutoToolsRuntime(
     const recipeRoot = deps.recipeRoot ?? Paths.getRecipeRoot();
     const packagedRecipeRoot =
       deps.packagedRecipeRoot ?? Paths.getPackagedRecipeRoot();
-    const discovered = RecipeDiscovery.discoverRecipeSources([
+    const discovered = RecipesDiscovery.discoverRecipeSources([
       { root: recipeRoot, defaultTool: true, mutableUsage: true },
       { root: packagedRecipeRoot },
     ]);
@@ -156,7 +156,7 @@ export function createAutoToolsRuntime(
     tools.clear();
     for (const entry of discovered.active.values()) {
       try {
-        const cfg = RecipeDiscovery.toRegisteredTool(entry);
+        const cfg = RecipesDiscovery.toRegisteredTool(entry);
         if (cfg) tools.set(cfg.name, cfg);
       } catch (error) {
         warnings.push(

package/lib/schema.ts

@@ -30,6 +30,61 @@ export interface ToolArgSpec {
   error?: string;
 }
 
+export type JsonSchema = Record<string, unknown>;
+
+export function stringSchema(description: string): JsonSchema {
+  return { description, type: "string" };
+}
+
+export function typedArgSchema(
+  description: string,
+  type: ToolArgType | undefined,
+): JsonSchema {
+  if (!type) return stringSchema(description);
+  switch (type.kind) {
+    case "int":
+      return { description, type: "integer" };
+    case "number":
+      return { description, type: "number" };
+    case "bool":
+      return { description, type: "boolean" };
+    case "array":
+      return { description, items: {}, type: "array" };
+    case "enum":
+      return { description, enum: type.values, type: "string" };
+    case "path":
+    case "string":
+      return stringSchema(description);
+  }
+}
+
+export function booleanSchema(description: string): JsonSchema {
+  return { description, type: "boolean" };
+}
+
+export function nullSchema(description: string): JsonSchema {
+  return { description, type: "null" };
+}
+
+export function arraySchema(description: string): JsonSchema {
+  return { description, items: {}, type: "array" };
+}
+
+export function unionSchema(anyOf: JsonSchema[]): JsonSchema {
+  return { anyOf };
+}
+
+export function objectSchema(
+  properties: Record<string, JsonSchema>,
+  required: string[] = [],
+): JsonSchema {
+  return { additionalProperties: false, properties, required, type: "object" };
+}
+
+export function looseObjectSchema(description: string): JsonSchema {
+  return { additionalProperties: true, description, type: "object" };
+}
+
 function mergeUnique(items: string[]): string[] {
   return [...new Set(items.filter(Boolean))];
 }

package/lib/tools-access.ts

@@ -0,0 +1,68 @@
+/**
+ * Public tool access and ownership checks
+ * Zones: session ownership, run visibility guards, tool authorization errors
+ * Owns consistent session-mismatch diagnostics for public tool execution paths
+ */
+
+import * as AsyncRuns from "./async-runs.ts";
+
+export interface SessionContext {
+  sessionManager?: { getSessionId?: () => string };
+}
+
+export function getContextSessionId(ctx: unknown): string | undefined {
+  return (ctx as SessionContext | undefined)?.sessionManager?.getSessionId?.();
+}
+
+export function requireContextSessionId(ctx: unknown, actor: string): string {
+  const sessionId = getContextSessionId(ctx);
+  if (!sessionId) {
+    throw new Error(
+      `${actor} requires a current coordinator session; use session:<id> or session:all for explicit session inventory.`,
+    );
+  }
+  return sessionId;
+}
+
+export function sessionMismatchError(input: {
+  currentSession?: string;
+  expectedSession?: string;
+  run?: string;
+  target?: string;
+}): Error {
+  const ownerSession = input.expectedSession ?? "none";
+  const currentSession = input.currentSession ?? "none";
+  const actor = input.run ? `run:${input.run}` : (input.target ?? "session");
+  const hintTarget = input.expectedSession
+    ? `session:${input.expectedSession}`
+    : "session:all";
+  return Object.assign(
+    new Error(
+      `${actor} reason=session_mismatch owner_session=${ownerSession} current_session=${currentSession} hint=inspect_session:${input.expectedSession ?? "all"}`,
+    ),
+    {
+      current_session: input.currentSession,
+      hint: `inspect target=${hintTarget} view=status`,
+      owner_session: input.expectedSession,
+      reason: "session_mismatch",
+      run: input.run,
+      target: input.target,
+    },
+  );
+}
+
+export function assertRunAccessibleToContext(
+  runId: string,
+  ctx: unknown,
+): Record<string, unknown> {
+  const status = AsyncRuns.getRunStatus(runId);
+  const sessionId = getContextSessionId(ctx);
+  if (sessionId && status.ownerId && status.ownerId !== sessionId) {
+    throw sessionMismatchError({
+      currentSession: sessionId,
+      expectedSession: String(status.ownerId),
+      run: runId,
+    });
+  }
+  return status;
+}