@odla-ai/harness 0.8.1 → 0.9.1

package/README.md

@@ -126,6 +126,17 @@ on stdout. Version 1 supports task.start, typed event messages,
 inference.request/inference.response, tool.request/tool.response,
 attempt.cancel, and attempt.complete.
 
+### Registry-brokered collaboration
+
+`createCodeRuntimeSessionSkillLoader(control)` loads PM and Discussion tool
+manifests for each accepted Code command and turns them into ordinary agent
+skills. Every handler proxies the exact `commandId` and provider-issued
+`toolCallId` back through the authenticated host control plane. The Registry
+executes the effect and returns only bounded tool output, so neither Theseus nor
+its networkless container receives an app key, tenant credential, or direct
+database client. Initial work waits for the Registry's persisted `running` ACK
+before manifests are requested.
+
 ## CaMeL tool and build boundary
 
 `createCodeToolBroker` is the trusted implementation for the three Theseus tools:

package/dist/{chunk-IWVGSWY6.js → chunk-4EPJJMFG.js}

@@ -4,10 +4,10 @@ import {
   stageWorkspace,
   stageWorkspacePair,
   verifyContainerEngineBoundary
-} from "./chunk-CR6RE3A2.js";
+} from "./chunk-HDIR4MM5.js";
 import {
   HARNESS_PROTOCOL_VERSION
-} from "./chunk-RXNHCGWE.js";
+} from "./chunk-I43KTCJ2.js";
 
 // src/workspace-digest.ts
 import { createHash } from "crypto";
@@ -40,92 +40,10 @@ async function digestStagedWorkspace(root, limits) {
   return `sha256:${hash.digest("hex")}`;
 }
 
-// src/code-runtime-client.ts
+// src/code-runtime-client-validation.ts
 import { digestCodeRepositorySnapshot } from "@odla-ai/camel/code";
 
-// src/code-runtime.ts
-var CODE_RUNTIME_PROTOCOL_VERSION = 1;
-async function runCodeRuntimeHeartbeatLoop(options) {
-  const heartbeatMs = options.heartbeatMs ?? 15e3;
-  if (!Number.isSafeInteger(heartbeatMs) || heartbeatMs < 1e3 || heartbeatMs > 3e5) {
-    throw new TypeError("heartbeatMs must be an integer from 1000 to 300000");
-  }
-  let retryMs = 1e3;
-  do {
-    if (options.signal?.aborted) return;
-    try {
-      const snapshot = await options.control.heartbeat(options.runtimeVersion, options.capabilities);
-      await options.onSnapshot?.(snapshot);
-      retryMs = 1e3;
-      if (options.once) return;
-      await wait(heartbeatMs, options.signal);
-    } catch (error) {
-      if (options.signal?.aborted) return;
-      if (options.once || !retryableControlFailure(error)) throw error;
-      await options.onRetry?.(error, retryMs);
-      await wait(retryMs, options.signal);
-      retryMs = Math.min(retryMs * 2, 3e4);
-    }
-  } while (!options.signal?.aborted);
-}
-var CodeRuntimeReconciler = class {
-  constructor(control, engine) {
-    this.control = control;
-    this.engine = engine;
-  }
-  control;
-  engine;
-  results = /* @__PURE__ */ new Map();
-  async reconcile(snapshot) {
-    for (const command of snapshot.commands) {
-      let completed = this.results.get(command.commandId);
-      if (!completed) {
-        let result;
-        try {
-          result = await this.engine.execute(command);
-        } catch (error) {
-          result = { status: "failed", message: (error instanceof Error ? error.message : String(error)).slice(0, 2e3) };
-        }
-        completed = { result, notified: false };
-        this.results.set(command.commandId, completed);
-        if (this.results.size > 1024) this.results.delete(this.results.keys().next().value);
-      }
-      await this.control.acknowledge(command.commandId, completed.result);
-      if (!completed.notified) {
-        await this.engine.acknowledged?.(command, completed.result);
-        completed.notified = true;
-      }
-    }
-  }
-};
-function retryableControlFailure(value) {
-  if (!value || typeof value !== "object") return false;
-  const failure = value;
-  if (failure.code === "invalid_response" || typeof failure.status !== "number") return false;
-  return failure.status === 408 || failure.status === 425 || failure.status === 429 || failure.status >= 500;
-}
-function wait(ms, signal) {
-  return new Promise((resolve5) => {
-    if (signal?.aborted) return resolve5();
-    const timer = setTimeout(resolve5, ms);
-    signal?.addEventListener("abort", () => {
-      clearTimeout(timer);
-      resolve5();
-    }, { once: true });
-  });
-}
-
 // src/code-runtime-client.ts
