@odla-ai/harness 0.10.4 → 0.11.1

package/dist/code-runtime-cli.cjs

@@ -3,7 +3,7 @@
 
 // src/code-runtime-cli.ts
 var import_node_os4 = require("os");
-var import_promises13 = require("fs/promises");
+var import_promises14 = require("fs/promises");
 
 // src/code-runtime-client-validation.ts
 var import_code = require("@odla-ai/camel/code");
@@ -422,40 +422,40 @@ async function readBoundedResponse(body, maximum) {
   return result;
 }
 
-// src/code-runtime.ts
-var CODE_RUNTIME_PROTOCOL_VERSION = 3;
-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;
+// src/code-runtime-overload.ts
+var OVERLOAD_RETRY_DELAYS_MS = [2e3, 4e3, 8e3, 16e3];
+var RETRYABLE_CODES = /* @__PURE__ */ new Set(["control_plane_overloaded", "registry_overloaded", "transport_unavailable"]);
+function overloadedControlFailure(cause) {
+  if (!cause || typeof cause !== "object") return false;
+  const failure = cause;
+  return failure.status === 503 && typeof failure.code === "string" && RETRYABLE_CODES.has(failure.code);
+}
+async function withOverloadRetry(call, wait2, onRetry = () => void 0) {
+  for (let attempt = 0; ; attempt += 1) {
     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);
+      return await call();
+    } catch (cause) {
+      const delayMs = OVERLOAD_RETRY_DELAYS_MS[attempt];
+      if (delayMs === void 0 || !overloadedControlFailure(cause)) throw cause;
+      await onRetry(cause, delayMs);
+      await wait2(delayMs);
     }
-  } while (!options.signal?.aborted);
+  }
 }
+
+// src/code-runtime-reconciler.ts
+var sleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
 var CodeRuntimeReconciler = class {
-  constructor(control, engine, onDiagnostic) {
+  constructor(control, engine, onDiagnostic, options = {}) {
     this.control = control;
     this.engine = engine;
     this.onDiagnostic = onDiagnostic;
+    this.options = options;
   }
   control;
   engine;
   onDiagnostic;
+  options;
   results = /* @__PURE__ */ new Map();
   async reconcile(snapshot) {
     for (const command of snapshot.commands) {
@@ -474,7 +474,15 @@ var CodeRuntimeReconciler = class {
       await this.control.acknowledge(command.commandId, completed.result);
       if (!completed.notified) {
         try {
-          await this.engine.acknowledged?.(command, completed.result);
+          await withOverloadRetry(
+            async () => {
+              await this.engine.acknowledged?.(command, completed.result);
+            },
+            (ms) => (this.options.wait ?? sleep)(ms),
+            (cause, delayMs) => this.onDiagnostic?.(
+              `command ${command.commandId} acknowledged handling waits ${delayMs}ms for an overloaded control plane \xB7 ${cause instanceof Error ? cause.message : String(cause)}`
+            )
+          );
         } catch (error) {
           this.onDiagnostic?.(
             `command ${command.commandId} acknowledged handling failed \xB7 ${error instanceof Error ? error.message : String(error)}`
@@ -485,6 +493,32 @@ var CodeRuntimeReconciler = class {
     }
   }
 };
+
+// src/code-runtime.ts
+var CODE_RUNTIME_PROTOCOL_VERSION = 3;
+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);
+}
 function retryableControlFailure(value) {
   if (!value || typeof value !== "object") return false;
   const failure = value;
@@ -1412,8 +1446,8 @@ var CodeRuntimeCheckpointManager = class {
       trustedBaseDigest: active.trustedBaseDigest,
       planningInputDigest: active.planningInputDigest,
       conversationRefs: active.conversationRefs,
-      fallbackPolicyDigest: this.options.fallbackPolicyDigest,
-      recipes: this.options.recipes,
+      fallbackPolicyDigest: active.buildPolicyDigest ?? this.options.fallbackPolicyDigest,
+      recipes: active.recipes ?? this.options.recipes,
       recipeExecutor: this.options.recipeExecutor,
       review: (patch2, verification) => this.options.control.review(command.sessionId, { patch: patch2, verification })
     });
@@ -2354,13 +2388,19 @@ function createCodeRuntimeSessionSkillLoader(control) {
         ...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);
+          try {
+            return await execute2(command.sessionId, {
+              commandId: command.commandId,
+              toolCallId: context.toolCallId,
+              skill: manifest.name,
+              tool: tool.name,
+              input
+            }, context.signal);
+          } catch (cause) {
+            if (context.signal?.aborted) throw cause;
+            const detail = (cause instanceof Error ? cause.message : String(cause)).slice(0, 500);
+            return { content: `Tool "${tool.name}" failed: ${detail}`, isError: true };
+          }
         }
       }))
     }));
