@agentfield/sdk 0.1.101 → 0.1.102-rc.1

package/dist/index.js

@@ -6,6 +6,9 @@ import { spawn } from 'child_process';
 import express from 'express';
 import rateLimit from 'express-rate-limit';
 import crypto2, { randomUUID, createHash } from 'crypto';
+import axios5, { isAxiosError } from 'axios';
+import http from 'http';
+import https from 'https';
 import { AsyncLocalStorage } from 'async_hooks';
 import { tool, jsonSchema, generateText, stepCountIs, streamText, embed, embedMany, generateObject } from 'ai';
 import { createOpenAI } from '@ai-sdk/openai';
@@ -17,9 +20,6 @@ import { createXai } from '@ai-sdk/xai';
 import { createDeepSeek } from '@ai-sdk/deepseek';
 import { createCohere } from '@ai-sdk/cohere';
 import os from 'os';
-import axios4, { isAxiosError } from 'axios';
-import http from 'http';
-import https from 'https';
 import WebSocket from 'ws';
 import { Buffer as Buffer$1 } from 'buffer';
 import { zodToJsonSchema } from 'zod-to-json-schema';
@@ -1065,8 +1065,8 @@ var CancelRegistry = class {
    * so callers always get a usable signal even outside the control-plane
    * dispatch path (e.g. local manual invocations).
    */
-  register(executionId) {
-    const controller = new AbortController();
+  register(executionId, existing) {
+    const controller = existing ?? new AbortController();
     if (!executionId) {
       return { controller, release: () => {
       } };
@@ -1133,6 +1133,298 @@ function installCancelRoute(app, registry, logger) {
     }
   );
 }
+
+// src/agent/pause.ts
+var ApprovalResult = class {
+  decision;
+  feedback;
+  executionId;
+  approvalRequestId;
+  rawResponse;
+  constructor(params) {
+    this.decision = params.decision;
+    this.feedback = params.feedback ?? "";
+    this.executionId = params.executionId ?? "";
+    this.approvalRequestId = params.approvalRequestId ?? "";
+    this.rawResponse = params.rawResponse;
+  }
+  /** True when the human approved the request. */
+  get approved() {
+    return this.decision === "approved";
+  }
+  /** True when the human asked for changes rather than approving/rejecting. */
+  get changesRequested() {
+    return this.decision === "request_changes";
+  }
+};
+var PauseClock = class {
+  totalPausedMs = 0;
+  pauseStartedAt = null;
+  /**
+   * Set by the watchdog when it aborts the reasoner for exceeding the active
+   * budget. Distinguishes a budget-timeout abort from an external cooperative
+   * cancel arriving via the cancel dispatcher.
+   */
+  timedOut = false;
+  startPause() {
+    if (this.pauseStartedAt === null) {
+      this.pauseStartedAt = Date.now();
+    }
+  }
+  endPause() {
+    if (this.pauseStartedAt !== null) {
+      this.totalPausedMs += Date.now() - this.pauseStartedAt;
+      this.pauseStartedAt = null;
+    }
+  }
+  /** Cumulative paused milliseconds, including any in-progress pause. */
+  totalPaused() {
+    if (this.pauseStartedAt === null) {
+      return this.totalPausedMs;
+    }
+    return this.totalPausedMs + (Date.now() - this.pauseStartedAt);
+  }
+};
+var PauseManager = class {
+  pending = /* @__PURE__ */ new Map();
+  /** execution_id -> approval_request_id, for fallback resolution. */
+  execToRequest = /* @__PURE__ */ new Map();
+  /**
+   * Register a new pending pause and return the promise to await. Idempotent:
+   * a second register() for the same `approvalRequestId` returns the existing
+   * promise rather than replacing it.
+   */
+  register(approvalRequestId, executionId = "") {
+    const existing = this.pending.get(approvalRequestId);
+    if (existing) {
+      return existing.promise;
+    }
+    let resolveFn;
+    const promise = new Promise((resolve2) => {
+      resolveFn = resolve2;
+    });
+    this.pending.set(approvalRequestId, { resolve: resolveFn, promise });
+    if (executionId) {
+      this.execToRequest.set(executionId, approvalRequestId);
+    }
+    return promise;
+  }
+  /**
+   * Resolve a pending pause by `approvalRequestId`. Returns true if a waiter
+   * was found and resolved, false otherwise.
+   */
+  resolve(approvalRequestId, result) {
+    const entry = this.pending.get(approvalRequestId);
+    if (!entry) {
+      return false;
+    }
+    this.pending.delete(approvalRequestId);
+    for (const [eid, rid] of this.execToRequest) {
+      if (rid === approvalRequestId) {
+        this.execToRequest.delete(eid);
+        break;
+      }
+    }
+    entry.resolve(result);
+    return true;
+  }
+  /**
+   * Fallback: resolve by `executionId` when the callback omits the
+   * `approvalRequestId`. Returns true if a waiter was found.
+   */
+  resolveByExecutionId(executionId, result) {
+    const requestId = this.execToRequest.get(executionId);
+    if (!requestId) {
+      return false;
+    }
+    return this.resolve(requestId, result);
+  }
+  /**
+   * Resolve every pending pause with a `cancelled` result. Used on shutdown so
+   * a reasoner blocked in `ctx.pause()` doesn't hang the process forever.
+   */
+  cancelAll() {
+    for (const [approvalRequestId, entry] of this.pending) {
+      entry.resolve(
+        new ApprovalResult({
+          decision: "cancelled",
+          feedback: "agent shutting down",
+          approvalRequestId
+        })
+      );
+    }
+    this.pending.clear();
+    this.execToRequest.clear();
+  }
+  /** Number of currently-pending pauses. Useful for tests. */
+  pendingCount() {
+    return this.pending.size;
+  }
+};
+function parseRawResponse(raw) {
+  if (raw && typeof raw === "object") {
+    return raw;
+  }
+  if (typeof raw === "string" && raw.trim()) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") {
+        return parsed;
+      }
+    } catch {
+      return { text: raw };
+    }
+  }
+  return void 0;
+}
+function installApprovalWebhookRoute(app, manager, logger) {
+  app.post(
+    "/webhooks/approval",
+    (req, res) => {
+      const body = req.body ?? {};
+      const executionId = String(body.execution_id ?? "");
+      const approvalRequestId = String(body.approval_request_id ?? "");
+      const decision = String(body.decision ?? "");
+      const feedback = typeof body.feedback === "string" ? body.feedback : "";
+      const rawResponse = parseRawResponse(body.response);
+      const result = new ApprovalResult({
+        decision,
+        feedback,
+        executionId,
+        approvalRequestId,
+        rawResponse
+      });
+      let resolved = false;
+      if (approvalRequestId) {
+        resolved = manager.resolve(approvalRequestId, result);
+      }
+      if (!resolved && executionId) {
+        resolved = manager.resolveByExecutionId(executionId, result);
+      }
+      logger?.info("approval-webhook received", {
+        executionId,
+        approvalRequestId,
+        decision,
+        resolved
+      });
+      res.status(200).json({ status: "received", resolved });
+    }
+  );
+}
+var httpAgent = new http.Agent({
+  keepAlive: true,
+  maxSockets: 10,
+  maxTotalSockets: 50,
+  maxFreeSockets: 5
+});
+var httpsAgent = new https.Agent({
+  keepAlive: true,
+  maxSockets: 10,
+  maxTotalSockets: 50,
+  maxFreeSockets: 5
+});
+
+// src/approval/ApprovalClient.ts
+var ApprovalClient = class {
+  http;
+  nodeId;
+  headers;
+  constructor(opts) {
+    this.http = axios5.create({
+      baseURL: opts.baseURL.replace(/\/$/, ""),
+      timeout: 3e4,
+      httpAgent,
+      httpsAgent
+    });
+    this.nodeId = opts.nodeId;
+    const merged = { ...opts.headers ?? {} };
+    if (opts.apiKey) {
+      merged["X-API-Key"] = opts.apiKey;
+    }
+    this.headers = merged;
+  }
+  /**
+   * Request human approval, transitioning the execution to `waiting`.
+   *
+   * Calls `POST /api/v1/agents/{node}/executions/{id}/request-approval`.
+   */
+  async requestApproval(executionId, payload) {
+    const body = {
+      approval_request_id: payload.approvalRequestId,
+      expires_in_hours: payload.expiresInHours ?? 72
+    };
+    if (payload.approvalRequestUrl) {
+      body.approval_request_url = payload.approvalRequestUrl;
+    }
+    if (payload.callbackUrl) {
+      body.callback_url = payload.callbackUrl;
+    }
+    const res = await this.http.post(
+      `/api/v1/agents/${encodeURIComponent(this.nodeId)}/executions/${encodeURIComponent(executionId)}/request-approval`,
+      body,
+      { headers: { ...this.headers, "Content-Type": "application/json" } }
+    );
+    return {
+      approvalRequestId: res.data.approval_request_id ?? "",
+      approvalRequestUrl: res.data.approval_request_url ?? ""
+    };
+  }
+  /**
+   * Get the current approval status for an execution.
+   *
+   * Calls `GET /api/v1/agents/{node}/executions/{id}/approval-status`.
+   */
+  async getApprovalStatus(executionId) {
+    const res = await this.http.get(
+      `/api/v1/agents/${encodeURIComponent(this.nodeId)}/executions/${encodeURIComponent(executionId)}/approval-status`,
+      { headers: this.headers }
+    );
+    const data = res.data;
+    return {
+      status: data.status ?? "pending",
+      response: data.response,
+      requestUrl: data.request_url,
+      requestedAt: data.requested_at,
+      respondedAt: data.responded_at
+    };
+  }
+  /**
+   * Poll approval status with exponential backoff until resolved.
+   *
+   * Returns once the status is no longer `pending` (i.e. approved, rejected,
+   * or expired).
+   */
+  async waitForApproval(executionId, opts) {
+    const pollInterval = opts?.pollIntervalMs ?? 5e3;
+    const maxInterval = opts?.maxIntervalMs ?? 6e4;
+    const timeout = opts?.timeoutMs;
+    const backoffFactor = 2;
+    const startTime = Date.now();
+    let interval = pollInterval;
+    while (true) {
+      if (timeout != null && Date.now() - startTime >= timeout) {
+        throw new Error(
+          `Approval for execution ${executionId} timed out after ${timeout}ms`
+        );
+      }
+      await sleep(interval);
+      let data;
+      try {
+        data = await this.getApprovalStatus(executionId);
+      } catch {
+        interval = Math.min(interval * backoffFactor, maxInterval);
+        continue;
+      }
+      if (data.status !== "pending") {
+        return data;
+      }
+      interval = Math.min(interval * backoffFactor, maxInterval);
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
 var store = new AsyncLocalStorage();
 var ExecutionContext = class {
   input;
@@ -1543,6 +1835,19 @@ var ReasonerContext = class {
   call(target, input) {
     return this.agent.call(target, input);
   }
+  /**
+   * Pause this execution for external approval / resumption.
+   *
+   * Transitions the execution to `waiting` on the control plane and blocks
+   * until a decision arrives via the agent's approval webhook, or the timeout
+   * elapses (returning `{ decision: 'expired' }`). The caller creates the
+   * approval request on an external service first and passes its
+   * `approvalRequestId`. Delegates to {@link Agent.pause}. See its docs for the
+   * async-execution requirement that lets a pause outlive the dispatch ceiling.
+   */
+  pause(opts) {
+    return this.agent.pause({ ...opts, executionId: this.executionId });
+  }
   discover(options) {
     return this.agent.discover(options);
   }
@@ -2224,18 +2529,6 @@ var ExecutionLogger = class {
 function createExecutionLogger(options = {}) {
   return new ExecutionLogger(options);
 }
-var httpAgent = new http.Agent({
-  keepAlive: true,
-  maxSockets: 10,
-  maxTotalSockets: 50,
-  maxFreeSockets: 5
-});
-var httpsAgent = new https.Agent({
-  keepAlive: true,
-  maxSockets: 10,
-  maxTotalSockets: 50,
-  maxFreeSockets: 5
-});
 var HEADER_CALLER_DID = "X-Caller-DID";
 var HEADER_DID_SIGNATURE = "X-DID-Signature";
 var HEADER_DID_TIMESTAMP = "X-DID-Timestamp";
@@ -2318,6 +2611,67 @@ function parsePrivateKeyJWK(jwkJSON) {
   });
 }
 
+// src/status/ExecutionStatus.ts
+var ExecutionStatus = {
+  PENDING: "pending",
+  QUEUED: "queued",
+  WAITING: "waiting",
+  RUNNING: "running",
+  SUCCEEDED: "succeeded",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+  TIMEOUT: "timeout",
+  UNKNOWN: "unknown"
+};
+var CANONICAL_STATUSES = new Set(
+  Object.values(ExecutionStatus)
+);
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  ExecutionStatus.SUCCEEDED,
+  ExecutionStatus.FAILED,
+  ExecutionStatus.CANCELLED,
+  ExecutionStatus.TIMEOUT
+]);
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set([
+  ExecutionStatus.PENDING,
+  ExecutionStatus.QUEUED,
+  ExecutionStatus.WAITING,
+  ExecutionStatus.RUNNING
+]);
+var STATUS_ALIASES = {
+  success: "succeeded",
+  successful: "succeeded",
+  completed: "succeeded",
+  complete: "succeeded",
+  done: "succeeded",
+  ok: "succeeded",
+  error: "failed",
+  failure: "failed",
+  errored: "failed",
+  canceled: "cancelled",
+  cancel: "cancelled",
+  timed_out: "timeout",
+  wait: "queued",
+  awaiting_approval: "waiting",
+  awaiting_human: "waiting",
+  approval_pending: "waiting",
+  in_progress: "running",
+  processing: "running"
+};
+function normalizeStatus(status) {
+  if (status == null) return "unknown";
+  const normalized = status.trim().toLowerCase();
+  if (!normalized) return "unknown";
+  if (CANONICAL_STATUSES.has(normalized)) return normalized;
+  return STATUS_ALIASES[normalized] ?? "unknown";
+}
+function isTerminal(status) {
+  return TERMINAL_STATUSES.has(normalizeStatus(status));
+}
+function isActive(status) {
+  return ACTIVE_STATUSES.has(normalizeStatus(status));
+}
+
 // src/client/AgentFieldClient.ts
 var AgentFieldClient = class {
   http;
@@ -2326,7 +2680,7 @@ var AgentFieldClient = class {
   didAuthenticator;
   constructor(config) {
     const baseURL = (config.agentFieldUrl ?? "http://localhost:8080").replace(/\/$/, "");
-    this.http = axios4.create({
+    this.http = axios5.create({
       baseURL,
       timeout: 3e4,
       httpAgent,
@@ -2366,21 +2720,7 @@ var AgentFieldClient = class {
     return res.data;
   }
   async execute(target, input, metadata) {
-    const headers = {};
-    if (metadata?.runId) headers["X-Run-ID"] = metadata.runId;
-    if (metadata?.workflowId) headers["X-Workflow-ID"] = metadata.workflowId;
-    if (metadata?.rootWorkflowId) headers["X-Root-Workflow-ID"] = metadata.rootWorkflowId;
-    if (metadata?.parentExecutionId) headers["X-Parent-Execution-ID"] = metadata.parentExecutionId;
-    if (metadata?.reasonerId) headers["X-Reasoner-ID"] = metadata.reasonerId;
-    if (metadata?.sessionId) headers["X-Session-ID"] = metadata.sessionId;
-    if (metadata?.actorId) headers["X-Actor-ID"] = metadata.actorId;
-    if (metadata?.callerDid) headers["X-Caller-DID"] = metadata.callerDid;
-    if (metadata?.targetDid) headers["X-Target-DID"] = metadata.targetDid;
-    if (metadata?.agentNodeDid) headers["X-Agent-Node-DID"] = metadata.agentNodeDid;
-    if (metadata?.agentNodeId) headers["X-Agent-Node-ID"] = metadata.agentNodeId;
-    if (metadata?.replaySourceRunId) headers["X-AgentField-Replay-Source-Run-ID"] = metadata.replaySourceRunId;
-    if (metadata?.replayBeforeExecutionId) headers["X-AgentField-Replay-Before-Execution-ID"] = metadata.replayBeforeExecutionId;
-    if (metadata?.replayMode) headers["X-AgentField-Replay-Mode"] = metadata.replayMode;
+    const headers = this.buildExecuteHeaders(metadata);
     const bodyStr = JSON.stringify({ input });
     const authHeaders = this.didAuthenticator.signRequest(Buffer.from(bodyStr));
     try {
@@ -2502,6 +2842,219 @@ var AgentFieldClient = class {
       headers: this.mergeHeaders({ "Content-Type": "application/json", ...authHeaders })
     });
   }
+  /** Build the `X-*` dispatch headers shared by execute / executeAsync. */
+  buildExecuteHeaders(metadata) {
+    const headers = {};
+    if (metadata?.runId) headers["X-Run-ID"] = metadata.runId;
+    if (metadata?.workflowId) headers["X-Workflow-ID"] = metadata.workflowId;
+    if (metadata?.rootWorkflowId) headers["X-Root-Workflow-ID"] = metadata.rootWorkflowId;
+    if (metadata?.parentExecutionId) headers["X-Parent-Execution-ID"] = metadata.parentExecutionId;
+    if (metadata?.reasonerId) headers["X-Reasoner-ID"] = metadata.reasonerId;
+    if (metadata?.sessionId) headers["X-Session-ID"] = metadata.sessionId;
+    if (metadata?.actorId) headers["X-Actor-ID"] = metadata.actorId;
+    if (metadata?.callerDid) headers["X-Caller-DID"] = metadata.callerDid;
+    if (metadata?.targetDid) headers["X-Target-DID"] = metadata.targetDid;
+    if (metadata?.agentNodeDid) headers["X-Agent-Node-DID"] = metadata.agentNodeDid;
+    if (metadata?.agentNodeId) headers["X-Agent-Node-ID"] = metadata.agentNodeId;
+    if (metadata?.replaySourceRunId) headers["X-AgentField-Replay-Source-Run-ID"] = metadata.replaySourceRunId;
+    if (metadata?.replayBeforeExecutionId) headers["X-AgentField-Replay-Before-Execution-ID"] = metadata.replayBeforeExecutionId;
+    if (metadata?.replayMode) headers["X-AgentField-Replay-Mode"] = metadata.replayMode;
+    return headers;
+  }
+  /**
+   * Submit an async execution and return its `execution_id`.
+   *
+   * POSTs to `/api/v1/execute/async/{target}`, which enqueues the execution
+   * and responds `202 Accepted` immediately (the control plane runs it and
+   * tracks status out-of-band). Use with {@link waitForExecutionResult} to
+   * poll for the terminal result without holding a synchronous connection —
+   * this is what lets a parent await a descendant that legitimately pauses
+   * (WAITING) for a long time without hitting the dispatch ceiling.
+   */
+  async executeAsync(target, input, metadata) {
+    const headers = this.buildExecuteHeaders(metadata);
+    const bodyStr = JSON.stringify({ input });
+    const authHeaders = this.didAuthenticator.signRequest(Buffer.from(bodyStr));
+    try {
+      const res = await this.http.post(
+        `/api/v1/execute/async/${target}`,
+        bodyStr,
+        { headers: this.mergeHeaders({ "Content-Type": "application/json", ...headers, ...authHeaders }) }
+      );
+      const executionId = res.data?.execution_id ?? res.data?.executionId ?? (typeof res.headers?.["x-execution-id"] === "string" ? res.headers["x-execution-id"] : void 0);
+      if (!executionId) {
+        throw new Error(`execute async ${target} returned no execution_id`);
+      }
+      return executionId;
+    } catch (err) {
+      const respData = err?.response?.data;
+      if (respData) {
+        const status = err.response.status;
+        const msg = respData.message || respData.error || JSON.stringify(respData);
+        const enriched = Object.assign(
+          new Error(`execute async ${target} failed (${status}): ${msg}`),
+          { status, responseData: respData }
+        );
+        throw enriched;
+      }
+      throw err;
+    }
+  }
+  /** Fetch the current status snapshot for an execution. */
+  async getExecutionStatus(executionId) {
+    const res = await this.http.get(
+      `/api/v1/executions/${encodeURIComponent(executionId)}`,
+      { headers: this.mergeHeaders({}) }
+    );
+    const data = res.data ?? {};
+    return {
+      executionId: data.execution_id ?? executionId,
+      status: data.status ?? "unknown",
+      statusReason: data.status_reason ?? void 0,
+      result: data.result,
+      error: data.error ?? void 0,
+      errorDetails: data.error_details,
+      durationMs: data.duration_ms ?? void 0
+    };
+  }
+  /**
+   * Poll an async execution until it reaches a terminal status, returning its
+   * result (or throwing on failure/cancellation/timeout).
+   *
+   * While polling, this observes the child's status transitions: when the
+   * child enters `waiting` it starts the supplied pause-clock and fires
+   * `onChildWaiting`; when the child leaves `waiting` it stops the clock and
+   * fires `onChildRunning`. Paused time is excluded from `timeoutMs`, so a
+   * parent awaiting a paused descendant does not time out while the descendant
+   * legitimately waits. Mirrors the Python SDK's `wait_for_execution_result`.
+   */
+  async waitForExecutionResult(executionId, opts = {}) {
+    const pollInterval = opts.pollIntervalMs ?? 1e3;
+    const maxInterval = opts.maxIntervalMs ?? 5e3;
+    const pauseClock = opts.pauseClock;
+    const start = Date.now();
+    let interval = pollInterval;
+    let childWaiting = false;
+    const activeElapsed = () => Date.now() - start - (pauseClock?.totalPaused() ?? 0);
+    try {
+      while (true) {
+        let snapshot;
+        try {
+          snapshot = await this.getExecutionStatus(executionId);
+        } catch {
+          if (opts.timeoutMs != null && activeElapsed() >= opts.timeoutMs) {
+            throw new Error(`waitForExecutionResult(${executionId}) timed out`);
+          }
+          await sleep2(interval);
+          interval = Math.min(interval * 2, maxInterval);
+          continue;
+        }
+        const status = normalizeStatus(snapshot.status);
+        if (status === "waiting" && !childWaiting) {
+          childWaiting = true;
+          pauseClock?.startPause();
+          await safePauseCallback(opts.onChildWaiting);
+        } else if (status !== "waiting" && childWaiting) {
+          childWaiting = false;
+          pauseClock?.endPause();
+          await safePauseCallback(opts.onChildRunning);
+        }
+        if (isTerminal(status)) {
+          if (status === "succeeded") {
+            return snapshot.result?.result ?? snapshot.result;
+          }
+          const detail = snapshot.error || snapshot.statusReason || status;
+          const failure = Object.assign(
+            new Error(`execution ${executionId} ${status}: ${detail}`),
+            { status: 0, responseData: snapshot.errorDetails ?? snapshot.error }
+          );
+          throw failure;
+        }
+        if (opts.timeoutMs != null && activeElapsed() >= opts.timeoutMs) {
+          throw new Error(`waitForExecutionResult(${executionId}) timed out`);
+        }
+        await sleep2(interval);
+        interval = Math.min(interval * 2, maxInterval);
+      }
+    } finally {
+      if (childWaiting) {
+        pauseClock?.endPause();
+      }
+    }
+  }
+  /**
+   * Notify the control plane that THIS execution is now `waiting` or `running`
+   * because of its awaited child's state — the multi-hop pause propagation
+   * hook. Distinct from request-approval: no approval id, no webhook, no human.
+   * It exists purely so ancestors watching this execution see WAITING
+   * transitively while a descendant is paused, and stop counting wall-clock.
+   *
+   * POSTs to `/api/v1/agents/{node}/executions/{id}/awaiter-status`.
+   */
+  async notifyAwaiterStatus(executionId, status, reason = "") {
+    if (status !== "waiting" && status !== "running") {
+      throw new Error(`notifyAwaiterStatus: status must be 'waiting' or 'running', got '${status}'`);
+    }
+    const nodeId = this.config.nodeId ?? "";
+    const payload = { status };
+    if (reason) payload.reason = reason;
+    const bodyStr = JSON.stringify(payload);
+    const authHeaders = this.didAuthenticator.signRequest(Buffer.from(bodyStr));
+    const res = await this.http.post(
+      `/api/v1/agents/${encodeURIComponent(nodeId)}/executions/${encodeURIComponent(executionId)}/awaiter-status`,
+      bodyStr,
+      {
+        headers: this.mergeHeaders({ "Content-Type": "application/json", ...authHeaders }),
+        timeout: 1e4
+      }
+    );
+    if (res.status >= 400) {
+      throw new Error(`awaiter-status update failed (${res.status})`);
+    }
+  }
+  /**
+   * Deliver a terminal execution result to the control plane, with retries.
+   *
+   * This is the out-of-band completion callback used by async-execution
+   * dispatch: after a reasoner has been 202-acked and run detached, its final
+   * status (`succeeded` / `failed` / `cancelled`) is POSTed to
+   * `/api/v1/executions/{id}/status`. Retries with exponential backoff because
+   * a dropped terminal callback would leave the execution stuck forever.
+   */
+  async reportExecutionResult(executionId, payload, maxRetries = 5) {
+    const body = {
+      status: payload.status,
+      execution_id: executionId,
+      duration_ms: payload.durationMs,
+      completed_at: payload.completedAt,
+      reasoner: payload.reasoner
+    };
+    if (payload.result !== void 0) body.result = wrapResult(payload.result);
+    if (payload.error !== void 0) body.error = payload.error;
+    if (payload.errorDetails !== void 0) body.error_details = payload.errorDetails;
+    const bodyStr = JSON.stringify(body);
+    const authHeaders = this.didAuthenticator.signRequest(Buffer.from(bodyStr));
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const res = await this.http.post(
+          `/api/v1/executions/${encodeURIComponent(executionId)}/status`,
+          bodyStr,
+          {
+            headers: this.mergeHeaders({ "Content-Type": "application/json", ...authHeaders }),
+            timeout: 3e4
+          }
+        );
+        if (res.status >= 200 && res.status < 300) {
+          return true;
+        }
+      } catch {
+      }
+      if (attempt < maxRetries - 1) {
+        await sleep2(2 ** attempt * 1e3);
+      }
+    }
+    return false;
+  }
   async discoverCapabilities(options = {}) {
     const format = (options.format ?? "json").toLowerCase();
     const params = { format };
@@ -2670,7 +3223,7 @@ var AgentFieldClient = class {
       ...executionHeaders,
       ...authHeaders
     });
-    axios4.post(`${uiApiBaseUrl}/executions/note`, bodyStr, {
+    axios5.post(`${uiApiBaseUrl}/executions/note`, bodyStr, {
       headers,
       timeout: devMode ? 5e3 : 1e4,
       httpAgent,
@@ -2679,11 +3232,30 @@ var AgentFieldClient = class {
     });
   }
 };
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function safePauseCallback(cb) {
+  if (!cb) return;
+  try {
+    await Promise.race([
+      Promise.resolve().then(cb),
+      sleep2(2e3)
+    ]);
+  } catch {
+  }
+}
+function wrapResult(result) {
+  if (result !== null && typeof result === "object" && !Array.isArray(result)) {
+    return result;
+  }
+  return { result };
+}
 var MemoryClientBase = class {
   http;
   defaultHeaders;
   constructor(baseUrl, defaultHeaders) {
-    this.http = axios4.create({
+    this.http = axios5.create({
       baseURL: baseUrl.replace(/\/$/, ""),
       timeout: 3e4,
       httpAgent,
@@ -3111,7 +3683,7 @@ var DidClient = class {
   http;
   defaultHeaders;
   constructor(baseUrl, defaultHeaders) {
-    this.http = axios4.create({
+    this.http = axios5.create({
       baseURL: baseUrl.replace(/\/$/, ""),
       timeout: 3e4,
       httpAgent,
@@ -3554,7 +4126,7 @@ var LocalVerifier = class {
     }
     let success = true;
     try {
-      const resp = await axios4.get(`${this.agentFieldUrl}/api/v1/policies`, {
+      const resp = await axios5.get(`${this.agentFieldUrl}/api/v1/policies`, {
         headers,
         timeout: 1e4
       });
@@ -3567,7 +4139,7 @@ var LocalVerifier = class {
       success = false;
     }
     try {
-      const resp = await axios4.get(`${this.agentFieldUrl}/api/v1/revocations`, {
+      const resp = await axios5.get(`${this.agentFieldUrl}/api/v1/revocations`, {
         headers,
         timeout: 1e4
       });
@@ -3580,7 +4152,7 @@ var LocalVerifier = class {
       success = false;
     }
     try {
-      const resp = await axios4.get(`${this.agentFieldUrl}/api/v1/registered-dids`, {
+      const resp = await axios5.get(`${this.agentFieldUrl}/api/v1/registered-dids`, {
         headers,
         timeout: 1e4
       });
@@ -3593,7 +4165,7 @@ var LocalVerifier = class {
       success = false;
     }
     try {
-      const resp = await axios4.get(`${this.agentFieldUrl}/api/v1/admin/public-key`, {
+      const resp = await axios5.get(`${this.agentFieldUrl}/api/v1/admin/public-key`, {
         headers,
         timeout: 1e4
       });
@@ -4025,6 +4597,17 @@ var Agent = class {
    *  code that respects `signal.aborted` (fetch, anthropic SDK, openai
    *  SDK, etc.). See ./cancel.ts. */
   cancelRegistry = new CancelRegistry();
+  /** Registry of pending `ctx.pause()` promises, resolved by the
+   *  `/webhooks/approval` route when the control plane delivers a decision.
+   *  See ./pause.ts. */
+  pauseManager = new PauseManager();
+  /** Per-execution pause clocks, keyed by execution_id. Present only for
+   *  detached (async-execution) reasoners; used to exclude pause/await time
+   *  from the reasoner's active wall-clock budget and from an awaiter's wait
+   *  timeout. See ./pause.ts. */
+  pauseClocks = /* @__PURE__ */ new Map();
+  /** Execution-scoped approval client used by `Agent.pause()`. */
+  approvalClient;
   constructor(config) {
     this.config = {
       port: 8001,
@@ -4032,12 +4615,19 @@ var Agent = class {
       host: "0.0.0.0",
       ...config,
       didEnabled: config.didEnabled ?? true,
-      deploymentType: config.deploymentType ?? "long_running"
+      deploymentType: config.deploymentType ?? "long_running",
+      asyncExecution: config.asyncExecution ?? true
     };
     this.app = express();
     this.app.use(express.json());
     this.aiClient = new AIClient(this.config.aiConfig);
     this.agentFieldClient = new AgentFieldClient(this.config);
+    this.approvalClient = new ApprovalClient({
+      baseURL: this.config.agentFieldUrl ?? "http://localhost:8080",
+      nodeId: this.config.nodeId,
+      apiKey: this.config.apiKey,
+      headers: this.sanitizeDefaultHeaders(this.config.defaultHeaders)
+    });
     this.memoryClient = new MemoryClient(this.config.agentFieldUrl, this.config.defaultHeaders);
     this.memoryEventClient = new MemoryEventClient(this.config.agentFieldUrl, this.config.defaultHeaders);
     this.didClient = new DidClient(this.config.agentFieldUrl, this.config.defaultHeaders);
@@ -4063,6 +4653,29 @@ var Agent = class {
     installCancelRoute(this.app, this.cancelRegistry, {
       info: (message, meta) => this.executionLogger.system("execution.cancel.received", message, meta ?? {})
     });
+    installApprovalWebhookRoute(this.app, this.pauseManager, {
+      info: (message, meta) => this.executionLogger.system("execution.approval.received", message, meta ?? {})
+    });
+  }
+  /** Coerce the loosely-typed `defaultHeaders` config into string headers. */
+  sanitizeDefaultHeaders(headers) {
+    const out = {};
+    for (const [key, value] of Object.entries(headers ?? {})) {
+      if (value !== void 0 && value !== null) {
+        out[key] = String(value);
+      }
+    }
+    return out;
+  }
+  /**
+   * Resolve the externally-reachable base URL for this agent — the URL the
+   * control plane uses to call back (approval webhook, cancel). Mirrors the
+   * value published at registration time.
+   */
+  resolvePublicUrl() {
+    const port = this.config.port ?? 8001;
+    const hostForUrl = this.config.publicUrl ? void 0 : this.config.host && this.config.host !== "0.0.0.0" ? this.config.host : "127.0.0.1";
+    return this.config.publicUrl ?? `http://${hostForUrl ?? "127.0.0.1"}:${port}`;
   }
   reasoner(name, handler, options) {
     this.reasoners.register(name, handler, options);
@@ -4185,6 +4798,84 @@ var Agent = class {
     }
     this.agentFieldClient.sendNote(message, tags, this.config.nodeId, execMetadata, uiApiUrl, this.config.devMode);
   }
+  /**
+   * Pause the current execution for external approval / resumption.
+   *
+   * Transitions the execution to `waiting` on the control plane, then blocks
+   * until the approval webhook callback resolves it or the timeout elapses.
+   * The caller is responsible for creating the approval request on an external
+   * service (e.g. hax-sdk) *before* calling this and passing the resulting
+   * `approvalRequestId`.
+   *
+   * Requires the agent to be serving (a reachable callback URL) and, to survive
+   * past the control plane's synchronous dispatch ceiling, requires
+   * async-execution dispatch to be enabled (the default). When async dispatch
+   * is disabled the pause still works but is bounded by that ceiling.
+   *
+   * Returns an {@link ApprovalResult}. On timeout it returns
+   * `{ decision: 'expired' }` rather than throwing. Mirrors the Python SDK's
+   * `Agent.pause()`.
+   */
+  async pause(opts) {
+    const executionId = opts.executionId ?? ExecutionContext.getCurrent()?.metadata.executionId;
+    if (!executionId) {
+      throw new Error("No execution_id available \u2014 cannot pause");
+    }
+    const callbackUrl = `${this.resolvePublicUrl()}/webhooks/approval`;
+    const expiresInHours = opts.expiresInHours ?? 72;
+    const future = this.pauseManager.register(opts.approvalRequestId, executionId);
+    try {
+      await this.approvalClient.requestApproval(executionId, {
+        approvalRequestId: opts.approvalRequestId,
+        approvalRequestUrl: opts.approvalRequestUrl,
+        callbackUrl,
+        expiresInHours
+      });
+    } catch (err) {
+      this.pauseManager.resolve(
+        opts.approvalRequestId,
+        new ApprovalResult({
+          decision: "error",
+          feedback: "failed to notify control plane",
+          executionId,
+          approvalRequestId: opts.approvalRequestId
+        })
+      );
+      throw err;
+    }
+    this.note(`Execution paused \u2014 waiting for approval ${opts.approvalRequestId}`, [
+      "approval",
+      "waiting"
+    ]);
+    const timeoutMs = opts.timeoutMs ?? expiresInHours * 36e5;
+    const pauseClock = this.pauseClocks.get(executionId);
+    pauseClock?.startPause();
+    let timer;
+    try {
+      const result = await Promise.race([
+        future,
+        new Promise((resolve2) => {
+          timer = setTimeout(() => {
+            resolve2(
+              new ApprovalResult({
+                decision: "expired",
+                feedback: "timed out waiting for approval",
+                executionId,
+                approvalRequestId: opts.approvalRequestId
+              })
+            );
+          }, timeoutMs);
+        })
+      ]);
+      if (result.decision === "expired") {
+        this.pauseManager.resolve(opts.approvalRequestId, result);
+      }
+      return result;
+    } finally {
+      if (timer) clearTimeout(timer);
+      pauseClock?.endPause();
+    }
+  }
   buildExecutionLogContext(metadata) {
     const current = metadata ?? ExecutionContext.getCurrent()?.metadata;
     if (!current) return void 0;
@@ -4228,6 +4919,7 @@ var Agent = class {
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
     }
+    this.pauseManager.cancelAll();
     await new Promise((resolve2, reject) => {
       this.server?.close((err) => {
         if (err) reject(err);
@@ -4424,23 +5116,24 @@ var Agent = class {
       rootWorkflowId,
       reasonerId: name
     });
+    const executeMetadata = {
+      runId,
+      workflowId,
+      rootWorkflowId,
+      parentExecutionId: parentMetadata?.executionId,
+      reasonerId: name,
+      sessionId: parentMetadata?.sessionId,
+      actorId: parentMetadata?.actorId,
+      callerDid: parentMetadata?.callerDid,
+      targetDid: parentMetadata?.targetDid,
+      agentNodeDid: parentMetadata?.agentNodeDid,
+      agentNodeId: this.config.nodeId,
+      replaySourceRunId: parentMetadata?.replaySourceRunId,
+      replayBeforeExecutionId: parentMetadata?.replayBeforeExecutionId,
+      replayMode: parentMetadata?.replayMode
+    };
     try {
-      const result = await this.agentFieldClient.execute(target, input, {
-        runId,
-        workflowId,
-        rootWorkflowId,
-        parentExecutionId: parentMetadata?.executionId,
-        reasonerId: name,
-        sessionId: parentMetadata?.sessionId,
-        actorId: parentMetadata?.actorId,
-        callerDid: parentMetadata?.callerDid,
-        targetDid: parentMetadata?.targetDid,
-        agentNodeDid: parentMetadata?.agentNodeDid,
-        agentNodeId: this.config.nodeId,
-        replaySourceRunId: parentMetadata?.replaySourceRunId,
-        replayBeforeExecutionId: parentMetadata?.replayBeforeExecutionId,
-        replayMode: parentMetadata?.replayMode
-      });
+      const result = this.config.asyncExecution === false ? await this.agentFieldClient.execute(target, input, executeMetadata) : await this.callRemoteAsync(target, input, executeMetadata, parentMetadata?.executionId);
       this.executionLogger.system("agent.call.completed", "Remote agent call completed", {
         target,
         agentNodeId: agentId,
@@ -4471,6 +5164,44 @@ var Agent = class {
       throw err;
     }
   }
+  /**
+   * Remote call variant that submits the execution asynchronously and polls for
+   * its result, instead of holding a synchronous connection open. This lets a
+   * caller await a descendant that legitimately pauses (WAITING) for a long
+   * time without tripping the control plane's synchronous dispatch ceiling.
+   *
+   * Multi-hop pause propagation: if the caller itself is a detached reasoner
+   * (has a registered pause-clock), then when the awaited child enters WAITING
+   * we push the caller's own execution to WAITING via awaiter-status — so any
+   * ancestor awaiting the caller transitively sees WAITING too and doesn't time
+   * out. Mirrors the propagation wiring in the Python SDK's `Agent.call`.
+   */
+  async callRemoteAsync(target, input, executeMetadata, parentExecutionId) {
+    const childExecutionId = await this.agentFieldClient.executeAsync(target, input, executeMetadata);
+    const parentPauseClock = parentExecutionId ? this.pauseClocks.get(parentExecutionId) : void 0;
+    let onChildWaiting;
+    let onChildRunning;
+    if (parentExecutionId && parentPauseClock) {
+      const reason = `awaiting child ${childExecutionId}`;
+      onChildWaiting = async () => {
+        try {
+          await this.agentFieldClient.notifyAwaiterStatus(parentExecutionId, "waiting", reason);
+        } catch {
+        }
+      };
+      onChildRunning = async () => {
+        try {
+          await this.agentFieldClient.notifyAwaiterStatus(parentExecutionId, "running", reason);
+        } catch {
+        }
+      };
+    }
+    return this.agentFieldClient.waitForExecutionResult(childExecutionId, {
+      pauseClock: parentPauseClock,
+      onChildWaiting,
+      onChildRunning
+    });
+  }
   registerDefaultRoutes() {
     this.app.get("/health", (_req, res) => {
       res.json(this.health());
@@ -4604,12 +5335,19 @@ var Agent = class {
     this.app.post("/execute/:name", (req, res) => this.executeServerlessHttp(req, res, req.params.name));
   }
   async executeReasoner(req, res, name) {
+    const metadata = this.buildMetadata(req);
+    const reasoner = this.reasoners.get(name);
+    if (reasoner && this.shouldRunAsync(req)) {
+      res.status(202).json({ status: "processing", execution_id: metadata.executionId });
+      void this.runReasonerAsync(reasoner, { targetName: name, input: req.body, metadata });
+      return;
+    }
     try {
       await this.executeInvocation({
         targetName: name,
         targetType: "reasoner",
         input: req.body,
-        metadata: this.buildMetadata(req),
+        metadata,
         req,
         res,
         respond: true
@@ -4914,6 +5652,121 @@ var Agent = class {
     }
     throw new TargetNotFoundError(`Reasoner not found: ${params.targetName}`);
   }
+  /**
+   * True when an incoming reasoner dispatch should run detached (202-ack).
+   *
+   * Requires async execution to be enabled AND the request to carry BOTH
+   * `X-Execution-ID` and `X-Run-ID`. The `X-Run-ID` header is the marker that
+   * the control plane dispatched this via an async-aware path — the workflow
+   * execute paths (`/execute`, `/execute/async`, agent-to-agent calls, triggers)
+   * always set it (see control-plane callAgent), and those paths wait for the
+   * out-of-band `/status` result. The legacy synchronous invoke endpoint
+   * (`POST /api/v1/reasoners/{node}.{reasoner}`) omits `X-Run-ID` for
+   * long-running agents and forwards the agent's HTTP response verbatim; it
+   * cannot handle a 202, so we must run synchronously there and return the
+   * result inline. Direct HTTP callers / tests without these headers likewise
+   * keep the synchronous request/response contract.
+   */
+  shouldRunAsync(req) {
+    if (this.config.asyncExecution === false) return false;
+    return this.hasHeader(req, "x-execution-id") && this.hasHeader(req, "x-run-id");
+  }
+  /** True when the request carries a non-empty value for the given header. */
+  hasHeader(req, name) {
+    const raw = req.headers[name];
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    return typeof value === "string" && value.trim().length > 0;
+  }
+  /**
+   * Run a reasoner detached after its dispatch was 202-acked, delivering the
+   * terminal status out-of-band via `POST /executions/{id}/status`.
+   *
+   * A pause-clock is registered for the execution so `ctx.pause()` (and any
+   * awaited paused descendant) can exclude its wait from the active wall-clock
+   * budget. A watchdog aborts the reasoner if active time exceeds the budget,
+   * guaranteeing the control plane always sees a terminal status even if the
+   * reasoner hangs. Mirrors the Python SDK's `_execute_async_with_callback`.
+   */
+  async runReasonerAsync(reasoner, params) {
+    const executionId = params.metadata.executionId;
+    const reasonerName = params.metadata.reasonerId ?? params.targetName;
+    const start = Date.now();
+    const budgetMs = this.config.executionBudgetMs ?? 72e5;
+    const pauseClock = new PauseClock();
+    this.pauseClocks.set(executionId, pauseClock);
+    const controller = new AbortController();
+    let watchdogTimer;
+    const watchdog = new Promise((_, reject) => {
+      const checkInterval = Math.min(5e3, Math.max(100, budgetMs / 4));
+      watchdogTimer = setInterval(() => {
+        const activeElapsed = Date.now() - start - pauseClock.totalPaused();
+        if (activeElapsed > budgetMs) {
+          pauseClock.timedOut = true;
+          this.cancelRegistry.cancel(executionId, "reasoner_timeout");
+          reject(
+            new Error(
+              `reasoner '${reasonerName}' timed out after ${Math.round(budgetMs / 1e3)}s of active time`
+            )
+          );
+        }
+      }, checkInterval);
+    });
+    watchdog.catch(() => {
+    });
+    const completedAt = () => (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const result = await Promise.race([
+        this.runReasoner(reasoner, {
+          targetName: params.targetName,
+          input: params.input,
+          metadata: params.metadata,
+          respond: false,
+          controller
+        }),
+        watchdog
+      ]);
+      await this.agentFieldClient.reportExecutionResult(executionId, {
+        status: "succeeded",
+        result,
+        durationMs: Date.now() - start,
+        completedAt: completedAt(),
+        reasoner: reasonerName
+      });
+    } catch (err) {
+      const durationMs = Date.now() - start;
+      if (pauseClock.timedOut) {
+        await this.agentFieldClient.reportExecutionResult(executionId, {
+          status: "failed",
+          error: err?.message ?? `reasoner '${reasonerName}' timed out`,
+          errorDetails: { reason: "reasoner_timeout" },
+          durationMs,
+          completedAt: completedAt(),
+          reasoner: reasonerName
+        });
+      } else if (controller.signal.aborted) {
+        await this.agentFieldClient.reportExecutionResult(executionId, {
+          status: "cancelled",
+          error: "cancelled_by_control_plane",
+          errorDetails: { reason: "cancelled" },
+          durationMs,
+          completedAt: completedAt(),
+          reasoner: reasonerName
+        });
+      } else {
+        await this.agentFieldClient.reportExecutionResult(executionId, {
+          status: "failed",
+          error: err?.message ?? "Execution failed",
+          errorDetails: err?.responseData,
+          durationMs,
+          completedAt: completedAt(),
+          reasoner: reasonerName
+        });
+      }
+    } finally {
+      if (watchdogTimer) clearInterval(watchdogTimer);
+      this.pauseClocks.delete(executionId);
+    }
+  }
   async runReasoner(reasoner, params) {
     const req = params.req ?? {};
     const res = params.res ?? {};
@@ -4930,7 +5783,8 @@ var Agent = class {
       agent: this
     });
     const { controller, release } = this.cancelRegistry.register(
-      executionMetadata.executionId
+      executionMetadata.executionId,
+      params.controller
     );
     return ExecutionContext.run(execCtx, async () => {
       this.executionLogger.system("execution.started", "Execution started", {
@@ -5153,9 +6007,7 @@ var Agent = class {
     try {
       const reasoners = this.reasonerDefinitions();
       const skills = this.skillDefinitions();
-      const port = this.config.port ?? 8001;
-      const hostForUrl = this.config.publicUrl ? void 0 : this.config.host && this.config.host !== "0.0.0.0" ? this.config.host : "127.0.0.1";
-      const publicUrl = this.config.publicUrl ?? `http://${hostForUrl ?? "127.0.0.1"}:${port}`;
+      const publicUrl = this.resolvePublicUrl();
       const agentTags = this.config.tags ?? [];
       const regResponse = await this.agentFieldClient.register({
         id: this.config.nodeId,
@@ -6288,7 +7140,7 @@ var OpenRouterMediaProvider = class {
     while (true) {
       const remaining = deadline - Date.now();
       if (remaining <= 0) break;
-      await sleep(Math.min(pollInterval, remaining));
+      await sleep3(Math.min(pollInterval, remaining));
       if (Date.now() >= deadline) break;
       const pollRes = await this.get(pollEndpoint);
       if (!pollRes.ok) {
@@ -6646,7 +7498,7 @@ var OpenRouterMediaProvider = class {
     });
   }
 };
-function sleep(ms) {
+function sleep3(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
@@ -6655,167 +7507,6 @@ init_types();
 init_factory();
 init_runner();
 
-// src/status/ExecutionStatus.ts
-var ExecutionStatus = {
-  PENDING: "pending",
-  QUEUED: "queued",
-  WAITING: "waiting",
-  RUNNING: "running",
-  SUCCEEDED: "succeeded",
-  FAILED: "failed",
-  CANCELLED: "cancelled",
-  TIMEOUT: "timeout",
-  UNKNOWN: "unknown"
-};
-var CANONICAL_STATUSES = new Set(
-  Object.values(ExecutionStatus)
-);
-var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
-  ExecutionStatus.SUCCEEDED,
-  ExecutionStatus.FAILED,
-  ExecutionStatus.CANCELLED,
-  ExecutionStatus.TIMEOUT
-]);
-var ACTIVE_STATUSES = /* @__PURE__ */ new Set([
-  ExecutionStatus.PENDING,
-  ExecutionStatus.QUEUED,
-  ExecutionStatus.WAITING,
-  ExecutionStatus.RUNNING
-]);
-var STATUS_ALIASES = {
-  success: "succeeded",
-  successful: "succeeded",
-  completed: "succeeded",
-  complete: "succeeded",
-  done: "succeeded",
-  ok: "succeeded",
-  error: "failed",
-  failure: "failed",
-  errored: "failed",
-  canceled: "cancelled",
-  cancel: "cancelled",
-  timed_out: "timeout",
-  wait: "queued",
-  awaiting_approval: "waiting",
-  awaiting_human: "waiting",
-  approval_pending: "waiting",
-  in_progress: "running",
-  processing: "running"
-};
-function normalizeStatus(status) {
-  if (status == null) return "unknown";
-  const normalized = status.trim().toLowerCase();
-  if (!normalized) return "unknown";
-  if (CANONICAL_STATUSES.has(normalized)) return normalized;
-  return STATUS_ALIASES[normalized] ?? "unknown";
-}
-function isTerminal(status) {
-  return TERMINAL_STATUSES.has(normalizeStatus(status));
-}
-function isActive(status) {
-  return ACTIVE_STATUSES.has(normalizeStatus(status));
-}
-var ApprovalClient = class {
-  http;
-  nodeId;
-  headers;
-  constructor(opts) {
-    this.http = axios4.create({
-      baseURL: opts.baseURL.replace(/\/$/, ""),
-      timeout: 3e4,
-      httpAgent,
-      httpsAgent
-    });
-    this.nodeId = opts.nodeId;
-    const merged = { ...opts.headers ?? {} };
-    if (opts.apiKey) {
-      merged["X-API-Key"] = opts.apiKey;
-    }
-    this.headers = merged;
-  }
-  /**
-   * Request human approval, transitioning the execution to `waiting`.
-   *
-   * Calls `POST /api/v1/agents/{node}/executions/{id}/request-approval`.
-   */
-  async requestApproval(executionId, payload) {
-    const body = {
-      approval_request_id: payload.approvalRequestId,
-      expires_in_hours: payload.expiresInHours ?? 72
-    };
-    if (payload.approvalRequestUrl) {
-      body.approval_request_url = payload.approvalRequestUrl;
-    }
-    if (payload.callbackUrl) {
-      body.callback_url = payload.callbackUrl;
-    }
-    const res = await this.http.post(
-      `/api/v1/agents/${encodeURIComponent(this.nodeId)}/executions/${encodeURIComponent(executionId)}/request-approval`,
-      body,
-      { headers: { ...this.headers, "Content-Type": "application/json" } }
-    );
-    return {
-      approvalRequestId: res.data.approval_request_id ?? "",
-      approvalRequestUrl: res.data.approval_request_url ?? ""
-    };
-  }
-  /**
-   * Get the current approval status for an execution.
-   *
-   * Calls `GET /api/v1/agents/{node}/executions/{id}/approval-status`.
-   */
-  async getApprovalStatus(executionId) {
-    const res = await this.http.get(
-      `/api/v1/agents/${encodeURIComponent(this.nodeId)}/executions/${encodeURIComponent(executionId)}/approval-status`,
-      { headers: this.headers }
-    );
-    const data = res.data;
-    return {
-      status: data.status ?? "pending",
-      response: data.response,
-      requestUrl: data.request_url,
-      requestedAt: data.requested_at,
-      respondedAt: data.responded_at
-    };
-  }
-  /**
-   * Poll approval status with exponential backoff until resolved.
-   *
-   * Returns once the status is no longer `pending` (i.e. approved, rejected,
-   * or expired).
-   */
-  async waitForApproval(executionId, opts) {
-    const pollInterval = opts?.pollIntervalMs ?? 5e3;
-    const maxInterval = opts?.maxIntervalMs ?? 6e4;
-    const timeout = opts?.timeoutMs;
-    const backoffFactor = 2;
-    const startTime = Date.now();
-    let interval = pollInterval;
-    while (true) {
-      if (timeout != null && Date.now() - startTime >= timeout) {
-        throw new Error(
-          `Approval for execution ${executionId} timed out after ${timeout}ms`
-        );
-      }
-      await sleep2(interval);
-      let data;
-      try {
-        data = await this.getApprovalStatus(executionId);
-      } catch {
-        interval = Math.min(interval * backoffFactor, maxInterval);
-        continue;
-      }
-      if (data.status !== "pending") {
-        return data;
-      }
-      interval = Math.min(interval * backoffFactor, maxInterval);
-    }
-  }
-};
-function sleep2(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-
-export { ACTIVE_STATUSES, AIClient, Agent, AgentRouter, ApprovalClient, Audio, CANONICAL_STATUSES, DIDAuthenticator, DidClient, DidInterface, DidManager, ExecutionContext, ExecutionLogger, ExecutionStatus, File, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, HarnessRunner, Image, JWE_ALG, JWE_ENC, KEY_AGREEMENT_TYPE, MediaProviderError, MediaRouter, MemoryClient, MemoryClientBase, MemoryEventClient, MemoryInterface, MultimodalResponse, OpenRouterMediaProvider, PayloadEncryptionError, RateLimitError, RealtimeSession, ReasonerContext, SUPPORTED_PROVIDERS, SUPPORTED_SESSION_TRANSPORTS, SessionTransportError, SkillContext, StatelessRateLimiter, TERMINAL_STATUSES, Text, Video, WorkflowReporter, audioFromBase64, audioFromBuffer, audioFromFile, audioFromUrl, buildProvider, buildSessionDefinition, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createExecutionLogger, createHarnessResult, createMetrics, createMultimodalResponse, createRawResult, decrypt, decryptToString, encryptForDid, encryptToJwk, executeToolCallLoop, extractKeyAgreementJwk, fileFromBase64, fileFromBuffer, fileFromPath, fileFromUrl, generateX25519KeyPair, getCurrentContext, getCurrentSkillContext, imageFromBase64, imageFromBuffer, imageFromFile, imageFromUrl, isActive, isExecutionLogBatchPayload, isTerminal, normalizeExecutionLogEntry, normalizeSessionTransportValue, normalizeStatus, serializeExecutionLogEntry, text, validateSessionTransport, videoFromBase64, videoFromBuffer, videoFromFile, videoFromUrl };
+export { ACTIVE_STATUSES, AIClient, Agent, AgentRouter, ApprovalClient, ApprovalResult, Audio, CANONICAL_STATUSES, DIDAuthenticator, DidClient, DidInterface, DidManager, ExecutionContext, ExecutionLogger, ExecutionStatus, File, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, HarnessRunner, Image, JWE_ALG, JWE_ENC, KEY_AGREEMENT_TYPE, MediaProviderError, MediaRouter, MemoryClient, MemoryClientBase, MemoryEventClient, MemoryInterface, MultimodalResponse, OpenRouterMediaProvider, PauseClock, PauseManager, PayloadEncryptionError, RateLimitError, RealtimeSession, ReasonerContext, SUPPORTED_PROVIDERS, SUPPORTED_SESSION_TRANSPORTS, SessionTransportError, SkillContext, StatelessRateLimiter, TERMINAL_STATUSES, Text, Video, WorkflowReporter, audioFromBase64, audioFromBuffer, audioFromFile, audioFromUrl, buildProvider, buildSessionDefinition, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createExecutionLogger, createHarnessResult, createMetrics, createMultimodalResponse, createRawResult, decrypt, decryptToString, encryptForDid, encryptToJwk, executeToolCallLoop, extractKeyAgreementJwk, fileFromBase64, fileFromBuffer, fileFromPath, fileFromUrl, generateX25519KeyPair, getCurrentContext, getCurrentSkillContext, imageFromBase64, imageFromBuffer, imageFromFile, imageFromUrl, installApprovalWebhookRoute, isActive, isExecutionLogBatchPayload, isTerminal, normalizeExecutionLogEntry, normalizeSessionTransportValue, normalizeStatus, serializeExecutionLogEntry, text, validateSessionTransport, videoFromBase64, videoFromBuffer, videoFromFile, videoFromUrl };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map