-var CodeRuntimeControlError = class extends Error {
-  constructor(message2, status, code = "control_error") {
-    super(message2);
-    this.status = status;
-    this.code = code;
-  }
-  status;
-  code;
-  name = "CodeRuntimeControlError";
-};
 function createCodeRuntimeControlClient(options) {
   const endpoint = validatedEndpoint(options.endpoint);
   if (!/^odla_code_host_[0-9a-f]{64}$/.test(options.token)) throw new TypeError("invalid Code host credential");
@@ -138,9 +56,10 @@ function createCodeRuntimeControlClient(options) {
     throw new TypeError("modelRequestTimeoutMs must be an integer from 30000 to 1800000");
   }
   const request = options.fetch ?? fetch;
-  const call = async (path, body, timeoutMs = requestTimeoutMs) => {
+  const call = async (path, body, timeoutMs = requestTimeoutMs, operationSignal) => {
     const timeout = AbortSignal.timeout(timeoutMs);
-    const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+    const signals = [options.signal, operationSignal, timeout].filter((item) => Boolean(item));
+    const signal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
     let response2;
     try {
       response2 = await request(`${endpoint}${path}`, {
@@ -151,7 +70,7 @@ function createCodeRuntimeControlClient(options) {
         signal
       });
     } catch (cause) {
-      if (options.signal?.aborted) throw cause;
+      if (options.signal?.aborted || operationSignal?.aborted) throw cause;
       throw new CodeRuntimeControlError("Code runtime control plane is unavailable", 503, "transport_unavailable");
     }
     const value = await response2.json().catch(() => null);
@@ -171,8 +90,7 @@ function createCodeRuntimeControlClient(options) {
       return parseSnapshot(await call("/registry/code/runtime/heartbeat", { runtimeVersion: version, capabilities }));
     },
     acknowledge: async (commandId, result) => {
-      if (!/^ccmd_[0-9a-f]{32}$/.test(commandId)) throw new TypeError("invalid Code runtime command id");
-      await call(`/registry/code/runtime/commands/${commandId}/ack`, result);
+      await call(`/registry/code/runtime/commands/${validCommandId(commandId)}/ack`, result);
     },
     source: async (sessionId) => parseSource(
       await call(`/registry/code/runtime/sessions/${validSessionId(sessionId)}/source`, {})
@@ -215,12 +133,124 @@ function createCodeRuntimeControlClient(options) {
     rememberMemory: async (sessionId, memory) => {
       await call(`/registry/code/runtime/sessions/${validSessionId(sessionId)}/remember`, memory);
     },
+    collaborationSkills: async (sessionId, commandId) => {
+      try {
+        return parseCollaborationSkills(await call(
+          `/registry/code/runtime/sessions/${validSessionId(sessionId)}/collaboration/skills`,
+          { commandId: validCommandId(commandId) }
+        ));
+      } catch (cause) {
+        if (cause instanceof CodeRuntimeControlError && cause.status === 404 && cause.code === "not_found") return [];
+        throw cause;
+      }
+    },
+    executeCollaborationTool: async (sessionId, collaboration, signal) => {
+      validateCollaborationToolRequest(collaboration);
+      return parseCollaborationToolOutput(await call(
+        `/registry/code/runtime/sessions/${validSessionId(sessionId)}/collaboration/tools`,
+        collaboration,
+        requestTimeoutMs,
+        signal
+      ));
+    },
     reportSessionFailure: async (sessionId, message2) => {
       if (!message2.trim() || message2.length > 2e3) throw new TypeError("invalid Code session failure");
       await call(`/registry/code/runtime/sessions/${validSessionId(sessionId)}/failure`, { message: message2 });
     }
   };
 }
+
+// src/code-runtime.ts
+var CODE_RUNTIME_PROTOCOL_VERSION = 1;
+async function runCodeRuntimeHeartbeatLoop(options) {
+  const heartbeatMs = options.heartbeatMs ?? 15e3;
+  if (!Number.isSafeInteger(heartbeatMs) || heartbeatMs < 1e3 || heartbeatMs > 3e5) {
+    throw new TypeError("heartbeatMs must be an integer from 1000 to 300000");
+  }
+  let retryMs = 1e3;
+  do {
+    if (options.signal?.aborted) return;
+    try {
+      const snapshot = await options.control.heartbeat(options.runtimeVersion, options.capabilities);
+      await options.onSnapshot?.(snapshot);
+      retryMs = 1e3;
+      if (options.once) return;
+      await wait(heartbeatMs, options.signal);
+    } catch (error) {
+      if (options.signal?.aborted) return;
+      if (options.once || !retryableControlFailure(error)) throw error;
+      await options.onRetry?.(error, retryMs);
+      await wait(retryMs, options.signal);
+      retryMs = Math.min(retryMs * 2, 3e4);
+    }
+  } while (!options.signal?.aborted);
+}
+var CodeRuntimeReconciler = class {
+  constructor(control, engine, onDiagnostic) {
+    this.control = control;
+    this.engine = engine;
+    this.onDiagnostic = onDiagnostic;
+  }
+  control;
+  engine;
+  onDiagnostic;
+  results = /* @__PURE__ */ new Map();
+  async reconcile(snapshot) {
+    for (const command of snapshot.commands) {
+      let completed = this.results.get(command.commandId);
+      if (!completed) {
+        let result;
+        try {
+          result = await this.engine.execute(command);
+        } catch (error) {
+          result = { status: "failed", message: (error instanceof Error ? error.message : String(error)).slice(0, 2e3) };
+        }
+        completed = { result, notified: false };
+        this.results.set(command.commandId, completed);
+        if (this.results.size > 1024) this.results.delete(this.results.keys().next().value);
+      }
+      await this.control.acknowledge(command.commandId, completed.result);
+      if (!completed.notified) {
+        try {
+          await this.engine.acknowledged?.(command, completed.result);
+        } catch (error) {
+          this.onDiagnostic?.(
+            `command ${command.commandId} acknowledged handling failed \xB7 ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        completed.notified = true;
+      }
+    }
+  }
+};
+function retryableControlFailure(value) {
+  if (!value || typeof value !== "object") return false;
+  const failure = value;
+  if (failure.code === "invalid_response" || typeof failure.status !== "number") return false;
+  return failure.status === 408 || failure.status === 425 || failure.status === 429 || failure.status >= 500;
+}
+function wait(ms, signal) {
+  return new Promise((resolve5) => {
+    if (signal?.aborted) return resolve5();
+    const timer = setTimeout(resolve5, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      resolve5();
+    }, { once: true });
+  });
+}
+
+// src/code-runtime-client-validation.ts
+var CodeRuntimeControlError = class extends Error {
+  constructor(message2, status, code = "control_error") {
+    super(message2);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+  name = "CodeRuntimeControlError";
+};
 function validatedEndpoint(value) {
   const endpoint = value.replace(/\/+$/, "");
   let url;
@@ -239,6 +269,10 @@ function validSessionId(value) {
   if (!/^csess_[0-9a-f]{32}$/.test(value)) throw new TypeError("invalid Code session id");
   return value;
 }
+function validCommandId(value) {
+  if (!/^ccmd_[0-9a-f]{32}$/.test(value)) throw new TypeError("invalid Code runtime command id");
+  return value;
+}
 function validateHeartbeat(version, capabilities) {
   if (!version.trim() || version.length > 80) throw new TypeError("runtimeVersion is required and at most 80 characters");
   if (capabilities.protocolVersion !== CODE_RUNTIME_PROTOCOL_VERSION) throw new TypeError("unsupported Code runtime protocol version");
@@ -320,6 +354,91 @@ function parseCandidate(value) {
   }
   return { candidateId: candidate.candidateId, status: candidate.status };
 }
+function parseCollaborationSkills(value) {
+  const items = record(value)?.skills;
+  if (!Array.isArray(items) || items.length > 16) throw invalid("collaboration skills");
+  const skillNames = /* @__PURE__ */ new Set();
+  const toolNames = /* @__PURE__ */ new Set();
+  return items.map((item) => {
+    const skill = record(item);
+    if (!skill || !validManifestName(skill.name) || skillNames.has(skill.name) || skill.instructions !== void 0 && (typeof skill.instructions !== "string" || utf8Bytes(skill.instructions) > 32e3) || !Array.isArray(skill.tools) || !skill.tools.length || skill.tools.length > 128) {
+      throw invalid("collaboration skill");
+    }
+    skillNames.add(skill.name);
+    const tools = skill.tools.map((candidate) => {
+      const tool = record(candidate);
+      const inputSchema = record(tool?.inputSchema);
+      if (!tool || !validManifestName(tool.name) || toolNames.has(tool.name) || typeof tool.description !== "string" || utf8Bytes(tool.description) > 8e3 || !inputSchema || jsonBytes(inputSchema) > 64e3 || tool.concurrency !== void 0 && tool.concurrency !== "parallel") {
+        throw invalid("collaboration tool");
+      }
+      const outputTaint = parseTaintLabels(tool.outputTaint);
+      const acceptsTaint = parseTaintLabels(tool.acceptsTaint);
+      toolNames.add(tool.name);
+      return {
+        name: tool.name,
+        description: tool.description,
+        inputSchema,
+        ...tool.concurrency === "parallel" ? { concurrency: "parallel" } : {},
+        ...outputTaint ? { outputTaint } : {},
+        ...acceptsTaint ? { acceptsTaint } : {}
+      };
+    });
+    return {
+      name: skill.name,
+      ...typeof skill.instructions === "string" ? { instructions: skill.instructions } : {},
+      tools
+    };
+  });
+}
+function validateCollaborationToolRequest(value) {
+  validCommandId(value.commandId);
+  if (typeof value.toolCallId !== "string" || value.toolCallId.length > 256 || !/^[^\s\u0000-\u001f\u007f]+$/.test(value.toolCallId) || !validManifestName(value.skill) || !validManifestName(value.tool) || !record(value.input) || jsonBytes(value.input) > 128e3) {
+    throw new TypeError("invalid Code collaboration tool request");
+  }
+}
+function parseCollaborationToolOutput(value) {
+  const output = record(record(value)?.output);
+  if (!output || output.isError !== void 0 && typeof output.isError !== "boolean") {
+    throw invalid("collaboration tool");
+  }
+  if (typeof output.content === "string") {
+    if (utf8Bytes(output.content) > 1e6) throw invalid("collaboration tool");
+    return { content: output.content, ...output.isError === true ? { isError: true } : {} };
+  }
+  if (!Array.isArray(output.content) || output.content.length > 64 || jsonBytes(output.content) > 1e6 || !output.content.every((block) => {
+    const item = record(block);
+    return item && ["text", "image", "audio", "document", "tool_use", "tool_result", "thinking"].includes(String(item.type));
+  })) throw invalid("collaboration tool");
+  return {
+    content: output.content,
+    ...output.isError === true ? { isError: true } : {}
+  };
+}
+function parseTaintLabels(value) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.length > 16) throw invalid("collaboration tool taint");
+  const labels = value.map((item) => {
+    if (item === "web_untrusted" || item === "operator_pasted_untrusted" || item === "llm_inherited") return item;
+    if (typeof item === "string" && /^tool_untrusted:[^\s\u0000-\u001f\u007f]{1,100}$/.test(item)) {
+      return item;
+    }
+    throw invalid("collaboration tool taint");
+  });
+  return [...new Set(labels)];
+}
+function validManifestName(value) {
+  return typeof value === "string" && /^[A-Za-z][A-Za-z0-9._:-]{0,127}$/.test(value);
+}
+function utf8Bytes(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function jsonBytes(value) {
+  try {
+    return utf8Bytes(JSON.stringify(value));
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
 var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
 var invalid = (part) => new CodeRuntimeControlError(`invalid Code runtime ${part} response`, 502, "invalid_response");
 
@@ -1390,6 +1509,48 @@ Finish with a concise, non-empty answer to the owner. Do not call tools or promi
   }
 }
 
+// src/code-runtime-session-skills.ts
+function createCodeRuntimeSessionSkillLoader(control) {
+  const load = control.collaborationSkills?.bind(control);
+  const execute2 = control.executeCollaborationTool?.bind(control);
+  if (!load || !execute2) return async () => [];
+  return async (command) => {
+    const manifests = await load(command.sessionId, command.commandId);
+    return manifests.map((manifest) => ({
+      name: manifest.name,
+      ...manifest.instructions === void 0 ? {} : { instructions: manifest.instructions },
+      tools: manifest.tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        ...tool.concurrency === void 0 ? {} : { concurrency: tool.concurrency },
+        ...tool.outputTaint === void 0 ? {} : { outputTaint: tool.outputTaint },
+        ...tool.acceptsTaint === void 0 ? {} : { acceptsTaint: tool.acceptsTaint },
+        handler: async (input, context) => {
+          if (!context.toolCallId) throw new TypeError("collaboration tool call identity is required");
+          return execute2(command.sessionId, {
+            commandId: command.commandId,
+            toolCallId: context.toolCallId,
+            skill: manifest.name,
+            tool: tool.name,
+            input
+          }, context.signal);
+        }
+      }))
+    }));
+  };
+}
+async function sessionSkillsFor(options, command) {
+  try {
+    return await options.sessionSkills?.(command) ?? [];
+  } catch (cause) {
+    options.onDiagnostic?.(
+      `session skills unavailable, continuing with code tools only: ${cause instanceof Error ? cause.message : String(cause)}`
+    );
+    return [];
+  }
+}
+
 // src/code-runtime-inference.ts
 async function handleCodeRuntimeInference(input) {
   const { command, request, state } = input;
@@ -2324,18 +2485,6 @@ function assertBudget(budget) {
   }
 }
 
-// src/code-runtime-session-skills.ts
-async function sessionSkillsFor(options, command) {
-  try {
-    return await options.sessionSkills?.(command) ?? [];
-  } catch (cause) {
-    options.onDiagnostic?.(
-      `session skills unavailable, continuing with code tools only: ${cause instanceof Error ? cause.message : String(cause)}`
-    );
-    return [];
-  }
-}
-
 // src/code-runtime-broker.ts
 function createCodeRuntimeToolBroker(input, lease, role) {
   const broker = createCodeToolBroker({
@@ -2635,6 +2784,76 @@ function codeToolResultPresentation(request, response2) {
   };
 }
 
+// src/code-runtime-acknowledgement-gate.ts
+function codeRuntimeAcknowledgementGate(signal) {
+  let settle;
+  let settled = false;
+  const ready = new Promise((resolve5) => {
+    settle = resolve5;
+  });
+  const release = (run) => {
+    if (settled) return;
+    settled = true;
+    signal.removeEventListener("abort", onAbort);
+    settle(run);
+  };
+  const onAbort = () => release(false);
+  if (signal.aborted) release(false);
+  else signal.addEventListener("abort", onAbort, { once: true });
+  return { ready, release };
+}
+
+// src/code-runtime-session-activity.ts
+function observeCodeRuntimeSessionSkills(command, skills, emit) {
+  return skills.map((skill) => ({
+    ...skill,
+    tools: skill.tools.map((tool) => {
+      if (!tool.handler) return tool;
+      const handler = tool.handler;
+      return {
+        ...tool,
+        handler: async (input, context) => {
+          const startedAt = Date.now();
+          const operationId = digestRuntimeValue(
+            `${command.commandId}:${skill.name}:${tool.name}:${context.toolCallId ?? "missing"}`
+          );
+          await emit({
+            type: "collaboration",
+            phase: "started",
+            skill: skill.name,
+            tool: tool.name,
+            operationId
+          }).catch(() => void 0);
+          try {
+            const output = await handler(input, context);
+            await emit({
+              type: "collaboration",
+              phase: "completed",
+              skill: skill.name,
+              tool: tool.name,
+              operationId,
+              ok: output.isError !== true,
+              durationMs: Date.now() - startedAt
+            }).catch(() => void 0);
+            return output;
+          } catch (cause) {
+            await emit({
+              type: "collaboration",
+              phase: "completed",
+              skill: skill.name,
+              tool: tool.name,
+              operationId,
+              ok: false,
+              durationMs: Date.now() - startedAt
+            }).catch(() => void 0);
+            throw cause;
+          }
+        }
+      };
+    })
+  }));
+}
+
 // src/code-runtime-engine.ts
 var TheseusRuntimeEngine = class {
   constructor(options) {
@@ -2665,6 +2884,8 @@ var TheseusRuntimeEngine = class {
     const active = this.#active.get(command.sessionId);
     if (!active || result.status !== "running") return;
     active.acknowledged = true;
+    active.startGate?.release(true);
+    active.startGate = void 0;
     if (active.failure) await this.options.control.reportSessionFailure(command.sessionId, active.failure).catch(() => void 0);
   }
   async close() {
@@ -2684,13 +2905,14 @@ var TheseusRuntimeEngine = class {
       control: this.options.control,
       ...this.options.localSource ? { localSource: this.options.localSource } : {}
     });
-    const abort = new AbortController();
+    const abort = new AbortController(), startGate = codeRuntimeAcknowledgementGate(abort.signal);
     const conversationRefs = [];
     const active = {
       workspace,
       abort,
       conversationRefs,
       acknowledged: false,
+      startGate,
       role: metadata.role,
       title: metadata.title,
       maxTokensPerInteraction: metadata.maxTokensPerInteraction,
@@ -2714,7 +2936,7 @@ var TheseusRuntimeEngine = class {
         body: `Source snapshot: local checkout ${requestedLocal.snapshotDigest} \xB7 ${requestedLocal.modified ? "modified" : "clean"} \xB7 Git ${requestedLocal.headCommitSha}`
       }, conversationRefs);
     }
-    active.done = this.#runAttempt(command, metadata, active).catch(async (cause) => {
+    active.done = startGate.ready.then((run) => run ? this.#runAttempt(command, metadata, active) : null).catch(async (cause) => {
       const detail = runtimeErrorMessage(cause);
       await this.#event(command, { type: "message", actor: "system", body: detail }, conversationRefs).catch(() => void 0);
       await this.#diagnostic(command, active, detail);
@@ -2829,7 +3051,7 @@ var TheseusRuntimeEngine = class {
       event: (event) => this.#event(command, event, active.conversationRefs)
     });
     await this.#event(command, { type: "status", status: "running" }, active.conversationRefs);
-    const extraSkills = await sessionSkillsFor(this.options, command);
+    const extraSkills = observeCodeRuntimeSessionSkills(command, await sessionSkillsFor(this.options, command), (event) => this.#event(command, event, active.conversationRefs));
     const result = await this.#attempt({
       inference,
       broker,
@@ -2958,6 +3180,8 @@ export {
   codeSkill,
   runCodeAgent,
   runCodeAgentAttempt,
+  createCodeRuntimeSessionSkillLoader,
+  sessionSkillsFor,
   createCodeRuntimeInference,
   registeredFiles,
   createCodeToolBroker,
@@ -2969,4 +3193,4 @@ export {
   runGoal,
   TheseusRuntimeEngine
 };
-//# sourceMappingURL=chunk-IWVGSWY6.js.map
+//# sourceMappingURL=chunk-4EPJJMFG.js.map