@@ -2378,23 +2418,7 @@ async function sessionSkillsFor(options, command) {
 }
 
 // src/code-runtime-inference.ts
-var OVERLOAD_RETRY_DELAYS_MS = [2e3, 4e3, 8e3, 16e3];
-var RETRYABLE_CODES = /* @__PURE__ */ new Set(["control_plane_overloaded", "registry_overloaded", "transport_unavailable"]);
-function overloadedControlFailure(cause) {
-  return cause instanceof CodeRuntimeControlError && cause.status === 503 && RETRYABLE_CODES.has(cause.code);
-}
-async function inferWithBackoff(infer, wait2, onRetry) {
-  for (let attempt = 0; ; attempt += 1) {
-    try {
-      return await infer();
-    } catch (cause) {
-      const delayMs = OVERLOAD_RETRY_DELAYS_MS[attempt];
-      if (delayMs === void 0 || !overloadedControlFailure(cause)) throw cause;
-      await onRetry(cause, delayMs);
-      await wait2(delayMs);
-    }
-  }
-}
+var inferWithBackoff = (infer, wait2, onRetry) => withOverloadRetry(infer, wait2, (cause, delayMs) => onRetry(cause, delayMs));
 async function handleCodeRuntimeInference(input) {
   const { command, request, state } = input;
   const startedAt = Date.now();
@@ -3806,6 +3830,96 @@ function observeCodeRuntimeSessionSkills(command, skills, emit) {
   }));
 }
 
