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

package/dist/arc/index.js

@@ -1,7 +1,8 @@
 import { tool, generateText, stepCountIs, streamText } from 'ai';
 import { anthropic } from '@ai-sdk/anthropic';
 import { z } from 'zod';
-import { createHash, randomUUID } from 'crypto';
+import { randomUUID, createHash } from 'crypto';
+import { AsyncLocalStorage } from 'async_hooks';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 
@@ -2140,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 {
@@ -4896,6 +4964,91 @@ function extractReasoningText(result) {
   }
   return "";
 }
+
+// src/hooks/hook-runner.ts
+var HookRunner = class {
+  hooks = /* @__PURE__ */ new Map();
+  register(event, callback) {
+    const list = this.hooks.get(event) ?? [];
+    list.push(callback);
+    this.hooks.set(event, list);
+  }
+  async run(context) {
+    const list = this.hooks.get(context.event) ?? [];
+    for (const hook of list) {
+      const result = await hook(context);
+      if (result && result.allow === false) {
+        return result;
+      }
+    }
+    return { allow: true };
+  }
+};
+var HarnessTelemetry = class {
+  constructor(enabled = true) {
+    this.enabled = enabled;
+  }
+  context = new AsyncLocalStorage();
+  spans = [];
+  metrics = [];
+  isEnabled() {
+    return this.enabled;
+  }
+  startSpan(name, attributes = {}) {
+    const now = Date.now();
+    const parent = this.context.getStore();
+    const traceId = parent?.traceId ?? randomUUID().replace(/-/g, "");
+    const spanId = randomUUID().replace(/-/g, "").slice(0, 16);
+    const record = {
+      traceId,
+      spanId,
+      parentSpanId: parent?.spanId,
+      name,
+      attributes: { ...attributes },
+      startTime: now,
+      endTime: now
+    };
+    this.spans.push(record);
+    return {
+      traceId,
+      spanId,
+      end: (extra = {}) => {
+        record.endTime = Date.now();
+        record.attributes = { ...record.attributes, ...extra };
+      }
+    };
+  }
+  async withSpan(name, attributes, fn) {
+    if (!this.enabled) {
+      return fn();
+    }
+    const span = this.startSpan(name, attributes);
+    return this.context.run({ traceId: span.traceId, spanId: span.spanId }, async () => {
+      try {
+        const result = await fn();
+        span.end({ success: true });
+        return result;
+      } catch (error) {
+        span.end({ success: false, error: error instanceof Error ? error.message : "unknown" });
+        throw error;
+      }
+    });
+  }
+  counter(name, value = 1, attributes = {}) {
+    if (!this.enabled) return;
+    this.metrics.push({ name, value, type: "counter", attributes });
+  }
+  histogram(name, value, attributes = {}) {
+    if (!this.enabled) return;
+    this.metrics.push({ name, value, type: "histogram", attributes });
+  }
+  getSpans() {
+    return [...this.spans];
+  }
+  getMetrics() {
+    return [...this.metrics];
+  }
+};
 var FsTranscriptStore = class {
   dir;
   indexPath;
@@ -4981,6 +5134,259 @@ var FsArtifactStore = class {
   }
 };
 
-export { ABSOLUTE_MAX_WORKER_STEPS, ArcLoop, DEFAULT_MAX_STEPS_PER_WORKER, DEFAULT_WORKER_STEP_BUDGETS, FsArtifactStore, FsTranscriptStore, 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