@agentfield/sdk 0.1.44 → 0.1.45-rc.2

package/dist/index.js

@@ -1,3 +1,7 @@
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+import { spawn } from 'child_process';
 import express from 'express';
 import rateLimit from 'express-rate-limit';
 import crypto2, { randomUUID, createHash } from 'crypto';
@@ -19,7 +23,807 @@ import WebSocket from 'ws';
 import { Buffer as Buffer$1 } from 'buffer';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 
-// src/agent/Agent.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function getZodConverter() {
+  if (zodConverter !== void 0) {
+    return zodConverter;
+  }
+  try {
+    const require2 = createRequire(import.meta.url);
+    const mod = require2("zod-to-json-schema");
+    zodConverter = mod.zodToJsonSchema ?? mod.default ?? null;
+  } catch {
+    zodConverter = null;
+  }
+  return zodConverter;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasJsonSchema(value) {
+  return isRecord(value) && typeof value.jsonSchema === "function";
+}
+function hasParse(value) {
+  return isRecord(value) && typeof value.parse === "function";
+}
+function estimateTokens(text) {
+  return Math.floor(text.length / 4);
+}
+function writeSchemaFile(schemaJson, cwd) {
+  const filePath = getSchemaPath(cwd);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const fd = fs.openSync(filePath, "w", 384);
+  try {
+    fs.writeFileSync(fd, schemaJson, "utf8");
+  } finally {
+    fs.closeSync(fd);
+  }
+  return filePath;
+}
+function validateAgainstSchema(data, schema) {
+  if (hasParse(schema)) {
+    return schema.parse(data);
+  }
+  return data;
+}
+function getOutputPath(cwd) {
+  return path.join(cwd, OUTPUT_FILENAME);
+}
+function getSchemaPath(cwd) {
+  return path.join(cwd, SCHEMA_FILENAME);
+}
+function schemaToJsonSchema(schema) {
+  if (isRecord(schema)) {
+    if ("type" in schema || "properties" in schema || "$schema" in schema) {
+      return schema;
+    }
+    if (hasJsonSchema(schema)) {
+      return schema.jsonSchema();
+    }
+  }
+  const converter = getZodConverter();
+  if (converter !== null) {
+    return converter(schema);
+  }
+  throw new TypeError("Unsupported schema type. Expected a Zod schema, JSON schema object, or jsonSchema() provider.");
+}
+function isLargeSchema(schemaJson) {
+  return estimateTokens(schemaJson) > LARGE_SCHEMA_TOKEN_THRESHOLD;
+}
+function buildPromptSuffix(schema, cwd) {
+  const jsonSchema = schemaToJsonSchema(schema);
+  const schemaJson = JSON.stringify(jsonSchema, null, 2);
+  const outputPath = getOutputPath(cwd);
+  if (isLargeSchema(schemaJson)) {
+    const schemaPath = writeSchemaFile(schemaJson, cwd);
+    return `
+
+---
+OUTPUT REQUIREMENTS:
+Read the JSON Schema at: ${schemaPath}
+Write your final answer as valid JSON conforming to that schema to: ${outputPath}
+Do not include any text outside the JSON in that file. Do not wrap in markdown fences.`;
+  }
+  return `
+
+---
+OUTPUT REQUIREMENTS:
+Write your final answer as valid JSON to the file: ${outputPath}
+The JSON must conform to this schema:
+${schemaJson}
+Do not include any text outside the JSON in that file. Do not wrap in markdown fences.`;
+}
+function cosmeticRepair(raw) {
+  let text = raw.trim();
+  const fenceMatch = text.match(/^```(?:json)?\s*\n([\s\S]*?)```\s*$/);
+  if (fenceMatch) {
+    text = fenceMatch[1].trim();
+  }
+  if (text.length > 0 && text[0] !== "{" && text[0] !== "[") {
+    const firstJsonCharIndex = [...text].findIndex((char) => char === "{" || char === "[");
+    if (firstJsonCharIndex >= 0) {
+      text = text.slice(firstJsonCharIndex);
+    }
+  }
+  text = text.replace(/,\s*([}\]])/g, "$1");
+  const openBraces = (text.match(/{/g)?.length ?? 0) - (text.match(/}/g)?.length ?? 0);
+  const openBrackets = (text.match(/\[/g)?.length ?? 0) - (text.match(/\]/g)?.length ?? 0);
+  if (openBraces > 0 || openBrackets > 0) {
+    text += "]".repeat(openBrackets) + "}".repeat(openBraces);
+  }
+  return text;
+}
+function readAndParse(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    if (content.trim().length === 0) {
+      return null;
+    }
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function readRepairAndParse(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    if (content.trim().length === 0) {
+      return null;
+    }
+    return JSON.parse(cosmeticRepair(content));
+  } catch {
+    return null;
+  }
+}
+function parseAndValidate(filePath, schema) {
+  const parsed = readAndParse(filePath);
+  if (parsed !== null) {
+    try {
+      return validateAgainstSchema(parsed, schema);
+    } catch {
+    }
+  }
+  const repaired = readRepairAndParse(filePath);
+  if (repaired !== null) {
+    try {
+      return validateAgainstSchema(repaired, schema);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function cleanupTempFiles(cwd) {
+  for (const filename of [OUTPUT_FILENAME, SCHEMA_FILENAME]) {
+    try {
+      fs.unlinkSync(path.join(cwd, filename));
+    } catch {
+    }
+  }
+}
+var OUTPUT_FILENAME, SCHEMA_FILENAME, LARGE_SCHEMA_TOKEN_THRESHOLD, zodConverter;
+var init_schema = __esm({
+  "src/harness/schema.ts"() {
+    OUTPUT_FILENAME = ".agentfield_output.json";
+    SCHEMA_FILENAME = ".agentfield_schema.json";
+    LARGE_SCHEMA_TOKEN_THRESHOLD = 4e3;
+  }
+});
+
+// src/harness/types.ts
+function createHarnessResult(partial) {
+  const r = {
+    isError: false,
+    numTurns: 0,
+    durationMs: 0,
+    sessionId: "",
+    messages: [],
+    ...partial,
+    get text() {
+      return this.result ?? "";
+    }
+  };
+  return r;
+}
+function createMetrics(partial) {
+  return { durationMs: 0, durationApiMs: 0, numTurns: 0, sessionId: "", ...partial };
+}
+function createRawResult(partial) {
+  return { messages: [], metrics: createMetrics(), isError: false, ...partial };
+}
+var init_types = __esm({
+  "src/harness/types.ts"() {
+  }
+});
+
+// src/harness/providers/claude.ts
+var claude_exports = {};
+__export(claude_exports, {
+  ClaudeCodeProvider: () => ClaudeCodeProvider
+});
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function getString(record, key) {
+  const value = record[key];
+  return typeof value === "string" ? value : void 0;
+}
+function getNumber(record, key) {
+  const value = record[key];
+  return typeof value === "number" ? value : void 0;
+}
+var ClaudeCodeProvider;
+var init_claude = __esm({
+  "src/harness/providers/claude.ts"() {
+    init_types();
+    ClaudeCodeProvider = class {
+      async execute(prompt, options) {
+        let sdk;
+        try {
+          const mod = await import('@anthropic-ai/claude-agent-sdk');
+          sdk = mod;
+        } catch {
+          throw new Error(
+            "@anthropic-ai/claude-agent-sdk is required for the 'claude-code' provider. Install it with: npm install @anthropic-ai/claude-agent-sdk"
+          );
+        }
+        const agentOptions = {};
+        if (options.model !== void 0) agentOptions.model = options.model;
+        if (options.cwd !== void 0) agentOptions.cwd = options.cwd;
+        if (options.maxTurns !== void 0) agentOptions.max_turns = options.maxTurns;
+        if (options.tools !== void 0) agentOptions.allowed_tools = options.tools;
+        if (options.systemPrompt !== void 0) agentOptions.system_prompt = options.systemPrompt;
+        if (options.maxBudgetUsd !== void 0) agentOptions.max_budget_usd = options.maxBudgetUsd;
+        if (options.permissionMode !== void 0) {
+          const modeMap = { auto: "bypassPermissions", plan: "plan" };
+          const raw = String(options.permissionMode);
+          agentOptions.permission_mode = modeMap[raw] ?? raw;
+        }
+        if (options.env !== void 0) agentOptions.env = options.env;
+        const messages = [];
+        let resultText;
+        let totalCost;
+        let numTurns = 0;
+        let sessionId = "";
+        const startApi = Date.now();
+        try {
+          for await (const msg of sdk.query({ prompt, options: agentOptions })) {
+            const msgObj = isRecord2(msg) ? msg : { raw: String(msg) };
+            messages.push(msgObj);
+            const msgType = getString(msgObj, "type") ?? "";
+            if (msgType === "result") {
+              const resultValue = msgObj.result ?? msgObj.text;
+              resultText = typeof resultValue === "string" ? resultValue : resultValue == null ? "" : String(resultValue);
+              const sid = getString(msgObj, "session_id");
+              if (sid !== void 0) {
+                sessionId = sid;
+              }
+              const costUsd = getNumber(msgObj, "cost_usd");
+              const totalCostUsd = getNumber(msgObj, "total_cost_usd");
+              if (costUsd !== void 0) {
+                totalCost = costUsd;
+              } else if (totalCostUsd !== void 0) {
+                totalCost = totalCostUsd;
+              }
+              const turns = getNumber(msgObj, "num_turns");
+              numTurns = turns === void 0 ? messages.length : Math.trunc(turns);
+            } else if (msgType === "assistant" && resultText === void 0) {
+              let content = msgObj.content;
+              if (content === void 0 && isRecord2(msgObj.message)) {
+                content = msgObj.message.content;
+              }
+              if (typeof content === "string") {
+                resultText = content;
+              } else if (Array.isArray(content)) {
+                for (const block of content) {
+                  if (isRecord2(block) && block.type === "text" && typeof block.text === "string") {
+                    resultText = block.text;
+                  }
+                }
+              }
+            }
+          }
+          return createRawResult({
+            result: resultText,
+            messages,
+            metrics: createMetrics({
+              durationApiMs: Date.now() - startApi,
+              numTurns,
+              totalCostUsd: totalCost,
+              sessionId
+            }),
+            isError: false
+          });
+        } catch (error) {
+          return createRawResult({
+            result: void 0,
+            messages,
+            metrics: createMetrics({ durationApiMs: Date.now() - startApi, sessionId }),
+            isError: true,
+            errorMessage: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    };
+  }
+});
+function runCli(cmd, options) {
+  return new Promise((resolve, reject) => {
+    const [bin, ...args] = cmd;
+    const proc = spawn(bin, args, {
+      env: { ...process.env, ...options?.env },
+      cwd: options?.cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    const timer = options?.timeout ? setTimeout(() => {
+      proc.kill();
+      reject(new Error(`CLI timed out after ${options.timeout}ms`));
+    }, options.timeout) : void 0;
+    proc.on("close", (code) => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      resolve({ stdout, stderr, exitCode: code ?? 0 });
+    });
+    proc.on("error", (err) => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      reject(err);
+    });
+  });
+}
+function parseJsonl(text) {
+  const events = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      events.push(JSON.parse(trimmed));
+    } catch {
+      continue;
+    }
+  }
+  return events;
+}
+function extractFinalText(events) {
+  let result;
+  for (const event of events) {
+    const type = event.type;
+    if (type === "item.completed") {
+      const item = event.item;
+      if (typeof item === "object" && item !== null) {
+        const itemType = item.type;
+        const itemText = item.text;
+        if (itemType === "agent_message" && typeof itemText === "string") {
+          result = itemText;
+        }
+      }
+    } else if (type === "result") {
+      const candidate = event.result ?? event.text;
+      if (typeof candidate === "string") {
+        result = candidate;
+      }
+    } else if (type === "turn.completed" && typeof event.text === "string") {
+      result = event.text;
+    } else if ((type === "message" || type === "assistant") && typeof event.content === "string") {
+      result = event.content;
+    }
+  }
+  return result;
+}
+var init_cli = __esm({
+  "src/harness/cli.ts"() {
+  }
+});
+
+// src/harness/providers/codex.ts
+var codex_exports = {};
+__export(codex_exports, {
+  CodexProvider: () => CodexProvider
+});
+var CodexProvider;
+var init_codex = __esm({
+  "src/harness/providers/codex.ts"() {
+    init_types();
+    init_cli();
+    CodexProvider = class {
+      bin;
+      constructor(binPath = "codex") {
+        this.bin = binPath;
+      }
+      async execute(prompt, options) {
+        const cmd = [this.bin, "exec", "--json"];
+        if (options.cwd) {
+          cmd.push("-C", String(options.cwd));
+        }
+        if (options.permissionMode === "auto") {
+          cmd.push("--full-auto");
+        }
+        cmd.push(prompt);
+        const startApi = Date.now();
+        try {
+          const { stdout, stderr, exitCode } = await runCli(cmd, {
+            env: options.env,
+            cwd: options.cwd
+          });
+          const events = parseJsonl(stdout);
+          const resultText = extractFinalText(events);
+          let numTurns = 0;
+          let sessionId = "";
+          for (const event of events) {
+            if (event.type === "turn.completed") {
+              numTurns += 1;
+            }
+            if (event.type === "thread.started") {
+              const threadId = event.thread_id;
+              if (typeof threadId === "string") {
+                sessionId = threadId;
+              }
+            }
+          }
+          const isError = exitCode !== 0 && !resultText;
+          return createRawResult({
+            result: resultText,
+            messages: events,
+            metrics: createMetrics({ durationApiMs: Date.now() - startApi, numTurns, sessionId }),
+            isError,
+            errorMessage: isError ? stderr.trim() : void 0
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (msg.includes("ENOENT")) {
+            return createRawResult({
+              isError: true,
+              errorMessage: `Codex binary not found at '${this.bin}'. Install: https://github.com/openai/codex`,
+              metrics: createMetrics({ durationApiMs: Date.now() - startApi })
+            });
+          }
+          return createRawResult({
+            isError: true,
+            errorMessage: msg,
+            metrics: createMetrics({ durationApiMs: Date.now() - startApi })
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/harness/providers/gemini.ts
+var gemini_exports = {};
+__export(gemini_exports, {
+  GeminiProvider: () => GeminiProvider
+});
+var GeminiProvider;
+var init_gemini = __esm({
+  "src/harness/providers/gemini.ts"() {
+    init_types();
+    init_cli();
+    GeminiProvider = class {
+      bin;
+      constructor(binPath = "gemini") {
+        this.bin = binPath;
+      }
+      async execute(prompt, options) {
+        const cmd = [this.bin];
+        if (options.cwd) {
+          cmd.push("-C", String(options.cwd));
+        }
+        if (options.permissionMode === "auto") {
+          cmd.push("--sandbox");
+        }
+        if (options.model) {
+          cmd.push("-m", String(options.model));
+        }
+        cmd.push("-p", prompt);
+        const startApi = Date.now();
+        try {
+          const { stdout, stderr, exitCode } = await runCli(cmd, {
+            env: options.env,
+            cwd: options.cwd
+          });
+          const resultText = stdout.trim() || void 0;
+          const isError = exitCode !== 0 && !resultText;
+          return createRawResult({
+            result: resultText,
+            messages: [],
+            metrics: createMetrics({
+              durationApiMs: Date.now() - startApi,
+              numTurns: resultText ? 1 : 0,
+              sessionId: ""
+            }),
+            isError,
+            errorMessage: isError ? stderr.trim() : void 0
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (msg.includes("ENOENT")) {
+            return createRawResult({
+              isError: true,
+              errorMessage: `Gemini binary not found at '${this.bin}'. Install: https://github.com/google-gemini/gemini-cli`,
+              metrics: createMetrics({ durationApiMs: Date.now() - startApi })
+            });
+          }
+          return createRawResult({
+            isError: true,
+            errorMessage: msg,
+            metrics: createMetrics({ durationApiMs: Date.now() - startApi })
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/harness/providers/opencode.ts
+var opencode_exports = {};
+__export(opencode_exports, {
+  OpenCodeProvider: () => OpenCodeProvider
+});
+var OpenCodeProvider;
+var init_opencode = __esm({
+  "src/harness/providers/opencode.ts"() {
+    init_types();
+    init_cli();
+    OpenCodeProvider = class {
+      bin;
+      constructor(binPath = "opencode") {
+        this.bin = binPath;
+      }
+      async execute(prompt, options) {
+        const cmd = [this.bin, "run"];
+        if (options.model) {
+          cmd.push("--model", String(options.model));
+        }
+        cmd.push(prompt);
+        const startApi = Date.now();
+        try {
+          const { stdout, stderr, exitCode } = await runCli(cmd, {
+            env: options.env,
+            cwd: options.cwd
+          });
+          const resultText = stdout.trim() || void 0;
+          const isError = exitCode !== 0 && !resultText;
+          return createRawResult({
+            result: resultText,
+            messages: [],
+            metrics: createMetrics({
+              durationApiMs: Date.now() - startApi,
+              numTurns: resultText ? 1 : 0,
+              sessionId: ""
+            }),
+            isError,
+            errorMessage: isError ? stderr.trim() : void 0
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (msg.includes("ENOENT")) {
+            return createRawResult({
+              isError: true,
+              errorMessage: `OpenCode binary not found at '${this.bin}'. Install: https://github.com/opencode-ai/opencode`,
+              metrics: createMetrics({ durationApiMs: Date.now() - startApi })
+            });
+          }
+          return createRawResult({
+            isError: true,
+            errorMessage: msg,
+            metrics: createMetrics({ durationApiMs: Date.now() - startApi })
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/harness/providers/factory.ts
+async function buildProvider(config) {
+  if (!SUPPORTED_PROVIDERS.has(config.provider)) {
+    throw new Error(
+      `Unknown harness provider: "${config.provider}". Supported: ${[...SUPPORTED_PROVIDERS].sort().join(", ")}`
+    );
+  }
+  if (config.provider === "claude-code") {
+    const { ClaudeCodeProvider: ClaudeCodeProvider2 } = await Promise.resolve().then(() => (init_claude(), claude_exports));
+    return new ClaudeCodeProvider2();
+  }
+  if (config.provider === "codex") {
+    const { CodexProvider: CodexProvider2 } = await Promise.resolve().then(() => (init_codex(), codex_exports));
+    return new CodexProvider2(config.codexBin ?? "codex");
+  }
+  if (config.provider === "gemini") {
+    const { GeminiProvider: GeminiProvider2 } = await Promise.resolve().then(() => (init_gemini(), gemini_exports));
+    return new GeminiProvider2(config.geminiBin ?? "gemini");
+  }
+  if (config.provider === "opencode") {
+    const { OpenCodeProvider: OpenCodeProvider2 } = await Promise.resolve().then(() => (init_opencode(), opencode_exports));
+    return new OpenCodeProvider2(config.opencodeBin ?? "opencode");
+  }
+  throw new Error(`Provider "${config.provider}" is not yet implemented.`);
+}
+var SUPPORTED_PROVIDERS;
+var init_factory = __esm({
+  "src/harness/providers/factory.ts"() {
+    SUPPORTED_PROVIDERS = /* @__PURE__ */ new Set(["claude-code", "codex", "gemini", "opencode"]);
+  }
+});
+
+// src/harness/runner.ts
+var runner_exports = {};
+__export(runner_exports, {
+  HarnessRunner: () => HarnessRunner
+});
+var TRANSIENT_PATTERNS, HarnessRunner;
+var init_runner = __esm({
+  "src/harness/runner.ts"() {
+    init_schema();
+    init_factory();
+    init_types();
+    TRANSIENT_PATTERNS = [
+      "rate limit",
+      "rate_limit",
+      "overloaded",
+      "timeout",
+      "timed out",
+      "connection reset",
+      "connection refused",
+      "temporarily unavailable",
+      "service unavailable",
+      "503",
+      "502",
+      "504",
+      "internal server error",
+      "500"
+    ];
+    HarnessRunner = class {
+      constructor(config) {
+        this.config = config;
+      }
+      async run(prompt, options = {}) {
+        const { schema, ...rest } = options;
+        const resolved = this.resolveOptions(this.config, rest);
+        if (!resolved.provider) {
+          throw new Error("No harness provider specified. Set 'provider' in HarnessConfig or pass it to .harness() call.");
+        }
+        const cwd = resolved.cwd ?? ".";
+        const provider = await this.buildProvider(resolved.provider, resolved);
+        const effectivePrompt = schema === void 0 ? prompt : `${prompt}${buildPromptSuffix(schema, cwd)}`;
+        const startTime = Date.now();
+        try {
+          const raw = await this.executeWithRetry(provider, effectivePrompt, resolved);
+          if (schema !== void 0) {
+            return this.handleSchemaOutput(raw, schema, cwd, startTime);
+          }
+          return createHarnessResult({
+            result: raw.result,
+            isError: raw.isError,
+            errorMessage: raw.errorMessage,
+            costUsd: raw.metrics.totalCostUsd,
+            numTurns: raw.metrics.numTurns,
+            durationMs: Date.now() - startTime,
+            sessionId: raw.metrics.sessionId,
+            messages: raw.messages
+          });
+        } finally {
+          if (schema !== void 0) {
+            cleanupTempFiles(cwd);
+          }
+        }
+      }
+      resolveOptions(config, overrides) {
+        const out = {};
+        if (config) {
+          for (const key of [
+            "provider",
+            "model",
+            "maxTurns",
+            "maxBudgetUsd",
+            "maxRetries",
+            "initialDelay",
+            "maxDelay",
+            "backoffFactor",
+            "tools",
+            "permissionMode",
+            "systemPrompt",
+            "env",
+            "cwd",
+            "codexBin",
+            "geminiBin",
+            "opencodeBin"
+          ]) {
+            const value = config[key];
+            if (value !== void 0 && value !== null) {
+              out[key] = value;
+            }
+          }
+        }
+        for (const [key, value] of Object.entries(overrides)) {
+          if (value !== void 0 && value !== null) {
+            out[key] = value;
+          }
+        }
+        return out;
+      }
+      isTransient(errorStr) {
+        const lower = errorStr.toLowerCase();
+        return TRANSIENT_PATTERNS.some((pattern) => lower.includes(pattern));
+      }
+      async executeWithRetry(provider, prompt, options) {
+        const maxRetries = options.maxRetries ?? 3;
+        const initialDelay = options.initialDelay ?? 1;
+        const maxDelay = options.maxDelay ?? 30;
+        const backoffFactor = options.backoffFactor ?? 2;
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+          try {
+            const result = await provider.execute(prompt, options);
+            if (!result.isError) {
+              return result;
+            }
+            const message = result.errorMessage ?? "";
+            if (this.isTransient(message) && attempt < maxRetries) {
+              const delay = this.computeBackoffDelay(initialDelay, backoffFactor, maxDelay, attempt);
+              await this.sleep(delay);
+              continue;
+            }
+            return result;
+          } catch (error) {
+            lastError = error;
+            const message = error instanceof Error ? error.message : String(error);
+            if (this.isTransient(message) && attempt < maxRetries) {
+              const delay = this.computeBackoffDelay(initialDelay, backoffFactor, maxDelay, attempt);
+              await this.sleep(delay);
+              continue;
+            }
+            throw error;
+          }
+        }
+        if (lastError !== void 0) {
+          throw lastError;
+        }
+        return createRawResult({ isError: true, errorMessage: "Max retries exceeded" });
+      }
+      handleSchemaOutput(raw, schema, cwd, startTime) {
+        const outputPath = getOutputPath(cwd);
+        const parsed = parseAndValidate(outputPath, schema);
+        if (parsed !== null) {
+          return createHarnessResult({
+            result: raw.result,
+            parsed,
+            isError: false,
+            costUsd: raw.metrics.totalCostUsd,
+            numTurns: raw.metrics.numTurns,
+            durationMs: Date.now() - startTime,
+            sessionId: raw.metrics.sessionId,
+            messages: raw.messages
+          });
+        }
+        return createHarnessResult({
+          result: raw.result,
+          isError: true,
+          errorMessage: "Schema validation failed after parse and cosmetic repair attempts.",
+          costUsd: raw.metrics.totalCostUsd,
+          numTurns: raw.metrics.numTurns,
+          durationMs: Date.now() - startTime,
+          sessionId: raw.metrics.sessionId,
+          messages: raw.messages
+        });
+      }
+      async buildProvider(providerName, options) {
+        const { provider: _, ...rest } = options;
+        return buildProvider({ provider: providerName, ...rest });
+      }
+      computeBackoffDelay(initialDelay, backoffFactor, maxDelay, attempt) {
+        const base = Math.min(initialDelay * backoffFactor ** attempt, maxDelay);
+        const jitter = Math.random() * (base * 0.5) - base * 0.25;
+        return base + jitter;
+      }
+      sleep(delaySeconds) {
+        return new Promise((resolve) => {
+          setTimeout(resolve, Math.max(0, delaySeconds) * 1e3);
+        });
+      }
+    };
+  }
+});
 
 // src/agent/ReasonerRegistry.ts
 var ReasonerRegistry = class {
@@ -2226,6 +3030,7 @@ function evaluateConstraints(constraints, inputParams) {
 // src/agent/Agent.ts
 var TargetNotFoundError = class extends Error {
 };
+var harnessRunners = /* @__PURE__ */ new WeakMap();
 var Agent = class {
   config;
   app;
@@ -2330,6 +3135,18 @@ var Agent = class {
   getAIClient() {
     return this.aiClient;
   }
+  async getHarnessRunner() {
+    const cached = harnessRunners.get(this);
+    if (cached) return cached;
+    const { HarnessRunner: RunnerClass } = await Promise.resolve().then(() => (init_runner(), runner_exports));
+    const runner = new RunnerClass(this.config.harnessConfig);
+    harnessRunners.set(this, runner);
+    return runner;
+  }
+  async harness(prompt, options) {
+    const runner = await this.getHarnessRunner();
+    return runner.run(prompt, options ?? {});
+  }
   getMemoryInterface(metadata) {
     const defaultScope = this.config.memoryConfig?.defaultScope ?? "workflow";
     const defaultScopeId = defaultScope === "session" ? metadata?.sessionId : defaultScope === "actor" ? metadata?.actorId : metadata?.workflowId ?? metadata?.runId ?? metadata?.sessionId ?? metadata?.actorId;
@@ -2570,22 +3387,22 @@ var Agent = class {
         },
         message: { error: "rate_limit_exceeded", message: "Too many authentication attempts. Try again later." },
         skip: (req) => {
-          const path = req.path;
-          if (!path.startsWith("/reasoners/") && !path.startsWith("/skills/") && !path.startsWith("/execute") && !path.startsWith("/api/v1/reasoners/") && !path.startsWith("/api/v1/skills/")) {
+          const path2 = req.path;
+          if (!path2.startsWith("/reasoners/") && !path2.startsWith("/skills/") && !path2.startsWith("/execute") && !path2.startsWith("/api/v1/reasoners/") && !path2.startsWith("/api/v1/skills/")) {
             return true;
           }
-          const parts = path.replace(/^\/+/, "").split("/");
+          const parts = path2.replace(/^\/+/, "").split("/");
           const funcName = parts[parts.length - 1] ?? "";
           return realtimeFunctions.has(funcName);
         }
       });
       this.app.use(authRateLimiter);
       this.app.use(async (req, res, next) => {
-        const path = req.path;
-        if (!path.startsWith("/reasoners/") && !path.startsWith("/skills/") && !path.startsWith("/execute") && !path.startsWith("/api/v1/reasoners/") && !path.startsWith("/api/v1/skills/")) {
+        const path2 = req.path;
+        if (!path2.startsWith("/reasoners/") && !path2.startsWith("/skills/") && !path2.startsWith("/execute") && !path2.startsWith("/api/v1/reasoners/") && !path2.startsWith("/api/v1/skills/")) {
           return next();
         }
-        const parts = path.replace(/^\/+/, "").split("/");
+        const parts = path2.replace(/^\/+/, "").split("/");
         const funcName = parts[parts.length - 1] ?? "";
         if (realtimeFunctions.has(funcName)) {
           return next();
@@ -2772,9 +3589,9 @@ var Agent = class {
     return handler(req, res);
   }
   async handleServerlessEvent(event) {
-    const path = event?.path ?? event?.rawPath ?? "";
+    const path2 = event?.path ?? event?.rawPath ?? "";
     const action = event?.action ?? "";
-    if (path === "/discover" || action === "discover") {
+    if (path2 === "/discover" || action === "discover") {
       return {
         statusCode: 200,
         headers: { "content-type": "application/json" },
@@ -2783,7 +3600,7 @@ var Agent = class {
     }
     const body = this.normalizeEventBody(event);
     const invocation = this.extractInvocationDetails({
-      path,
+      path: path2,
       query: event?.queryStringParameters,
       body,
       reasoner: event?.reasoner,
@@ -2873,9 +3690,9 @@ var Agent = class {
     const input = this.normalizeInputPayload(params.body);
     return { name: name ?? void 0, targetType: typeValue, input };
   }
-  parsePathTarget(path) {
-    if (!path) return {};
-    const normalized = path.split("?")[0];
+  parsePathTarget(path2) {
+    if (!path2) return {};
+    const normalized = path2.split("?")[0];
     const reasonerMatch = normalized.match(/\/reasoners\/([^/]+)/);
     if (reasonerMatch?.[1]) {
       return { name: reasonerMatch[1], targetType: "reasoner" };
@@ -3221,6 +4038,11 @@ function sanitize(value) {
   return value.replace(/[^0-9a-zA-Z]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
 }
 
+// src/harness/index.ts
+init_types();
+init_factory();
+init_runner();
+
 // src/status/ExecutionStatus.ts
 var ExecutionStatus = {
   PENDING: "pending",
@@ -3380,6 +4202,6 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-export { ACTIVE_STATUSES, AIClient, Agent, AgentRouter, ApprovalClient, CANONICAL_STATUSES, DIDAuthenticator, DidClient, DidInterface, DidManager, ExecutionContext, ExecutionStatus, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, MCPClient, MCPClientRegistry, MCPToolRegistrar, MemoryClient, MemoryEventClient, MemoryInterface, RateLimitError, ReasonerContext, SkillContext, StatelessRateLimiter, TERMINAL_STATUSES, WorkflowReporter, getCurrentContext, getCurrentSkillContext, isActive, isTerminal, normalizeStatus };
+export { ACTIVE_STATUSES, AIClient, Agent, AgentRouter, ApprovalClient, CANONICAL_STATUSES, DIDAuthenticator, DidClient, DidInterface, DidManager, ExecutionContext, ExecutionStatus, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, HarnessRunner, MCPClient, MCPClientRegistry, MCPToolRegistrar, MemoryClient, MemoryEventClient, MemoryInterface, RateLimitError, ReasonerContext, SUPPORTED_PROVIDERS, SkillContext, StatelessRateLimiter, TERMINAL_STATUSES, WorkflowReporter, buildProvider, createHarnessResult, createMetrics, createRawResult, getCurrentContext, getCurrentSkillContext, isActive, isTerminal, normalizeStatus };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map