+// src/code-repository-recipes.ts
+var import_promises13 = require("fs/promises");
+var import_node_path12 = require("path");
+var REPOSITORY_RECIPES_FILE = "odla.recipes.json";
+var MAX_RECIPES = 16;
+var DEFAULT_TIMEOUT_MS = 12e4;
+var MAX_TIMEOUT_MS = 15 * 6e4;
+var ID2 = /^[A-Za-z0-9._:-]{1,120}$/;
+var RECIPE_FIELDS = /* @__PURE__ */ new Set(["id", "command", "timeoutMs"]);
+var fault = (detail) => new TypeError(`${REPOSITORY_RECIPES_FILE} is malformed: ${detail}`);
+function parseRepositoryRecipes(text2, envelope) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text2);
+  } catch {
+    throw fault("not valid JSON");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw fault("the document must be an object");
+  const document = parsed;
+  if (document.version !== 1) throw fault("version must be 1");
+  const entries = document.recipes;
+  if (!Array.isArray(entries) || entries.length < 1) throw fault("recipes must be a non-empty array");
+  if (entries.length > MAX_RECIPES) throw fault(`at most ${MAX_RECIPES} recipes may be declared`);
+  const recipes = [];
+  const seen = /* @__PURE__ */ new Set();
+  entries.forEach((entry, index) => {
+    const label = `recipe ${index + 1}`;
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) throw fault(`${label} must be an object`);
+    const row = entry;
+    const unknown = Object.keys(row).filter((key) => !RECIPE_FIELDS.has(key));
+    if (unknown.length) throw fault(`${label} has unsupported field ${unknown[0]}; the host owns image and resource limits`);
+    if (typeof row.id !== "string" || !ID2.test(row.id)) throw fault(`${label} needs an id of 1 to 120 letters, digits, . _ : or -`);
+    if (seen.has(row.id)) throw fault(`${label} repeats id ${row.id}`);
+    seen.add(row.id);
+    if (!Array.isArray(row.command) || row.command.length < 1 || row.command.some((part) => typeof part !== "string" || !part)) {
+      throw fault(`${label} (${row.id}) needs command as a non-empty array of non-empty strings`);
+    }
+    const timeoutMs = row.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > MAX_TIMEOUT_MS) {
+      throw fault(`${label} (${row.id}) timeoutMs must be an integer from 1 to ${MAX_TIMEOUT_MS}`);
+    }
+    const recipe2 = {
+      id: row.id,
+      command: [...row.command],
+      timeoutMs,
+      image: envelope.image,
+      maxOutputBytes: envelope.maxOutputBytes,
+      cpus: envelope.cpus,
+      memory: envelope.memory,
+      pids: envelope.pids
+    };
+    try {
+      assertCodeBuildRecipe(recipe2);
+    } catch (cause) {
+      throw fault(`${label} (${row.id}) is not a runnable recipe: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+    recipes.push(recipe2);
+  });
+  return recipes;
+}
+async function readRepositoryRecipes(baselineDir, envelope) {
+  let text2;
+  try {
+    text2 = await (0, import_promises13.readFile)((0, import_node_path12.join)(baselineDir, REPOSITORY_RECIPES_FILE), "utf8");
+  } catch (cause) {
+    if (cause.code === "ENOENT") return null;
+    throw cause;
+  }
+  return parseRepositoryRecipes(text2, envelope);
+}
+async function resolveCodeRecipes(baselineDir, release, envelope) {
+  const declared = envelope ? await readRepositoryRecipes(baselineDir, envelope) : null;
+  return declared ? { recipes: declared, source: "repository" } : { recipes: release, source: "release" };
+}
+function describeCodeRecipes(resolved) {
+  const ids = resolved.recipes.map((recipe2) => recipe2.id).join(", ");
+  return resolved.source === "repository" ? `Verification recipes: declared by the repository in ${REPOSITORY_RECIPES_FILE} \xB7 ${ids}` : `Verification recipes: release-owned (the repository declares none in ${REPOSITORY_RECIPES_FILE}) \xB7 ${ids}`;
+}
+async function sessionRecipesFor(workspace, options, resume) {
+  const resolved = await resolveCodeRecipes(workspace.baselineDir, options.recipes, options.repositoryRecipes ?? null).catch(async (cause) => {
+    await workspace.cleanup();
+    throw cause;
+  });
+  return {
+    ...resolved,
+    buildPolicyDigest: digestRuntimeValue(JSON.stringify(resolved.recipes)),
+    note: !resume && resolved.source === "repository" ? describeCodeRecipes(resolved) : null
+  };
+}
+
 // src/code-runtime-engine.ts
 var TheseusRuntimeEngine = class {
   constructor(options) {
@@ -3857,6 +3971,7 @@ var TheseusRuntimeEngine = class {
       control: this.options.control,
       ...this.options.localSource ? { localSource: this.options.localSource } : {}
     });
+    const resolvedRecipes = await sessionRecipesFor(workspace, this.options, resume);
     const abort = new AbortController(), startGate = codeRuntimeAcknowledgementGate(abort.signal);
     const conversationRefs = [];
     const active = {
@@ -3865,6 +3980,8 @@ var TheseusRuntimeEngine = class {
       conversationRefs,
       acknowledged: false,
       startGate,
+      recipes: resolvedRecipes.recipes,
+      buildPolicyDigest: resolvedRecipes.buildPolicyDigest,
       role: metadata.role,
       readOnly: metadata.readOnly,
       title: metadata.title,
@@ -3882,6 +3999,7 @@ var TheseusRuntimeEngine = class {
       done: Promise.resolve(null)
     };
     this.#active.set(command.sessionId, active);
+    if (resolvedRecipes.note) await this.#event(command, { type: "message", actor: "system", body: resolvedRecipes.note }, conversationRefs);
     if (requestedLocal) {
       await this.#event(command, {
         type: "message",
@@ -3917,7 +4035,7 @@ var TheseusRuntimeEngine = class {
     const active = await this.#takeOver(command, "pursue requires an active Code session");
     active.done = startGoalPursuit({
       spec,
-      recipes: this.options.recipes,
+      recipes: active.recipes,
       recipeExecutor: this.options.recipeExecutor ?? createContainerRecipeExecutor(this.options.engine),
       workspace: active.workspace,
       baseCommitSha: active.baseCommitSha,
@@ -3996,7 +4114,7 @@ var TheseusRuntimeEngine = class {
   async #runAttempt(command, metadata, active) {
     const lease = fakeCodeLease(command, metadata);
     const broker = this.#observed(command, active, createCodeRuntimeToolBroker({
-      recipes: this.options.recipes,
+      recipes: active.recipes,
       engine: this.options.engine,
       recipeAuthorization: this.options.recipeAuthorization
     }, lease, metadata.role));
@@ -4022,7 +4140,7 @@ var TheseusRuntimeEngine = class {
       // A review-role session is read-only and still runs the proof; a planner
       // marked read-only by its payload runs nothing.
       recipes: metadata.role === "review" || !metadata.readOnly,
-      recipeIds: this.options.recipes.map((recipe2) => recipe2.id),
+      recipeIds: active.recipes.map((recipe2) => recipe2.id),
       ...extraSkills.length ? { extraSkills } : {}
     });
     const closing = result.finalText.trim();
@@ -4131,7 +4249,7 @@ function parse(argv) {
   };
 }
 async function readPolicy(path) {
-  const value = JSON.parse(await (0, import_promises13.readFile)(path, "utf8"));
+  const value = JSON.parse(await (0, import_promises14.readFile)(path, "utf8"));
   if (!value || Object.keys(value).some((key) => !["recipes", "recipeAuthorization"].includes(key)) || !Array.isArray(value.recipes) || !value.recipes.length || value.recipeAuthorization !== void 0 && value.recipeAuthorization !== "registered_recipe" && value.recipeAuthorization !== "exact_approval") throw new TypeError("invalid Code build policy file");
   const recipes = value.recipes;
   for (const recipe2 of recipes) assertCodeBuildRecipe(recipe2);