@tangle-network/agent-runtime 0.14.0 → 0.15.0

package/dist/agent.d.ts

@@ -1,6 +1,6 @@
 import * as _tangle_network_agent_eval from '@tangle-network/agent-eval';
 import { FindingSubject, TraceAnalystKindSpec, AnalystFinding, TraceStore, RunCompleteHook, FeedbackLabel, FeedbackTrajectoryStore } from '@tangle-network/agent-eval';
-import { R as RuntimeStreamEvent } from './types-jr_EFhrD.js';
+import { R as RuntimeStreamEvent } from './types-CYxfw14J.js';
 import { I as ImprovementAdapter, K as KnowledgeAdapter, a as RunAnalystLoopResult } from './types-D_MXrmJP.js';
 
 /**

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { AgentEvalError, KnowledgeReadinessReport, ControlEvalResult, KnowledgeRequirement, TraceEvent } from '@tangle-network/agent-eval';
 export { AgentEvalError, AgentEvalErrorCode, CaptureIntegrityError, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, ReplayError, RunRecord, UserQuestion, ValidationError, VerificationError } from '@tangle-network/agent-eval';
-import { A as AgentBackendInput, a as AgentExecutionBackend, b as AgentBackendContext, R as RuntimeStreamEvent, c as AgentTaskSpec, K as KnowledgeReadinessDecision, d as RunAgentTaskOptions, e as AgentTaskRunResult, f as RunAgentTaskStreamOptions, g as AgentTaskRunSummary, h as AgentRuntimeEvent, i as AgentTaskStatus, j as RuntimeSessionStore, k as RuntimeSession } from './types-jr_EFhrD.js';
-export { l as AgentAdapter, m as AgentKnowledgeProvider, n as AgentRuntimeEventSink, o as AgentTaskContext } from './types-jr_EFhrD.js';
+import { A as AgentBackendInput, a as AgentExecutionBackend, b as AgentBackendContext, R as RuntimeStreamEvent, c as AgentTaskSpec, K as KnowledgeReadinessDecision, d as RunAgentTaskOptions, e as AgentTaskRunResult, f as RunAgentTaskStreamOptions, g as AgentTaskRunSummary, h as AgentRuntimeEvent, i as AgentTaskStatus, j as RuntimeSessionStore, k as RuntimeSession } from './types-CYxfw14J.js';
+export { l as AgentAdapter, m as AgentKnowledgeProvider, n as AgentRuntimeEventSink, o as AgentTaskContext } from './types-CYxfw14J.js';
 import { AgentProfilePrompt, AgentProfileResources, AgentSubagentProfile, AgentProfile, SandboxInstance } from '@tangle-network/sandbox';
 
 /**
@@ -59,6 +59,14 @@ interface BackendRetryPolicy {
     jitter?: number;
     /** Status codes that trigger a retry. Default: 408, 425, 429, 500, 502, 503, 504. */
     retryStatuses?: ReadonlyArray<number>;
