@bluecopa/harness 2.0.1-snapshot.3 → 2.0.1-snapshot.4

package/dist/arc/index.d.ts

@@ -1,5 +1,5 @@
-import { A as AnyTool, T as ToolProvider, a as ToolResult, M as ModelFactory, b as ToolResultArtifact } from '../shared-types-vZuVoy_H.js';
-export { c as ActionType, B as BashOptions, d as BatchOp, e as BatchResult, G as GlobOptions, f as GrepOptions, R as ReadOptions, g as TextEditorRequest, h as ThreadStatus, i as ToolProviderCapabilities, W as WebFetchOptions } from '../shared-types-vZuVoy_H.js';
+import { A as AnyTool, T as ToolProvider, a as ToolResult, M as ModelFactory, b as ToolResultArtifact, c as ToolProviderCapabilities, B as BashOptions, R as ReadOptions, G as GlobOptions, d as GrepOptions, e as BatchOp, f as BatchResult } from '../shared-types-D89hqST8.js';
+export { g as ActionType, h as TextEditorRequest, i as ThreadStatus, W as WebFetchOptions } from '../shared-types-D89hqST8.js';
 import { HarnessTelemetry } from '../observability/otel.js';
 export { MetricRecord, SpanHandle, SpanRecord } from '../observability/otel.js';
 import 'ai';
@@ -1006,6 +1006,64 @@ declare const ABSOLUTE_MAX_WORKER_STEPS = 60;
 /** Recommended extension size when workers need to keep their current context. */
 declare const REQUEST_MORE_STEPS_INCREMENT = 15;
 
