@lucid-agents/taskmarket 1.20.2 → 1.21.0

package/dist/{launch-II23FNVJ.js → launch-QDCWAIKE.js}

@@ -7,7 +7,7 @@ import {
   recordSessionEnd,
   recordSessionStart,
   uploadPlan
-} from "./chunk-2AED73YN.js";
+} from "./chunk-UD5Z752S.js";
 import {
   TaskOperationError,
   authorizeUploads,
@@ -28,7 +28,7 @@ import {
   submitUploadedArtifacts,
   taskAccessGrantHeaders,
   taskAwardsOf
-} from "./chunk-TO6BB6N3.js";
+} from "./chunk-5N25NATR.js";
 import {
   terminalPrompter
 } from "./chunk-ZIC2YCLV.js";
@@ -68,7 +68,7 @@ import {
   sha256Hex,
   specHash,
   taskStage
-} from "./chunk-F7ENDHGG.js";
+} from "./chunk-ZZTCFKR3.js";
 import {
   BrokerConnector,
   OutputLimitError,
@@ -80,7 +80,7 @@ import {
   serveSandboxChannel,
   withFileLock,
   writeAtomic
-} from "./chunk-6LKXMM4U.js";
+} from "./chunk-ZU33L5X5.js";
 import {
   applyComputeCreditSetup,
   atomicToUsd,
@@ -90,7 +90,7 @@ import {
   planComputeCreditSetup,
   readComputeCreditBalance,
   usdToAtomic
-} from "./chunk-WUSEHQHR.js";
+} from "./chunk-TAMXCFLT.js";
 import {
   MAX_RETIRED_RAILS,
   WORKSPACE_CONSENT_VERSION,
@@ -110,7 +110,7 @@ import {
   routeOfCatalogRow,
   saveAgentPolicy,
   settledRetiredRails
-} from "./chunk-5D4HN65V.js";
+} from "./chunk-OCQKVV4A.js";
 import {
   BASE_CHANNEL_RAIL_ID,
   createBaseChannelPayer,
@@ -124,7 +124,7 @@ import {
   rpcUrlForNetwork,
   saveX402Policy,
   x402SpendWindowAvailability
-} from "./chunk-AT2VG32A.js";
+} from "./chunk-HE2N4GEO.js";
 import {
   IntentStatusResponseSchema,
   NetworkChainInfoSchema,
@@ -134,9 +134,10 @@ import {
   isRecordingPendingResponse,
   keystoreExists,
   loadKeystore,
+  piCodingAgentTools,
   selectedNetwork,
   taskmarketChain
-} from "./chunk-2JTB3UFM.js";
+} from "./chunk-3IIVNF5F.js";
 import {
   AGENT_VIEW_VERSION,
   describeFailureDetail,
@@ -2459,6 +2460,15 @@ function createMarketActions(options) {
   };
 }
 
+// src/lib/agent/shared-tools-ui.ts
+var CONTROLLER_TOOLS = /* @__PURE__ */ new Set();
+function sharedToolNames(answered = CONTROLLER_TOOLS) {
+  return piCodingAgentTools({
+    transport: { answers: (name) => answered.has(name), call: async () => ({ success: false }) },
+    sessionId: "names"
+  }).map((tool) => tool.name);
+}
+
 // src/lib/agent/deliverable.ts
 import { randomBytes } from "crypto";
 import path5 from "path";
@@ -4454,6 +4464,14 @@ function serveInferenceChannel(channel, transport, options = {}) {
           );
           return;
         }