+    /**
+     * Per-attempt wall-clock deadline in ms. If a single fetch attempt does
+     * not return headers within this window the attempt is aborted and
+     * retried. Default 120000 (2 min). Without this a hung upstream blocks
+     * the attempt indefinitely — observed in production as a 15-minute
+     * `fetch failed` that burned an entire eval persona. Set to 0 to disable.
+     */
+    requestTimeoutMs?: number;
 }
 declare function createOpenAICompatibleBackend<TInput extends AgentBackendInput = AgentBackendInput>(options: {
     apiKey: string;

package/dist/index.js

@@ -113,6 +113,32 @@ function pickRetryDelayMs(attempt, policy) {
   const jitter = capped * policy.jitter * (Math.random() * 2 - 1);
   return Math.max(0, Math.round(capped + jitter));
 }
+function withTimeout(callerSignal, timeoutMs) {
+  if (timeoutMs <= 0) {
+    return { signal: callerSignal ?? new AbortController().signal, dispose: () => void 0 };
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(new Error(`request timed out after ${timeoutMs}ms`)),
+    timeoutMs
+  );
+  if (typeof timer.unref === "function") {
+    ;
+    timer.unref();
+  }
+  const onCallerAbort = () => controller.abort(callerSignal?.reason ?? new Error("aborted"));
+  if (callerSignal) {
+    if (callerSignal.aborted) onCallerAbort();
+    else callerSignal.addEventListener("abort", onCallerAbort, { once: true });
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      clearTimeout(timer);
+      callerSignal?.removeEventListener("abort", onCallerAbort);
+    }
+  };
+}
 function sleep(ms, signal) {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) {
@@ -138,7 +164,8 @@ function createOpenAICompatibleBackend(options) {
     initialBackoffMs: options.retry?.initialBackoffMs ?? 1e3,
     maxBackoffMs: options.retry?.maxBackoffMs ?? 3e4,
     jitter: options.retry?.jitter ?? 0.25,
-    retryStatuses: options.retry?.retryStatuses ?? DEFAULT_RETRY_STATUSES
+    retryStatuses: options.retry?.retryStatuses ?? DEFAULT_RETRY_STATUSES,
+    requestTimeoutMs: options.retry?.requestTimeoutMs ?? 12e4
   };
   return {
     kind,
@@ -146,24 +173,40 @@ function createOpenAICompatibleBackend(options) {
       return newRuntimeSession(kind, context.requestedSessionId);
     },
     async *stream(input, context) {
+      const url = `${options.baseUrl.replace(/\/$/, "")}/chat/completions`;
+      const requestBody = JSON.stringify({
+        model: options.model,
+        stream: true,
+        messages: input.messages ?? [
+          { role: "user", content: input.message ?? context.task.intent }
+        ]
+      });
       let response;
       let lastStatus = 0;
+      let lastThrown;
       for (let attempt = 1; attempt <= retryPolicy.maxAttempts; attempt++) {
-        response = await fetcher(`${options.baseUrl.replace(/\/$/, "")}/chat/completions`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${options.apiKey}`,
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            model: options.model,
-            stream: true,
-            messages: input.messages ?? [
-              { role: "user", content: input.message ?? context.task.intent }
-            ]
-          }),
-          signal: context.signal
-        });
+        lastThrown = void 0;
+        const attemptSignal = withTimeout(context.signal, retryPolicy.requestTimeoutMs);
+        try {
+          response = await fetcher(url, {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${options.apiKey}`,
+              "Content-Type": "application/json"
+            },
+            body: requestBody,
+            signal: attemptSignal.signal
+          });
+        } catch (err) {
+          attemptSignal.dispose();
+          if (context.signal?.aborted) throw err;
+          lastThrown = err;
+          response = void 0;
+          if (attempt === retryPolicy.maxAttempts) break;
+          await sleep(pickRetryDelayMs(attempt, retryPolicy), context.signal);
+          continue;
+        }
+        attemptSignal.dispose();
         if (response.ok) break;
         lastStatus = response.status;
         if (!retryPolicy.retryStatuses.includes(response.status)) break;
@@ -175,7 +218,15 @@ function createOpenAICompatibleBackend(options) {
         const delayMs = pickRetryDelayMs(attempt, retryPolicy);
         await sleep(delayMs, context.signal);
       }
-      if (!response || !response.ok) {
+      if (!response) {
+        const reason = lastThrown instanceof Error ? lastThrown.message : String(lastThrown);
+        throw new BackendTransportError(
+          kind,
+          `chat backend unreachable after ${retryPolicy.maxAttempts} attempts: ${reason}`,
+          { status: 0 }
+        );
+      }
+      if (!response.ok) {
         throw new BackendTransportError(kind, `chat backend returned ${lastStatus || "unknown"}`, {
           status: lastStatus || 0
         });
@@ -242,6 +293,36 @@ function mapCommonBackendEvent(event, context) {
       timestamp: nowIso()
     };
   }
+  if (type === "artifact") {
+    const artifactId = stringValue(data.artifactId) ?? stringValue(data.id) ?? stringValue(record.artifactId);
+    if (!artifactId) return void 0;
+    return {
+      type: "artifact",
+      task: context.task,
+      session: context.session,
+      artifactId,
+      name: stringValue(data.name) ?? stringValue(record.name),
+      mimeType: stringValue(data.mimeType) ?? stringValue(record.mimeType),
+      uri: stringValue(data.uri) ?? stringValue(record.uri),
+      content: stringValue(data.content) ?? stringValue(data.body) ?? stringValue(record.content),
+      metadata: data.metadata && typeof data.metadata === "object" ? data.metadata : void 0,
+      timestamp: nowIso()
+    };
+  }
+  if (type === "proposal_created" || type === "proposal" || type === "filing") {
+    const proposalId = stringValue(data.proposalId) ?? stringValue(data.id) ?? stringValue(record.proposalId);
+    if (!proposalId) return void 0;
+    const status = stringValue(data.status) ?? stringValue(record.status);
+    return {
+      type: "proposal_created",
+      task: context.task,
+      session: context.session,
+      proposalId,
+      title: stringValue(data.title) ?? stringValue(record.title) ?? proposalId,
+      status: status === "pending" || status === "approved" || status === "rejected" ? status : void 0,
+      timestamp: nowIso()
+    };
+  }
   if (type === "result" || type === "final") {
     const text = stringValue(data.finalText) ?? stringValue(data.text) ?? stringValue(record.text);
     return text ? {
@@ -2675,9 +2756,21 @@ function sanitizeRuntimeStreamEvent(event, options = {}) {
       name: event.name,
       mimeType: event.mimeType,
       uri: options.includeEvidenceIds ? event.uri : void 0,
+      content: options.includeControlPayloads ? event.content : void 0,
       metadata: options.includeMetadata ? event.metadata : void 0
     };
   }
+  if (event.type === "proposal_created") {
+    return {
+      type: event.type,
+      ...withTask,
+      ...withSession,
+      timestamp: event.timestamp,
+      proposalId: event.proposalId,
+      title: options.includeControlPayloads ? event.title : void 0,
+      status: event.status
+    };
+  }
   if (event.type === "final") {
     return {
       type: event.type,
@@ -3051,6 +3144,16 @@ function projectToTraceEvent(event) {
           mimeType: event.mimeType
         }
       };
+    case "proposal_created":
+      return {
+        kind: "state_mutation",
+        payload: {
+          phase: "proposal_created",
+          proposalId: event.proposalId,
+          title: event.title,
+          status: event.status
+        }
+      };
     case "task_end":
       return {
         kind: event.status === "failed" || event.status === "aborted" ? "error" : "log",