+interface Episode {
+    id: string;
+    taskId: string;
+    sessionId: string;
+    tupleId?: string;
+    summary: string;
+    createdAt: number;
+    completedAt?: number;
+    /** Arbitrary metadata for routing/display */
+    metadata?: Record<string, unknown>;
+}
+interface EpisodeTrace {
+    episodeId: string;
+    messages: Array<{
+        role: string;
+        content: string;
+        [key: string]: unknown;
+    }>;
+    createdAt: number;
+}
+interface EpisodeStore {
+    addEpisode(episode: Episode): Promise<void>;
+    addTrace(trace: EpisodeTrace): Promise<void>;
+    getEpisode(id: string): Promise<Episode | null>;
+    getTrace(episodeId: string): Promise<EpisodeTrace | null>;
+    getEpisodesByTask(taskId: string): Promise<Episode[]>;
+    getEpisodesBySession(sessionId: string): Promise<Episode[]>;
+    getRecentEpisodes(limit: number): Promise<Episode[]>;
+    evictTraces(olderThan: number): Promise<number>;
+}
+interface SessionMemo {
+    id: string;
+    sessionId: string;
+    content: string;
+    sourceEpisodeIds?: string[];
+    createdAt: number;
+}
+interface SessionMemoStore {
+    addMemo(memo: SessionMemo): Promise<void>;
+    getMemo(id: string): Promise<SessionMemo | null>;
+    getMemosBySession(sessionId: string): Promise<SessionMemo[]>;
+    getRecentMemos(limit: number): Promise<SessionMemo[]>;
+}
+interface LongTermMemory {
+    id: string;
+    content: string;
+    category: string;
+    createdAt: number;
+    updatedAt: number;
+}
+interface LongTermStore {
+    addMemory(memory: LongTermMemory): Promise<void>;
+    getMemory(id: string): Promise<LongTermMemory | null>;
+    getAllMemories(): Promise<LongTermMemory[]>;
+    getMemoriesByCategory(category: string): Promise<LongTermMemory[]>;
+    updateMemory(id: string, updates: Partial<Pick<LongTermMemory, 'content' | 'category' | 'updatedAt'>>): Promise<void>;
+    deleteMemory(id: string): Promise<void>;
+}
 /** In-memory transcript store for testing */
 declare class MemoryTranscriptStore implements TranscriptStore {
     private transcripts;
@@ -1048,6 +1106,37 @@ declare class MemorySessionStore implements SessionStore {
     saveMeta(id: string, meta: SessionMeta): Promise<void>;
     list(): Promise<SessionMeta[]>;
 }
+/** In-memory episode store */
+declare class InMemoryEpisodeStore implements EpisodeStore {
+    private episodes;
+    private traces;
+    addEpisode(episode: Episode): Promise<void>;
+    addTrace(trace: EpisodeTrace): Promise<void>;
+    getEpisode(id: string): Promise<Episode | null>;
+    getTrace(episodeId: string): Promise<EpisodeTrace | null>;
+    getEpisodesByTask(taskId: string): Promise<Episode[]>;
+    getEpisodesBySession(sessionId: string): Promise<Episode[]>;
+    getRecentEpisodes(limit: number): Promise<Episode[]>;
+    evictTraces(_olderThan: number): Promise<number>;
+}
+/** In-memory session memo store */
+declare class InMemorySessionMemoStore implements SessionMemoStore {
+    private memos;
+    addMemo(memo: SessionMemo): Promise<void>;
+    getMemo(id: string): Promise<SessionMemo | null>;
+    getMemosBySession(sessionId: string): Promise<SessionMemo[]>;
+    getRecentMemos(limit: number): Promise<SessionMemo[]>;
+}
+/** In-memory long-term store */
+declare class InMemoryLongTermStore implements LongTermStore {
+    private memories;
+    addMemory(memory: LongTermMemory): Promise<void>;
+    getMemory(id: string): Promise<LongTermMemory | null>;
+    getAllMemories(): Promise<LongTermMemory[]>;
+    getMemoriesByCategory(category: string): Promise<LongTermMemory[]>;
+    updateMemory(id: string, updates: Partial<Pick<LongTermMemory, 'content' | 'category' | 'updatedAt'>>): Promise<void>;
+    deleteMemory(id: string): Promise<void>;
+}
 
 /**
  * File-based transcript store.
@@ -1080,6 +1169,169 @@ declare class FsArtifactStore implements ArtifactStore {
     private save;
 }
 
+/**
+ * CompositeToolProvider delegates to the first provider with matching capabilities.
+ *
+ * Useful when multiple tool providers exist (e.g., a sandbox executor + a local
+ * file-system executor) and you want to route tool calls based on capability.
+ */
+declare class CompositeToolProvider implements ToolProvider {
+    private providers;
+    constructor(providers: ToolProvider[]);
+    capabilities(): ToolProviderCapabilities;
+    /** Pick the first provider that supports the requested capability. */
+    private pick;
+    bash(command: string, options?: BashOptions): Promise<ToolResult>;
+    readFile(path: string, options?: ReadOptions): Promise<ToolResult>;
+    writeFile(path: string, content: string): Promise<ToolResult>;
+    editFile(path: string, oldText: string, newText: string): Promise<ToolResult>;
+    glob(pattern: string, options?: GlobOptions): Promise<ToolResult>;
+    grep(pattern: string, path?: string, options?: GrepOptions): Promise<ToolResult>;
+}
+
+/**
+ * Executor interface for sandboxed code execution (e.g., E2B sandbox).
+ *
+ * Implementations wrap sandbox APIs into a uniform shape that
+ * E2BToolProvider can delegate to.
+ */
+interface E2BExecutor {
+    bash(command: string, options?: BashOptions): Promise<ToolResult>;
+    readFile(path: string, options?: ReadOptions): Promise<ToolResult>;
+    writeFile(path: string, content: string): Promise<ToolResult>;
+    editFile(path: string, oldText: string, newText: string): Promise<ToolResult>;
+    glob(pattern: string, options?: GlobOptions): Promise<ToolResult>;
+    grep(pattern: string, path?: string, options?: GrepOptions): Promise<ToolResult>;
+    batch?(ops: BatchOp[]): Promise<BatchResult[]>;
+    destroy(): Promise<void>;
+}
+/**
+ * E2BToolProvider wraps an E2BExecutor into a ToolProvider interface
+ * suitable for use with the harness agent loop.
+ */
+declare class E2BToolProvider {
+    private executor;
+    constructor(executor: E2BExecutor);
+    capabilities(): ToolProviderCapabilities;
+    bash(command: string, options?: BashOptions): Promise<ToolResult>;
+    readFile(path: string, options?: ReadOptions): Promise<ToolResult>;
+    writeFile(path: string, content: string): Promise<ToolResult>;
+    editFile(path: string, oldText: string, newText: string): Promise<ToolResult>;
+    glob(pattern: string, options?: GlobOptions): Promise<ToolResult>;
+    grep(pattern: string, path?: string, options?: GrepOptions): Promise<ToolResult>;
+}
+
+/** Options for constructing a ControlPlaneE2BExecutor. */
+interface ControlPlaneE2BExecutorOptions {
+    baseUrl: string;
+    apiKey: string;
+    templateId?: string;
+}
+/**
+ * Base class for control-plane E2B sandbox executors.
+ *
+ * Provides the configuration surface and stubs that concrete implementations
+ * (e.g., Samyx control-plane API) extend. Subclasses must override the
+ * tool-execution methods with actual sandbox API calls.
+ */
+declare class ControlPlaneE2BExecutor implements E2BExecutor {
+    protected baseUrl: string;
+    protected apiKey: string;
+    protected templateId: string;
+    constructor(options: ControlPlaneE2BExecutorOptions);
+    bash(_command: string, _options?: BashOptions): Promise<ToolResult>;
+    readFile(_path: string, _options?: ReadOptions): Promise<ToolResult>;
+    writeFile(_path: string, _content: string): Promise<ToolResult>;
+    editFile(_path: string, _oldText: string, _newText: string): Promise<ToolResult>;
+    glob(_pattern: string, _options?: GlobOptions): Promise<ToolResult>;
+    grep(_pattern: string, _path?: string, _options?: GrepOptions): Promise<ToolResult>;
+    writeFileBytes(_path: string, _data: Uint8Array): Promise<void>;
+    readFileBytes(_path: string): Promise<Uint8Array>;
+    get activeSandboxId(): string | undefined;
+    destroy(): Promise<void>;
+}
+
+/**
+ * Permission request sent to the resolver for each tool call.
+ *
+ * The `toolName` key is always present. Additional tool arguments
+ * are forwarded as-is for context-sensitive permission decisions.
+ */
+interface PermissionRequest {
+    toolName: string;
+    [toolArg: string]: unknown;
+}
+/** Resolver function that decides whether a tool call is permitted. */
+type PermissionResolver = (request: PermissionRequest) => Promise<boolean>;
+/** Permission mode for the manager. */
+type PermissionMode = "deny_all" | "allow_all" | "ask";
+/**
+ * PermissionManager controls whether tool calls are allowed.
+ *
+ * Three modes:
+ * - `deny_all`: reject everything
+ * - `allow_all`: accept everything
+ * - `ask`: delegate to a resolver function
+ */
+declare class PermissionManager {
+    private mode;
+    private resolver;
+    constructor(mode: PermissionMode, resolver?: PermissionResolver);
+    /** Check whether a tool call is permitted. */
+    canExecute(request: PermissionRequest): Promise<boolean>;
+}
+
+interface ExecutionContext {
+    attempt: number;
+    totalAttempts: number;
+    startTime: number;
+    signal: AbortSignal;
+}
+interface PipelineOptions {
+    timeout?: number;
+    retryCount?: number;
+}
+declare class ResiliencePipeline {
+    private options;
+    constructor(options?: PipelineOptions);
+    /** Set a timeout in milliseconds for execution. */
+    timeout(ms: number): ResiliencePipeline;
+    /** Set retry count. */
+    retries(count: number): ResiliencePipeline;
+    /** Build the executable pipeline. */
+    build(): {
+        execute: <T>(fn: () => Promise<T>, ctx: ExecutionContext) => Promise<T>;
+    };
+}
+/** Create a new resilience pipeline builder. */
+declare function resilience(): ResiliencePipeline;
+
+/**
+ * Profile types for ArcLoop thread configuration.
+ *
+ * Profiles control which tools a worker thread can use and which
+ * model tier it runs at.
+ */
+/** Declaration of a worker profile — matched by name in process context. */
+interface ProfileDeclaration {
+    name: string;
+    /** Descriptive signature for the orchestrator (e.g., "question:string -> evidence:string[]") */
+    signature: string;
+    /** Tool names available to workers with this profile */
+    tools: string[];
+    /** Worker model tier */
+    model: "fast" | "medium" | "strong";
+    /** Worker step budget */
+    maxSteps: number;
+    /** Background/injection context for the worker system prompt */
+    background: string;
+}
+/** A profile bound to a process, with its declaration. */
+interface ProcessProfile {
+    name: string;
+    declaration: ProfileDeclaration;
+}
+
 /**
  * In-memory reference implementation of JobRegistry.
  *
@@ -1105,4 +1357,4 @@ declare class MemoryJobRegistry implements JobRegistry {
     private emit;
 }
 
-export { ABSOLUTE_MAX_WORKER_STEPS, AnyTool, type ArcConfig, type ArcEvent, ArcLoop, type ArcRunResult, type ArcTraceEvent, type Artifact, type ArtifactStore, DEFAULT_MAX_STEPS_PER_WORKER, DEFAULT_WORKER_STEP_BUDGETS, type DispatchRecord, type DispatchTier, type ExpectedArtifact, type ExpectedOutputContract, FsArtifactStore, FsTranscriptStore, HarnessTelemetry, type HookCallback, type HookContext, type HookDecision, type HookEventName, HookRunner, type JobEvent, type JobKind, type JobRegistry, type JobSpec, type JobStartOptions, type JobState, type JobStatus, type JobTransport, MemoryArtifactStore, MemoryJobRegistry, MemoryMessageStore, MemoryScratchPad, MemorySessionStore, MemorySummaryDAG, MemoryTranscriptStore, MemoryVectorIndex, type MessageStore, ModelFactory, type OodaSnapshot, type OrchestratorContext, type PushResult, REQUEST_MORE_STEPS_INCREMENT, type ReadEpisodeArgs, type ReadEpisodeDetail, type RunWorkerConfig, type ScratchPad, type SessionMeta, type SessionSnapshot, type SessionStore, type StoredAttachment, type StoredMessage, type SummaryDAG, type SummaryNode, type Tool, type ToolExecutionMode, ToolProvider, ToolResult, ToolResultArtifact, type TraceToolCall, type Transcript, type TranscriptStore, type Tuple, type VectorIndex, type WorkerProgressEvent, type WorkerResult, cloneForTrace, formatDispatchForPrompt };
+export { ABSOLUTE_MAX_WORKER_STEPS, AnyTool, type ArcConfig, type ArcEvent, ArcLoop, type ArcRunResult, type ArcTraceEvent, type Artifact, type ArtifactStore, BashOptions, BatchOp, BatchResult, CompositeToolProvider, ControlPlaneE2BExecutor, type ControlPlaneE2BExecutorOptions, DEFAULT_MAX_STEPS_PER_WORKER, DEFAULT_WORKER_STEP_BUDGETS, type DispatchRecord, type DispatchTier, type E2BExecutor, E2BToolProvider, type Episode, type EpisodeStore, type EpisodeTrace, type ExecutionContext, type ExpectedArtifact, type ExpectedOutputContract, FsArtifactStore, FsTranscriptStore, GlobOptions, GrepOptions, HarnessTelemetry, type HookCallback, type HookContext, type HookDecision, type HookEventName, HookRunner, InMemoryEpisodeStore, InMemoryLongTermStore, InMemorySessionMemoStore, type JobEvent, type JobKind, type JobRegistry, type JobSpec, type JobStartOptions, type JobState, type JobStatus, type JobTransport, type LongTermMemory, type LongTermStore, MemoryArtifactStore, MemoryJobRegistry, MemoryMessageStore, MemoryScratchPad, MemorySessionStore, MemorySummaryDAG, MemoryTranscriptStore, MemoryVectorIndex, type MessageStore, ModelFactory, type OodaSnapshot, type OrchestratorContext, PermissionManager, type PermissionMode, type PermissionRequest, type PermissionResolver, type ProcessProfile, type ProfileDeclaration, type PushResult, REQUEST_MORE_STEPS_INCREMENT, type ReadEpisodeArgs, type ReadEpisodeDetail, ReadOptions, type RunWorkerConfig, type ScratchPad, type SessionMemo, type SessionMemoStore, type SessionMeta, type SessionSnapshot, type SessionStore, type StoredAttachment, type StoredMessage, type SummaryDAG, type SummaryNode, type Tool, type ToolExecutionMode, ToolProvider, ToolProviderCapabilities, ToolResult, ToolResultArtifact, type TraceToolCall, type Transcript, type TranscriptStore, type Tuple, type VectorIndex, type WorkerProgressEvent, type WorkerResult, cloneForTrace, formatDispatchForPrompt, resilience };

package/dist/arc/index.js

@@ -2141,6 +2141,73 @@ var MemorySessionStore = class {
     return [...this.metas.values()].sort((a, b) => b.lastActiveAt - a.lastActiveAt);
   }
 };
+var InMemoryEpisodeStore = class {
+  episodes = /* @__PURE__ */ new Map();
+  traces = /* @__PURE__ */ new Map();
+  async addEpisode(episode) {
+    this.episodes.set(episode.id, episode);
+  }
+  async addTrace(trace) {
+    this.traces.set(trace.episodeId, trace);
+  }
+  async getEpisode(id) {
+    return this.episodes.get(id) ?? null;
+  }
+  async getTrace(episodeId) {
+    return this.traces.get(episodeId) ?? null;
+  }
+  async getEpisodesByTask(taskId) {
+    return [...this.episodes.values()].filter((e) => e.taskId === taskId);
+  }
+  async getEpisodesBySession(sessionId) {
+    return [...this.episodes.values()].filter((e) => e.sessionId === sessionId);
+  }
+  async getRecentEpisodes(limit) {
+    return [...this.episodes.values()].sort((a, b) => b.createdAt - a.createdAt).slice(0, limit);
+  }
+  async evictTraces(_olderThan) {
+    return 0;
+  }
+};
+var InMemorySessionMemoStore = class {
+  memos = /* @__PURE__ */ new Map();
+  async addMemo(memo) {
+    this.memos.set(memo.id, memo);
+  }
+  async getMemo(id) {
+    return this.memos.get(id) ?? null;
+  }
+  async getMemosBySession(sessionId) {
+    return [...this.memos.values()].filter((m) => m.sessionId === sessionId);
+  }
+  async getRecentMemos(limit) {
+    return [...this.memos.values()].sort((a, b) => b.createdAt - a.createdAt).slice(0, limit);
+  }
+};
+var InMemoryLongTermStore = class {
+  memories = /* @__PURE__ */ new Map();
+  async addMemory(memory) {
+    this.memories.set(memory.id, memory);
+  }
+  async getMemory(id) {
+    return this.memories.get(id) ?? null;
+  }
+  async getAllMemories() {
+    return [...this.memories.values()];
+  }
+  async getMemoriesByCategory(category) {
+    return [...this.memories.values()].filter((m) => m.category === category);
+  }
+  async updateMemory(id, updates) {
+    const existing = this.memories.get(id);
+    if (existing) {
+      this.memories.set(id, { ...existing, ...updates });
+    }
+  }
+  async deleteMemory(id) {
+    this.memories.delete(id);
+  }
+};
 
 // src/arc/jobs/memory-job-registry.js
 var MemoryJobRegistry = class {
@@ -5067,6 +5134,259 @@ var FsArtifactStore = class {
   }
 };
 