+        case "tool": {
+          const { name, callId } = request;
+          void answer(
+            request.id,
+            (!options.views?.tools ? Promise.reject(new XgateError("unsupported_by_transport")) : typeof name !== "string" || !CODE.test(name) ? Promise.reject(new XgateError("unknown_tool")) : typeof callId !== "string" || callId.length === 0 || callId.length > 200 ? Promise.reject(new XgateError("invalid_call_id")) : options.views.tools.call(name, callId, request.args).catch(stableCode("tool_unavailable"))).then((value) => ({ value }))
+          );
+          return;
+        }
         case "market_action": {
           const actions = options.views?.marketAction;
           const { phase, tool, actionId } = request;
@@ -6557,8 +6575,13 @@ async function runSession(options, signals, keystore, workspace) {
       guardExtensionPath: piExtensionPath("lockdown"),
       // The marketplace tools the xgate extension registers: the read-only ones (market-ui.ts),
       // the claim, submit and stop requests (market-action-ui.ts) and the task workspace and
-      // validation (task-run-ui.ts).
-      marketplaceTools: [...MARKET_TOOL_NAMES, ...MARKET_ACTION_TOOL_NAMES, ...TASK_RUN_TOOL_NAMES],
+      // validation (task-run-ui.ts), and the shared tools the controller answers (shared-tools-ui.ts).
+      marketplaceTools: [
+        ...MARKET_TOOL_NAMES,
+        ...MARKET_ACTION_TOOL_NAMES,
+        ...TASK_RUN_TOOL_NAMES,
+        ...sharedToolNames()
+      ],
       // The Pi bundled with this CLI, run with the current Node.
       piCliPath: options.pi.cliPath,
       piPackageDir: options.pi.packageDir,

package/dist/pi-extensions/remote-tools.cjs

@@ -22234,7 +22234,7 @@ var SshSandboxBackend = class {
   }
   async ensure(signal) {
     if (this.conn && this.files && !this.conn.closed) {
-      this.touch();
+      await this.keepAlive();
       return { conn: this.conn, files: this.files };
     }
     if (this.failure && Date.now() < this.failure.until)
@@ -22278,6 +22278,7 @@ var SshSandboxBackend = class {
       this.files = files;
       this.info = { label: `${this.user}@${endpoint.host} (${this.root})` };
       this.failure = void 0;
+      this.lastHeartbeat = Date.now();
       this.log(`${this.dialed ? "Reconnected" : "Connected"} to the sandbox at ${endpoint.host}`);
       this.dialed = true;
       conn.onClose(() => {
@@ -22298,13 +22299,59 @@ var SshSandboxBackend = class {
       throw failure;
     }
   }
-  /** Tells the broker the sandbox is in use, at most once a minute, without waiting. */
-  touch() {
+  get heartbeatIntervalMs() {
+    return this.options.heartbeatIntervalMs ?? HEARTBEAT_INTERVAL_MS;
+  }
+  /**
+   * Tells the broker the sandbox is in use, and waits for the answer. A refusal means the broker is
+   * stopping the sandbox for inactivity, so the call fails instead of running on a machine that is
+   * going away. Skipped when the last answer is under an interval old.
+   */
+  async keepAlive(force = false) {
     const heartbeat = this.options.connector.heartbeat;
-    if (!heartbeat || Date.now() - this.lastHeartbeat < HEARTBEAT_INTERVAL_MS)
+    if (!heartbeat || !force && Date.now() - this.lastHeartbeat < this.heartbeatIntervalMs)
       return;
+    try {
+      await heartbeat.call(this.options.connector);
+    } catch (error) {
+      const message = `the sandbox could not be kept alive: ${error.message}`;
+      this.log(message);
+      throw new SandboxUnavailableError(message, { cause: error });
+    }
     this.lastHeartbeat = Date.now();
-    heartbeat.call(this.options.connector).catch((error) => this.log(`Heartbeat failed: ${error.message}`));
+  }
+  /**
+   * Runs a command while heartbeating every interval, so the idle stop never takes the sandbox
+   * under it. A refused heartbeat kills the command and fails the call with the refusal.
+   */
+  async leased(signal, run) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    if (signal?.aborted)
+      controller.abort();
+    else
+      signal?.addEventListener("abort", onAbort, { once: true });
+    let refusal;
+    let beating = false;
+    const timer = setInterval(() => {
+      if (beating)
+        return;
+      beating = true;
+      this.keepAlive(true).catch((error) => {
+        refusal = error;
+        controller.abort();
+      }).finally(() => {
+        beating = false;
+      });
+    }, this.heartbeatIntervalMs);
+    try {
+      return await run(controller.signal);
+    } catch (error) {
+      throw refusal ?? error;
+    } finally {
+      clearInterval(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
   }
   async close() {
     this.generation++;
@@ -22341,18 +22388,18 @@ var SshSandboxBackend = class {
     const unit = this.nextUnit();
     const stderr = [];
     let stderrBytes = 0;
-    const { exitCode } = await conn.stream(wrapInScope(command, this.root, unit), {
+    const { exitCode } = await this.leased(signal, (leaseSignal) => conn.stream(wrapInScope(command, this.root, unit), {
       onData: onStdout,
       onStderr: (chunk) => {
         stderrBytes += chunk.length;
         if (stderrBytes <= 16 * 1024)
           stderr.push(chunk);
       },
-      signal,
+      signal: leaseSignal,
       maxStreamBytes: this.maxStreamBytes,
       killCommand: stopScopeCommand(unit),
       untilClose: true
-    });
+    }));
     return { exitCode, stderr: Buffer.concat(stderr).toString("utf8").trim().slice(0, 2e3) };
   }
   async glob(dir, pattern, options) {
@@ -22479,13 +22526,13 @@ var SshSandboxBackend = class {
   async exec(command, cwd, options) {
     const { conn } = await this.ensure(options.signal);
     const unit = this.nextUnit();
-    return conn.stream(wrapInScope(command, cwd, unit), {
+    return this.leased(options.signal, (signal) => conn.stream(wrapInScope(command, cwd, unit), {
       onData: options.onData,
-      signal: options.signal,
+      signal,
       timeout: options.timeout,
       maxStreamBytes: this.maxStreamBytes,
       killCommand: stopScopeCommand(unit)
-    });
+    }));
   }
 };