@tangle-network/agent-runtime 0.79.4 → 0.80.1

package/README.md

@@ -8,6 +8,12 @@ One loop, used three ways. Domain behavior (models, tools, knowledge) plugs in a
 pnpm add @tangle-network/agent-runtime @tangle-network/agent-eval @tangle-network/sandbox
 ```
 
+**See it run in 30 seconds** (offline, no keys) — the one move everything else builds on, a driver reading a worker's output and composing the next step from it:
+
+```bash
+pnpm tsx examples/driver-loop/driver-loop.ts
+```
+
 ## What you do with it
 
 | You want to… | Call |

package/dist/agent.js

@@ -1,8 +1,8 @@
-import "./chunk-AHZ3YBL6.js";
+import "./chunk-3RAXZ6LB.js";
 import {
   createSandboxForSpec
-} from "./chunk-44CX5JU6.js";
-import "./chunk-IPEQ3ERC.js";
+} from "./chunk-3TAQW75Y.js";
+import "./chunk-XRKP3XW3.js";
 import "./chunk-H7IBHAFT.js";
 import {
   mapSandboxEvent

package/dist/{chunk-AHZ3YBL6.js → chunk-3RAXZ6LB.js}

@@ -14,7 +14,7 @@ import {
   settledToIteration,
   supervise,
   withDriverExecutor
-} from "./chunk-44CX5JU6.js";
+} from "./chunk-3TAQW75Y.js";
 import {
   addTokenUsage,
   isAbortError,
@@ -555,6 +555,195 @@ ${rows}
 </body></html>`;
 }
 