-export { ABSOLUTE_MAX_WORKER_STEPS, ArcLoop, DEFAULT_MAX_STEPS_PER_WORKER, DEFAULT_WORKER_STEP_BUDGETS, FsArtifactStore, FsTranscriptStore, HarnessTelemetry, HookRunner, MemoryArtifactStore, MemoryJobRegistry, MemoryMessageStore, MemoryScratchPad, MemorySessionStore, MemorySummaryDAG, MemoryTranscriptStore, MemoryVectorIndex, REQUEST_MORE_STEPS_INCREMENT, cloneForTrace, formatDispatchForPrompt };
+// src/arc/composite-tool-provider.ts
+var CompositeToolProvider = class {
+  providers;
+  constructor(providers) {
+    this.providers = providers;
+  }
+  capabilities() {
+    return this.providers.reduce(
+      (acc, p) => {
+        const c = p.capabilities();
+        return {
+          bash: acc.bash || c.bash,
+          fileSystem: acc.fileSystem || c.fileSystem,
+          webFetch: acc.webFetch || c.webFetch,
+          webSearch: acc.webSearch || c.webSearch,
+          codeExecution: acc.codeExecution || c.codeExecution,
+          sandboxed: acc.sandboxed || c.sandboxed
+        };
+      },
+      {
+        bash: false,
+        fileSystem: false,
+        webFetch: false,
+        webSearch: false,
+        codeExecution: false,
+        sandboxed: false
+      }
+    );
+  }
+  /** Pick the first provider that supports the requested capability. */
+  pick(capability) {
+    const provider = this.providers.find((p) => p.capabilities()[capability]);
+    if (!provider) {
+      throw new Error(`No provider supports capability: ${capability}`);
+    }
+    return provider;
+  }
+  async bash(command, options) {
+    return this.pick("bash").bash(command, options);
+  }
+  async readFile(path2, options) {
+    return this.pick("fileSystem").readFile(path2, options);
+  }
+  async writeFile(path2, content) {
+    return this.pick("fileSystem").writeFile(path2, content);
+  }
+  async editFile(path2, oldText, newText) {
+    return this.pick("fileSystem").editFile(path2, oldText, newText);
+  }
+  async glob(pattern, options) {
+    return this.pick("fileSystem").glob(pattern, options);
+  }
+  async grep(pattern, path2, options) {
+    return this.pick("fileSystem").grep(pattern, path2, options);
+  }
+};
+
+// src/arc/e2b-tool-provider.ts
+var E2BToolProvider = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  capabilities() {
+    return {
+      bash: true,
+      fileSystem: true,
+      webFetch: false,
+      webSearch: false,
+      codeExecution: true,
+      sandboxed: true
+    };
+  }
+  async bash(command, options) {
+    return this.executor.bash(command, options);
+  }
+  async readFile(path2, options) {
+    return this.executor.readFile(path2, options);
+  }
+  async writeFile(path2, content) {
+    return this.executor.writeFile(path2, content);
+  }
+  async editFile(path2, oldText, newText) {
+    return this.executor.editFile(path2, oldText, newText);
+  }
+  async glob(pattern, options) {
+    return this.executor.glob(pattern, options);
+  }
+  async grep(pattern, path2, options) {
+    return this.executor.grep(pattern, path2, options);
+  }
+};
+
+// src/arc/control-plane-e2b-executor.ts
+var ControlPlaneE2BExecutor = class {
+  baseUrl;
+  apiKey;
+  templateId;
+  constructor(options) {
+    this.baseUrl = options.baseUrl;
+    this.apiKey = options.apiKey;
+    this.templateId = options.templateId ?? "polyglot-v1";
+  }
+  async bash(_command, _options) {
+    throw new Error(
+      "ControlPlaneE2BExecutor.bash() not implemented \u2014 use a concrete subclass"
+    );
+  }
+  async readFile(_path, _options) {
+    throw new Error("ControlPlaneE2BExecutor.readFile() not implemented");
+  }
+  async writeFile(_path, _content) {
+    throw new Error("ControlPlaneE2BExecutor.writeFile() not implemented");
+  }
+  async editFile(_path, _oldText, _newText) {
+    throw new Error("ControlPlaneE2BExecutor.editFile() not implemented");
+  }
+  async glob(_pattern, _options) {
+    throw new Error("ControlPlaneE2BExecutor.glob() not implemented");
+  }
+  async grep(_pattern, _path, _options) {
+    throw new Error("ControlPlaneE2BExecutor.grep() not implemented");
+  }
+  async writeFileBytes(_path, _data) {
+    throw new Error("ControlPlaneE2BExecutor.writeFileBytes() not implemented");
+  }
+  async readFileBytes(_path) {
+    throw new Error("ControlPlaneE2BExecutor.readFileBytes() not implemented");
+  }
+  get activeSandboxId() {
+    return void 0;
+  }
+  async destroy() {
+  }
+};
+
+// src/arc/permission-manager.ts
+var PermissionManager = class {
+  mode;
+  resolver;
+  constructor(mode, resolver) {
+    this.mode = mode;
+    this.resolver = resolver;
+  }
+  /** Check whether a tool call is permitted. */
+  async canExecute(request) {
+    switch (this.mode) {
+      case "deny_all":
+        return false;
+      case "allow_all":
+        return true;
+      case "ask":
+        if (this.resolver) {
+          return this.resolver(request);
+        }
+        return false;
+      default:
+        return false;
+    }
+  }
+};
+
+// src/arc/resilience.ts
+var ResiliencePipeline = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /** Set a timeout in milliseconds for execution. */
+  timeout(ms) {
+    this.options.timeout = ms;
+    return this;
+  }
+  /** Set retry count. */
+  retries(count) {
+    this.options.retryCount = count;
+    return this;
+  }
+  /** Build the executable pipeline. */
+  build() {
+    const { timeout: timeoutMs, retryCount = 0 } = this.options;
+    return {
+      execute: async (fn, ctx) => {
+        let lastError;
+        for (let attempt = 0; attempt <= retryCount; attempt++) {
+          if (ctx.signal.aborted) {
+            throw ctx.signal.reason ?? new DOMException("Aborted", "AbortError");
+          }
+          try {
+            if (timeoutMs) {
+              const result = await raceWithTimeout(
+                fn(),
+                timeoutMs,
+                ctx.signal
+              );
+              return result;
+            }
+            return await fn();
+          } catch (err2) {
+            lastError = err2 instanceof Error ? err2 : new Error(String(err2));
+            if (attempt === retryCount) {
+              throw lastError;
+            }
+            const delay = Math.min(4e3, 500 * Math.pow(2, attempt));
+            await sleep2(delay, ctx.signal);
+          }
+        }
+        throw lastError ?? new Error("Pipeline failed");
+      }
+    };
+  }
+};
+function resilience() {
+  return new ResiliencePipeline();
+}
+async function raceWithTimeout(promise, timeoutMs, signal) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(
+          signal.reason ?? new DOMException("Aborted", "AbortError")
+        );
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    })
+  ]);
+}
+function sleep2(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(
+        signal.reason ?? new DOMException("Aborted", "AbortError")
+      );
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(
+        signal.reason ?? new DOMException("Aborted", "AbortError")
+      );
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+export { ABSOLUTE_MAX_WORKER_STEPS, ArcLoop, CompositeToolProvider, ControlPlaneE2BExecutor, DEFAULT_MAX_STEPS_PER_WORKER, DEFAULT_WORKER_STEP_BUDGETS, E2BToolProvider, FsArtifactStore, FsTranscriptStore, HarnessTelemetry, HookRunner, InMemoryEpisodeStore, InMemoryLongTermStore, InMemorySessionMemoStore, MemoryArtifactStore, MemoryJobRegistry, MemoryMessageStore, MemoryScratchPad, MemorySessionStore, MemorySummaryDAG, MemoryTranscriptStore, MemoryVectorIndex, PermissionManager, REQUEST_MORE_STEPS_INCREMENT, cloneForTrace, formatDispatchForPrompt, resilience };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map