+// src/runtime/cli-bridge-sandbox-client.ts
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+
+// src/runtime/inline-sandbox-client.ts
+function isAsyncIterable(v) {
+  return typeof v === "object" && v !== null && Symbol.asyncIterator in v;
+}
+async function settle(exec, task, signal) {
+  const r = exec.execute(task, signal);
+  if (isAsyncIterable(r)) {
+    for await (const _ of r) {
+    }
+    return exec.resultArtifact();
+  }
+  return r;
+}
+function inlineSandboxClient(factory) {
+  let seq = 0;
+  return {
+    async create(options) {
+      const id = `inline-${seq++}`;
+      const createOptions = options;
+      return {
+        id,
+        async *streamPrompt(message) {
+          const controller = new AbortController();
+          const spec = { profile: { name: id }, harness: null };
+          const exec = factory(spec, { signal: controller.signal, seams: { createOptions } });
+          try {
+            const artifact = await settle(exec, message, controller.signal);
+            const out = artifact.out;
+            const tokensIn = artifact.spent.tokens.input;
+            const tokensOut = artifact.spent.tokens.output;
+            const costUsd = artifact.spent.usd;
+            if (tokensIn || tokensOut || costUsd) {
+              yield {
+                type: "llm_call",
+                data: { tokensIn, tokensOut, costUsd }
+              };
+            }
+            yield {
+              type: "result",
+              data: {
+                finalText: out?.content ?? "",
+                tokenUsage: {
+                  inputTokens: tokensIn,
+                  outputTokens: tokensOut
+                },
+                costUsd
+              }
+            };
+          } finally {
+            await exec.teardown("brutalKill").catch(() => {
+            });
+          }
+        },
+        async delete() {
+        }
+      };
+    }
+  };
+}
+
+// src/runtime/cli-bridge-sandbox-client.ts
+var DEFAULT_BRIDGE_URL = "http://127.0.0.1:3355";
+var BRIDGE_TIMEOUT_MS = 9e5;
+function bridgeModelId(harness, model) {
+  return model.startsWith(`${harness}/`) ? model : `${harness}/${model}`;
+}
+function resolveTarget(cfg, createOptions) {
+  const backend = createOptions?.backend;
+  const harness = backend?.type ?? cfg.harness;
+  const model = backend?.model?.model ?? cfg.model;
+  if (!harness)
+    throw new Error(
+      "cliBridgeSandboxClient: no harness (set cfg.harness or create({ backend: { type } }))"
+    );
+  if (!model)
+    throw new Error(
+      "cliBridgeSandboxClient: no model (set cfg.model or create({ backend: { model: { model } } }))"
+    );
+  return { harness, model };
+}
+function bridgePost(url, bearer, bridgeModel, prompt, signal) {
+  const target = new URL(`${url.replace(/\/$/, "")}/v1/chat/completions`);
+  const body = JSON.stringify({ model: bridgeModel, messages: [{ role: "user", content: prompt }] });
+  const requestFn = target.protocol === "https:" ? httpsRequest : httpRequest;
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(new Error(`cli-bridge ${bridgeModel}: aborted before request`));
+      return;
+    }
+    const req = requestFn(
+      target,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${bearer}`,
+          "content-length": Buffer.byteLength(body)
+        },
+        // No header/body idle timeout: a slow bridge is a live bridge; the abort
+        // signal is the sole deadline.
+        timeout: 0
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          const text = Buffer.concat(chunks).toString("utf8");
+          const status = res.statusCode ?? 0;
+          if (status < 200 || status >= 300) {
+            reject(new Error(`cli-bridge ${bridgeModel}: HTTP ${status} ${text.slice(0, 300)}`));
+            return;
+          }
+          let j;
+          try {
+            j = JSON.parse(text);
+          } catch {
+            reject(new Error(`cli-bridge ${bridgeModel}: non-JSON body ${text.slice(0, 300)}`));
+            return;
+          }
+          if (j.error) {
+            reject(new Error(`cli-bridge ${bridgeModel}: ${j.error.message}`));
+            return;
+          }
+          resolve({
+            content: j.choices?.[0]?.message?.content ?? "",
+            input: j.usage?.prompt_tokens ?? 0,
+            output: j.usage?.completion_tokens ?? 0
+          });
+        });
+      }
+    );
+    const onAbort = () => {
+      req.destroy(
+        new Error(
+          `cli-bridge ${bridgeModel}: aborted (${BRIDGE_TIMEOUT_MS}ms deadline or upstream cancel)`
+        )
+      );
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    req.on("error", (e) => reject(new Error(`cli-bridge ${bridgeModel}: ${e.message}`)));
+    req.on("close", () => signal.removeEventListener("abort", onAbort));
+    req.write(body);
+    req.end();
+  });
+}
+function cliBridgeSandboxClient(cfg) {
+  if (!cfg.bearer) throw new Error("cliBridgeSandboxClient: bearer is required");
+  const url = cfg.url ?? DEFAULT_BRIDGE_URL;
+  let seq = 0;
+  const factory = (_spec, ctx) => {
+    const id = `cli-bridge-${seq++}`;
+    const createOptions = ctx.seams.createOptions;
+    const { harness, model } = resolveTarget(cfg, createOptions);
+    const bridgeModel = bridgeModelId(harness, model);
+    let artifact;
+    return {
+      runtime: "cli",
+      async execute(task, signal) {
+        const started = Date.now();
+        const timeout = AbortSignal.timeout(BRIDGE_TIMEOUT_MS);
+        const composed = AbortSignal.any([signal, timeout]);
+        const r = await bridgePost(url, cfg.bearer, bridgeModel, String(task), composed);
+        artifact = {
+          outRef: `cli-bridge:${id}`,
+          out: { content: r.content },
+          spent: {
+            iterations: 1,
+            tokens: { input: r.input, output: r.output },
+            usd: 0,
+            ms: Date.now() - started
+          }
+        };
+        return artifact;
+      },
+      teardown: () => Promise.resolve({ destroyed: true }),
+      resultArtifact() {
+        if (!artifact)
+          throw new Error("cliBridgeSandboxClient: resultArtifact() read before execute()");
+        return artifact;
+      }
+    };
+  };
+  return inlineSandboxClient(factory);
+}
+
 // src/runtime/completion.ts
 function completionAuthorizes(v, policy) {
   if (!v?.done) return false;
@@ -816,7 +1005,7 @@ import { mkdtempSync, rmSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { dirname, join } from "path";
-function isAsyncIterable(v) {
+function isAsyncIterable2(v) {
   return typeof v === "object" && v !== null && Symbol.asyncIterator in v;
 }
 function inProcessSandboxClient(options) {
@@ -867,7 +1056,7 @@ function inProcessSandboxClient(options) {
           const ctx = { round, workdir: boxWorkdir, signal };
           round += 1;
           const produced = await onPrompt(prompt, ctx);
-          if (isAsyncIterable(produced)) {
+          if (isAsyncIterable2(produced)) {
             for await (const ev of produced) yield ev;
           } else {
             for (const ev of produced) yield ev;
@@ -883,65 +1072,6 @@ function inProcessSandboxClient(options) {
   };
 }
 
-// src/runtime/inline-sandbox-client.ts
-function isAsyncIterable2(v) {
-  return typeof v === "object" && v !== null && Symbol.asyncIterator in v;
-}
-async function settle(exec, task, signal) {
-  const r = exec.execute(task, signal);
-  if (isAsyncIterable2(r)) {
-    for await (const _ of r) {
-    }
-    return exec.resultArtifact();
-  }
-  return r;
-}
-function inlineSandboxClient(factory) {
-  let seq = 0;
-  return {
-    async create(_options) {
-      const id = `inline-${seq++}`;
-      return {
-        id,
-        async *streamPrompt(message) {
-          const controller = new AbortController();
-          const spec = { profile: { name: id }, harness: null };
-          const exec = factory(spec, { signal: controller.signal, seams: {} });
-          try {
-            const artifact = await settle(exec, message, controller.signal);
-            const out = artifact.out;
-            const tokensIn = artifact.spent.tokens.input;
-            const tokensOut = artifact.spent.tokens.output;
-            const costUsd = artifact.spent.usd;
-            if (tokensIn || tokensOut || costUsd) {
-              yield {
-                type: "llm_call",
-                data: { tokensIn, tokensOut, costUsd }
-              };
-            }
-            yield {
-              type: "result",
-              data: {
-                finalText: out?.content ?? "",
-                tokenUsage: {
-                  inputTokens: tokensIn,
-                  outputTokens: tokensOut
-                },
-                costUsd
-              }
-            };
-          } finally {
-            await exec.teardown("brutalKill").catch(() => {
-            });
-          }
-        },
-        async delete() {
-        }
-      };
-    }
-  };
-}
-
 // src/runtime/report-usage.ts
 function reportLoopUsage(cost, result, source = "loop") {
   cost.observe(result.costUsd, source);
@@ -4625,6 +4755,8 @@ export {
   renderPairwiseMarkdown,
   renderLeaderboardSvg,
   renderLeaderboardHtml,
+  inlineSandboxClient,
+  cliBridgeSandboxClient,
   completionAuthorizes,
   stopSentinel,
   sentinelCompletion,
@@ -4634,7 +4766,6 @@ export {
   renderReport,
   harvestCorpus,
   inProcessSandboxClient,
-  inlineSandboxClient,
   reportLoopUsage,
   loopCampaignDispatch,
   loopDispatch,
@@ -4703,4 +4834,4 @@ export {
   computeFindingId,
   makeFinding2 as makeFinding
 };
-//# sourceMappingURL=chunk-AHZ3YBL6.js.map
+//# sourceMappingURL=chunk-3RAXZ6LB.js.map