@agentfield/sdk 0.1.143-rc.3 → 0.1.143-rc.5

package/dist/index.js

@@ -1,15 +1,16 @@
-import fs2, { promises, readFileSync } from 'fs';
-import * as path5 from 'path';
-import path5__default, { resolve, dirname } from 'path';
+import http2 from 'http';
+import https2 from 'https';
+import crypto2, { randomUUID, createHash } from 'crypto';
+import fs, { promises, readFileSync } from 'fs';
+import os2, { constants } from 'os';
+import * as path from 'path';
+import path__default, { resolve, dirname } from 'path';
 import { spawn } from 'child_process';
-import os, { constants } from 'os';
+import { performance } from 'perf_hooks';
 import { createRequire } from 'module';
 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';
@@ -149,6 +150,184 @@ var init_openrouterAttribution = __esm({
     DEFAULT_OPENROUTER_CATEGORIES = "cli-agent,programming-app";
   }
 });
+function requestResponse(url) {
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new Error(`Unsupported CodeAF download protocol: ${url.protocol}`);
+  }
+  return new Promise((resolve3, reject) => {
+    const request = (url.protocol === "https:" ? https2 : http2).get(url, resolve3);
+    request.on("error", reject);
+    request.setTimeout(3e4, () => request.destroy(new Error("CodeAF download timed out")));
+  });
+}
+async function codeafDownloadResponse(url, redirects = 0) {
+  const response = await requestResponse(url);
+  if ([301, 302, 303, 307, 308].includes(response.statusCode ?? 0) && response.headers.location) {
+    response.resume();
+    if (redirects >= 5) throw new Error("Too many CodeAF download redirects");
+    return codeafDownloadResponse(new URL(response.headers.location, url), redirects + 1);
+  }
+  if (response.statusCode !== 200) {
+    response.resume();
+    throw new Error(`CodeAF download failed: HTTP ${response.statusCode}`);
+  }
+  return response;
+}
+var init_codeafDownload = __esm({
+  "src/harness/codeafDownload.ts"() {
+  }
+});
+
+// src/harness/codeafRelease.ts
+var CODEAF_VERSION, CODEAF_BASE_URL, CODEAF_MAX_DOWNLOAD_BYTES, CODEAF_SHA256;
+var init_codeafRelease = __esm({
+  "src/harness/codeafRelease.ts"() {
+    CODEAF_VERSION = "v0.8.2";
+    CODEAF_BASE_URL = `https://github.com/Agent-Field/CodeAF/releases/download/${CODEAF_VERSION}`;
+    CODEAF_MAX_DOWNLOAD_BYTES = 128 * 1024 * 1024;
+    CODEAF_SHA256 = Object.freeze({
+      "codeaf-darwin-amd64": "a476f1ce44b21f8016583a65c49b21497d10713bcd72c33478b3bd12e52446d7",
+      "codeaf-darwin-arm64": "e61adac060bf2345c08a3e23ae83239871c3050eadac046879f5f3176270c4f1",
+      "codeaf-linux-amd64": "681d9813f2517addc86fb644d313e3f7cf0ab60be708c8e8b13d77fb16a6798c",
+      "codeaf-linux-arm64": "c6375d58d198d9e1a84880d8b4324ee6c067a0e5e351af115ca5506b1ffa1c78",
+      "codeaf-windows-amd64.exe": "ff80f6f0c89c209fc809e960c70a1eb3518ccfc06775d587d5a187edd5d5222d",
+      "codeaf-windows-arm64.exe": "bfc0b386e5248e7e6756f097b372f72e4e955ee1e19e9216ccafee47064b2b80"
+    });
+  }
+});
+function agentfieldHome(env = process.env) {
+  return env.AGENTFIELD_HOME || path__default.join(os2.homedir(), ".agentfield");
+}
+function codeafStateHome(env) {
+  const preferred = path__default.join(agentfieldHome(env), "codeaf");
+  try {
+    fs.mkdirSync(preferred, { recursive: true });
+  } catch {
+  }
+  return preferred;
+}
+function codeafManagedPaths(env = process.env) {
+  const name = process.platform === "win32" ? "codeaf.exe" : "codeaf";
+  return [
+    path__default.join(agentfieldHome(env), "bin", name)
+  ];
+}
+function versionMarker(binary) {
+  return path__default.join(path__default.dirname(binary), ".codeaf.version");
+}
+function isCodeafInstalled(binary) {
+  try {
+    if (!fs.statSync(binary).isFile()) {
+      return false;
+    }
+    fs.accessSync(binary, process.platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
+    return fs.readFileSync(versionMarker(binary), "utf8").trim() === CODEAF_VERSION;
+  } catch {
+    return false;
+  }
+}
+function findManagedCodeaf(env = process.env) {
+  return codeafManagedPaths(env).find(isCodeafInstalled);
+}
+function isTruthy(value) {
+  return /^(1|true|yes|on)$/i.test(value?.trim() ?? "");
+}
+function skipCodeafInstall(env = process.env) {
+  return isTruthy(env.AGENTFIELD_SKIP_CODEAF) || isTruthy(env.AGENTFIELD_SKIP_AFORGE);
+}
+function codeafAsset(platform = process.platform, arch = process.arch) {
+  const releaseOS = platform === "win32" ? "windows" : platform;
+  const releaseArch = arch === "x64" ? "amd64" : arch;
+  const asset = `codeaf-${releaseOS}-${releaseArch}${platform === "win32" ? ".exe" : ""}`;
+  return Object.hasOwn(CODEAF_SHA256, asset) ? asset : void 0;
+}
+async function download(url, file, expectedHash) {
+  const response = await codeafDownloadResponse(url);
+  try {
+    if (Number(response.headers["content-length"]) > CODEAF_MAX_DOWNLOAD_BYTES) {
+      throw new Error("CodeAF download exceeds the 128 MiB size limit");
+    }
+    const hash = createHash("sha256");
+    let size = 0;
+    for await (const chunk of response) {
+      const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      size += data.length;
+      if (size > CODEAF_MAX_DOWNLOAD_BYTES) {
+        throw new Error("CodeAF download exceeds the 128 MiB size limit");
+      }
+      hash.update(data);
+      await file.writeFile(data);
+    }
+    if (hash.digest("hex") !== expectedHash) {
+      throw new Error("CodeAF download SHA-256 mismatch");
+    }
+  } finally {
+    response.destroy();
+  }
+}
+async function installCodeaf() {
+  const asset = codeafAsset();
+  if (!asset) {
+    throw new Error(`CodeAF is not installable on ${process.platform}/${process.arch}`);
+  }
+  if (process.env.HTTPS_PROXY || process.env.https_proxy) {
+    throw new Error("CodeAF download skipped: HTTPS_PROXY is set and the TypeScript SDK does not use proxies; run `af codeaf ensure`");
+  }
+  const [binary] = codeafManagedPaths();
+  const temporary = path__default.join(path__default.dirname(binary), `.codeaf-${randomUUID()}.tmp`);
+  let file;
+  try {
+    await fs.promises.mkdir(path__default.dirname(binary), { recursive: true });
+    file = await fs.promises.open(temporary, "wx", 384);
+  } catch (error) {
+    throw new Error(`cannot install CodeAF into ${path__default.dirname(binary)}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  console.info(`downloading CodeAF ${CODEAF_VERSION} (~70 MB) to ${binary}`);
+  try {
+    const base = (process.env.AGENTFIELD_CODEAF_BASE_URL || CODEAF_BASE_URL).replace(/\/+$/, "");
+    await download(new URL(`${base}/${asset}`), file, CODEAF_SHA256[asset]);
+    await file.chmod(493);
+    await file.close();
+    try {
+      await fs.promises.rename(temporary, binary);
+    } catch (error) {
+      if (process.platform === "win32" && isCodeafInstalled(binary)) {
+        return binary;
+      }
+      throw error;
+    }
+    await fs.promises.writeFile(versionMarker(binary), `${CODEAF_VERSION}
+`);
+    return binary;
+  } finally {
+    await file.close().catch(() => void 0);
+    await fs.promises.rm(temporary, { force: true });
+  }
+}
+async function ensureCodeafInstalled() {
+  const installed = findManagedCodeaf();
+  if (installed) {
+    return installed;
+  }
+  if (skipCodeafInstall()) {
+    return void 0;
+  }
+  if (installation) return installation;
+  if (Date.now() < nextInstallAttempt) return void 0;
+  nextInstallAttempt = Date.now() + 6e4;
+  installation = installCodeaf().finally(() => {
+    installation = void 0;
+  });
+  return installation;
+}
+var installation, nextInstallAttempt;
+var init_codeafInstall = __esm({
+  "src/harness/codeafInstall.ts"() {
+    init_codeafDownload();
+    init_codeafRelease();
+    nextInstallAttempt = 0;
+  }
+});
 
 // src/harness/availability.ts
 var availability_exports = {};
@@ -161,7 +340,7 @@ __export(availability_exports, {
   providerUnavailable: () => providerUnavailable
 });
 function executableExtensions(binary, env) {
-  if (process.platform !== "win32" || path5__default.extname(binary)) {
+  if (process.platform !== "win32" || path__default.extname(binary)) {
     return [""];
   }
   const pathExt = env.PATHEXT ?? env.PathExt ?? ".COM;.EXE;.BAT;.CMD";
@@ -169,10 +348,10 @@ function executableExtensions(binary, env) {
 }
 function isExecutableFile(candidate) {
   try {
-    if (!fs2.statSync(candidate).isFile()) {
+    if (!fs.statSync(candidate).isFile()) {
       return false;
     }
-    fs2.accessSync(candidate, process.platform === "win32" ? fs2.constants.F_OK : fs2.constants.X_OK);
+    fs.accessSync(candidate, process.platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -180,20 +359,20 @@ function isExecutableFile(candidate) {
 }
 function findExecutable(binary, env = process.env) {
   const extensions = executableExtensions(binary, env);
-  const hasPath = path5__default.isAbsolute(binary) || binary.includes("/") || binary.includes("\\");
-  const directories = hasPath ? [""] : (env.PATH ?? env.Path ?? env.path ?? "").split(path5__default.delimiter).filter(Boolean);
+  const hasPath = path__default.isAbsolute(binary) || binary.includes("/") || binary.includes("\\");
+  const directories = hasPath ? [""] : (env.PATH ?? env.Path ?? env.path ?? "").split(path__default.delimiter).filter(Boolean);
   for (const directory of directories) {
     for (const extension of extensions) {
-      const candidate = `${hasPath ? binary : path5__default.join(directory, binary)}${extension}`;
+      const candidate = `${hasPath ? binary : path__default.join(directory, binary)}${extension}`;
       if (isExecutableFile(candidate)) {
-        return path5__default.resolve(candidate);
+        return path__default.resolve(candidate);
       }
     }
   }
   return void 0;
 }
-function ensureCliAvailable(provider, binary, resolveBinary = findExecutable, env = process.env) {
-  const resolved = resolveBinary(binary, env);
+function ensureCliAvailable(provider, binary, resolveBinary2 = findExecutable, env = process.env) {
+  const resolved = resolveBinary2(binary, env);
   if (resolved) {
     return resolved;
   }
@@ -207,7 +386,7 @@ function providerUnavailable(provider, binary) {
   });
 }
 function isWindowsBatchFile(command) {
-  return process.platform === "win32" && WINDOWS_BATCH_EXTENSIONS.has(path5__default.extname(command).toLowerCase());
+  return process.platform === "win32" && WINDOWS_BATCH_EXTENSIONS.has(path__default.extname(command).toLowerCase());
 }
 function batchProbeInvocation(command) {
   const env = { ...process.env };
@@ -285,7 +464,7 @@ async function harnessDoctor(providers, options = {}) {
     );
   }
   const env = options.env ?? process.env;
-  const resolveBinary = options.resolveBinary ?? findExecutable;
+  const resolveBinary2 = options.resolveBinary ?? findExecutable;
   const versionProbe = options.versionProbe ?? defaultVersionProbe;
   const wrapperProbe = options.wrapperProbe ?? defaultWrapperProbe;
   const reports = [];
@@ -308,15 +487,23 @@ async function harnessDoctor(providers, options = {}) {
       continue;
     }
     const binaryName = spec.binary;
-    const binary = resolveBinary(binaryName, env) ?? null;
+    const legacyPin = provider === "aforge" ? env.AFORGE_BIN?.trim() : void 0;
+    const lookupCodeaf = provider === "codeaf" || provider === "aforge" && !legacyPin;
+    const override = lookupCodeaf ? env.CODEAF_BIN?.trim() : void 0;
+    const codeaf = lookupCodeaf ? override ? resolveBinary2(override, env) : findManagedCodeaf(env) ?? resolveBinary2("codeaf", env) : void 0;
+    const codeafAlias = provider === "aforge" && !!codeaf;
+    const binary = provider === "codeaf" || override ? codeaf ?? null : legacyPin ? resolveBinary2(legacyPin, env) ?? null : codeaf ?? resolveBinary2(binaryName, env) ?? null;
     const issues = [];
     let version = null;
     if (binary === null) {
       issues.push("binary_not_found");
     } else {
       try {
-        const output = (await versionProbe([binary, ...spec.versionArgs])).trim();
+        const output = (await versionProbe([binary, ...codeafAlias ? ["version"] : spec.versionArgs])).trim();
         version = output ? output.split(/\r?\n/, 1)[0] : "unknown";
+        if (provider === "codeaf") {
+          version = version.match(/^codeaf\s+(v\S+)/)?.[1] ?? version;
+        }
       } catch {
         issues.push("version_probe_failed");
       }
@@ -338,7 +525,14 @@ async function harnessDoctor(providers, options = {}) {
 var PROVIDER_SPECS, SUPPORTED_PROVIDER_NAMES, HarnessProviderUnavailable, WINDOWS_BATCH_EXTENSIONS, BATCH_PROBE_ENV_PREFIX;
 var init_availability = __esm({
   "src/harness/availability.ts"() {
+    init_codeafInstall();
     PROVIDER_SPECS = {
+      codeaf: {
+        binary: "codeaf",
+        versionArgs: ["version"],
+        installCommand: "af codeaf ensure",
+        authEnvVars: ["OPENROUTER_API_KEY"]
+      },
       aforge: {
         binary: "aforge",
         versionArgs: ["version"],
@@ -495,6 +689,7 @@ async function runCli(cmd, options) {
       stdio: [hasInput ? "pipe" : "ignore", "pipe", "pipe"]
     });
     if (hasInput) {
+      proc.stdin?.on("error", () => void 0);
       proc.stdin?.end(options.inputText);
     }
     let stdout = "";
@@ -565,9 +760,9 @@ async function runCli(cmd, options) {
     });
   });
 }
-function parseJsonl(text2) {
+function parseJsonl(text3) {
   const events = [];
-  for (const line of text2.split("\n")) {
+  for (const line of text3.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) {
       continue;
@@ -766,16 +961,22 @@ var init_aforge = __esm({
     };
     aforgeSemaphore = new Semaphore(resolveMaxConcurrent());
     AforgeProvider = class {
-      bin;
-      constructor(bin = "aforge") {
+      constructor(bin = "aforge", deadline) {
+        this.deadline = deadline;
         this.bin = bin === "aforge" ? process.env.AFORGE_BIN?.trim() || bin : bin;
       }
+      deadline;
+      bin;
       async execute(prompt, options) {
         return aforgeSemaphore.use(() => this.executeImpl(prompt, options));
       }
       async executeImpl(prompt, options) {
         const root = resolveRoot(options) ?? ".";
-        const outerTimeout = timeoutSeconds();
+        const remaining = this.deadline === void 0 ? void 0 : this.deadline - performance.now();
+        if (remaining !== void 0 && remaining <= 0) {
+          return createRawResult({ isError: true, failureType: "timeout", errorMessage: "CodeAF fallback timed out" });
+        }
+        const outerTimeout = remaining === void 0 ? timeoutSeconds() : remaining / 1e3;
         const command = (process.env.AGENTFIELD_AFORGE_COMMAND ?? "exec").trim().toLowerCase();
         if (command !== "do" && command !== "exec") {
           return createRawResult({
@@ -793,7 +994,7 @@ var init_aforge = __esm({
           "-w",
           root,
           "--timeout",
-          String(innerTimeout(outerTimeout))
+          String(Math.max(1, Math.floor(innerTimeout(outerTimeout))))
         ] : [
           this.bin,
           "do",
@@ -802,7 +1003,7 @@ var init_aforge = __esm({
           "-w",
           root,
           "--timeout",
-          String(innerTimeout(outerTimeout))
+          String(Math.max(1, Math.floor(innerTimeout(outerTimeout))))
         ];
         if (command === "exec" && typeof options.maxTurns === "number" && Number.isFinite(options.maxTurns) && options.maxTurns > 0) {
           cmd.push("--turns", String(Math.trunc(options.maxTurns)));
@@ -895,6 +1096,329 @@ var init_aforge = __esm({
   }
 });
 
+// src/harness/providers/codeaf.ts
+var codeaf_exports = {};
+__export(codeaf_exports, {
+  CODEAF_DEFAULT_MODEL: () => CODEAF_DEFAULT_MODEL,
+  CodeafProvider: () => CodeafProvider,
+  resolveCodeafMaxConcurrent: () => resolveCodeafMaxConcurrent
+});
+function resolveCodeafMaxConcurrent() {
+  const value = process.env.CODEAF_MAX_CONCURRENT ?? process.env.AFORGE_MAX_CONCURRENT;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : 8;
+}
+async function resolveAutomaticBinary() {
+  const managed = findManagedCodeaf();
+  if (managed) {
+    return { provider: "codeaf", binary: managed };
+  }
+  try {
+    const installed = await ensureCodeafInstalled();
+    if (installed) {
+      return { provider: "codeaf", binary: installed };
+    }
+  } catch (error) {
+    downloadError = error instanceof Error ? error.message : String(error);
+  }
+  const onPath = findExecutable("codeaf");
+  if (onPath) {
+    return { provider: "codeaf", binary: onPath };
+  }
+  const legacyName = process.platform === "win32" ? "aforge.exe" : "aforge";
+  const legacy = findExecutable(path__default.join(agentfieldHome(), "bin", legacyName)) ?? findExecutable("aforge");
+  if (legacy) {
+    console.warn(`CodeAF is not installed; falling back to the legacy aforge binary at ${legacy}. Run \`af codeaf ensure\`.`);
+    return { provider: "aforge", binary: legacy };
+  }
+  const unavailable = providerUnavailable("codeaf", "codeaf");
+  unavailable.message += ` (or set CODEAF_BIN)${downloadError ? `. Download failed: ${downloadError}` : ""}`;
+  throw unavailable;
+}
+function resolveBinary(explicit) {
+  const override = explicit?.trim() || process.env.CODEAF_BIN?.trim();
+  if (override) {
+    return Promise.resolve({ provider: "codeaf", binary: override });
+  }
+  resolution ??= resolveAutomaticBinary().catch((error) => {
+    resolution = void 0;
+    throw error;
+  });
+  return resolution;
+}
+async function withinDeadline(operation, deadline, message) {
+  let timer;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), Math.max(0, deadline - performance.now()));
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function parseEnvelope2(stdout) {
+  const parse = (text3) => {
+    try {
+      const value = JSON.parse(text3);
+      if (typeof value === "object" && value !== null && !Array.isArray(value) && "ok" in value && "stop" in value) {
+        return value;
+      }
+    } catch {
+    }
+    return void 0;
+  };
+  const whole = parse(stdout.trim());
+  if (whole) {
+    return whole;
+  }
+  const lines = stdout.split("\n");
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const envelope = parse(lines[index].trim());
+    if (envelope) {
+      return envelope;
+    }
+  }
+  return void 0;
+}
+function numeric2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function text2(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function failure(envelope, exitCode, stdout) {
+  if (exitCode < 0) return "crash";
+  if (!envelope) return exitCode === 0 && !stdout.trim() ? "no_output" : "crash";
+  const stop = text2(envelope.stop);
+  const answer = text2(envelope.answer);
+  if (stop === "deadline") return "timeout";
+  if (stop === "done") return envelope.ok === true ? "none" : "crash";
+  if (stop === "unchecked") return answer ? "none" : "crash";
+  if (stop === "budget" || stop === "turn-cap") return answer ? "none" : "no_output";
+  if (["question", "incomplete", "error", "price"].includes(stop)) return "crash";
+  return exitCode === 0 && answer ? "none" : "crash";
+}
+function errorMessage(exitCode, envelope, stderr) {
+  const stop = text2(envelope?.stop);
+  const detail = text2(envelope?.error) || text2(envelope?.answer) || stderr.trim().replace(ANSI_PATTERN2, "").slice(-1e3);
+  let message = `codeaf exit code ${exitCode} (stop=${stop}): ${detail.slice(0, 1e3)}`;
+  if (stop === "question" && text2(envelope?.blocked_on)) {
+    message += `. blocked_on: ${text2(envelope?.blocked_on).slice(0, 1e3)}`;
+  }
+  return message;
+}
+function childEnvironment(options, variant) {
+  const overlay = {};
+  if (typeof options.env === "object" && options.env !== null && !Array.isArray(options.env)) {
+    for (const [key, value] of Object.entries(options.env)) {
+      if (typeof value === "string") overlay[key] = value;
+    }
+  }
+  const inherited = { ...process.env, ...overlay };
+  const env = { CODEAF_MODELS: void 0, AFORGE_MODELS: void 0 };
+  if (inherited.CODEAF_HOME === void 0) {
+    env.CODEAF_HOME = codeafStateHome(inherited);
+  }
+  if (inherited.CODEAF_NO_UPDATE_CHECK === void 0) env.CODEAF_NO_UPDATE_CHECK = "1";
+  if (inherited.CODEAF_TELEMETRY === void 0 && (isTruthy(inherited.CI) || isTruthy(inherited.DO_NOT_TRACK) || /^(0|false|no|off)$/i.test(inherited.AGENTFIELD_TELEMETRY_ENABLED?.trim() ?? ""))) {
+    env.CODEAF_TELEMETRY = "off";
+  }
+  const normalized = variant?.trim().toLowerCase();
+  if (normalized && REASONING_VARIANTS2.has(normalized)) env.CODEAF_EXEC_REASONING = normalized;
+  return { ...env, ...overlay };
+}
+var CODEAF_DEFAULT_MODEL, REASONING_VARIANTS2, ANSI_PATTERN2, Semaphore2, codeafSemaphore, resolution, downloadError, aliasLogged, invalidCommandLogged, CodeafProvider;
+var init_codeaf = __esm({
+  "src/harness/providers/codeaf.ts"() {
+    init_base();
+    init_aforge();
+    init_types();
+    init_cli();
+    init_availability();
+    init_codeafInstall();
+    init_modelVariant();
+    CODEAF_DEFAULT_MODEL = "~deepseek/deepseek-v4-flash-latest";
+    REASONING_VARIANTS2 = /* @__PURE__ */ new Set(["off", "low", "medium", "high"]);
+    ANSI_PATTERN2 = /\x1B\[[0-?]*[ -/]*[@-~]/g;
+    Semaphore2 = class {
+      constructor(limit) {
+        this.limit = limit;
+      }
+      limit;
+      active = 0;
+      waiters = [];
+      async use(operation) {
+        if (this.active >= this.limit) {
+          await new Promise((resolve3) => this.waiters.push(resolve3));
+        } else {
+          this.active += 1;
+        }
+        try {
+          return await operation();
+        } finally {
+          const next = this.waiters.shift();
+          if (next) {
+            next();
+          } else {
+            this.active -= 1;
+          }
+        }
+      }
+    };
+    codeafSemaphore = new Semaphore2(resolveCodeafMaxConcurrent());
+    aliasLogged = false;
+    invalidCommandLogged = false;
+    CodeafProvider = class {
+      constructor(bin, alias = false) {
+        this.bin = bin;
+        this.alias = alias;
+      }
+      bin;
+      alias;
+      async execute(prompt, options) {
+        const legacyPin = this.alias ? process.env.AFORGE_BIN?.trim() : void 0;
+        if (legacyPin) {
+          return { ...await new AforgeProvider(legacyPin).execute(prompt, options), provider: "aforge" };
+        }
+        const started = performance.now();
+        const parsedTimeout = Number.parseInt(process.env.AGENTFIELD_HARNESS_TIMEOUT_SECONDS ?? "", 10);
+        const timeout = Number.isFinite(parsedTimeout) && parsedTimeout > 0 ? parsedTimeout : 1800;
+        const deadline = started + timeout * 1e3;
+        let resolved;
+        try {
+          resolved = await withinDeadline(resolveBinary(this.bin), deadline, "Timed out while provisioning CodeAF");
+        } catch (error) {
+          if (!(error instanceof Error) || !error.message.includes("Timed out while provisioning")) throw error;
+          return createRawResult({
+            provider: "codeaf",
+            isError: true,
+            failureType: "timeout",
+            errorMessage: error.message,
+            metrics: createMetrics({ durationApiMs: performance.now() - started })
+          });
+        }
+        if (resolved.provider === "aforge") {
+          try {
+            return { ...await withinDeadline(
+              new AforgeProvider(resolved.binary, deadline).execute(prompt, options),
+              deadline,
+              "CodeAF fallback timed out"
+            ), provider: "aforge" };
+          } catch (error) {
+            if (!(error instanceof Error) || !error.message.includes("timed out")) throw error;
+            return createRawResult({ provider: "aforge", isError: true, failureType: "timeout", errorMessage: error.message });
+          }
+        }
+        if (this.alias && !aliasLogged) {
+          aliasLogged = true;
+          console.info("provider 'aforge' now runs CodeAF; set AFORGE_BIN to pin the legacy binary");
+        }
+        try {
+          return await withinDeadline(
+            codeafSemaphore.use(() => this.executeImpl(resolved.binary, prompt, options, deadline)),
+            deadline,
+            "CodeAF timed out"
+          );
+        } catch (error) {
+          if (!(error instanceof Error) || !error.message.includes("timed out")) throw error;
+          return createRawResult({ provider: "codeaf", isError: true, failureType: "timeout", errorMessage: error.message });
+        }
+      }
+      async executeImpl(binary, prompt, options, deadline) {
+        if (performance.now() >= deadline) {
+          return createRawResult({ provider: "codeaf", isError: true, failureType: "timeout", errorMessage: "CodeAF timed out" });
+        }
+        const root = resolveRoot(options) ?? ".";
+        const outerTimeout = Math.max(0, deadline - performance.now());
+        const requestedCommand = process.env.AGENTFIELD_CODEAF_COMMAND?.trim().toLowerCase() || process.env.AGENTFIELD_AFORGE_COMMAND?.trim().toLowerCase() || "exec";
+        const command = requestedCommand === "do" ? "do" : "exec";
+        if (!["exec", "do"].includes(requestedCommand) && !invalidCommandLogged) {
+          invalidCommandLogged = true;
+          console.warn(`Invalid AGENTFIELD_CODEAF_COMMAND ${JSON.stringify(requestedCommand)}; using exec`);
+        }
+        const { model, variant } = resolveModelAndVariant(options);
+        const overlay = typeof options.env === "object" && options.env !== null ? options.env : {};
+        const environment = { ...process.env, ...overlay };
+        const effectiveModel = (model || environment.CODEAF_MODEL?.trim() || environment.AFORGE_MODEL?.trim() || CODEAF_DEFAULT_MODEL).replace(/^openrouter\//, "");
+        const systemPrompt = text2(options.systemPrompt ?? options.system_prompt);
+        const cmd = [binary, command, "--json", "--dir", root];
+        if (command === "do") cmd.push("--yes-spend");
+        cmd.push("--model", effectiveModel);
+        if (command === "do") cmd.push("--plan-model", effectiveModel, "--check-model", effectiveModel);
+        cmd.push("--timeout", `${Number(Math.max(1, outerTimeout / 1e3 - 5).toFixed(3))}s`);
+        if (command === "exec") {
+          if (typeof options.maxTurns === "number" && Number.isFinite(options.maxTurns) && options.maxTurns > 0) {
+            cmd.push("--max-turns", String(Math.trunc(options.maxTurns)));
+          }
+          if (systemPrompt) cmd.push("--system", systemPrompt);
+        } else {
+          cmd.push("-");
+        }
+        const startApi = Date.now();
+        try {
+          const env = childEnvironment(options, variant);
+          const remaining = deadline - performance.now();
+          if (remaining <= 0) throw new Error("CodeAF timed out");
+          const { stdout, stderr, exitCode } = await runCli(markProviderCommand("codeaf", cmd), {
+            env,
+            cwd: void 0,
+            timeout: remaining,
+            idleSeconds: 0,
+            inputText: command === "do" && systemPrompt ? `${systemPrompt}
+
+Task:
+${prompt}` : prompt
+          });
+          const envelope = parseEnvelope2(stdout);
+          const failureType = failure(envelope, exitCode, stdout);
+          const stop = text2(envelope?.stop);
+          if (failureType === "none" && ["unchecked", "budget", "turn-cap"].includes(stop)) {
+            console.warn(`CodeAF returned ${stop === "unchecked" ? "an unchecked answer" : `a partial answer (${stop})`}`);
+          }
+          const tokens = typeof envelope?.tokens === "object" && envelope.tokens !== null && !Array.isArray(envelope.tokens) ? envelope.tokens : {};
+          const inputTokens = Math.trunc(numeric2(tokens.in) ?? 0);
+          const outputTokens = Math.trunc(numeric2(tokens.out) ?? 0);
+          return createRawResult({
+            provider: "codeaf",
+            result: failureType === "none" ? text2(envelope?.answer) || void 0 : void 0,
+            messages: envelope ? [envelope] : [],
+            metrics: createMetrics({
+              durationApiMs: Date.now() - startApi,
+              numTurns: Math.trunc(numeric2(envelope?.steps) ?? 0),
+              totalCostUsd: numeric2(envelope?.spend_usd),
+              inputTokens,
+              outputTokens,
+              totalTokens: inputTokens + outputTokens,
+              cacheReadTokens: 0,
+              cacheCreationTokens: 0,
+              model: text2(envelope?.model) || effectiveModel,
+              usage: tokens
+            }),
+            isError: failureType !== "none",
+            errorMessage: failureType !== "none" ? errorMessage(exitCode, envelope, stderr) : void 0,
+            failureType,
+            returnCode: exitCode
+          });
+        } catch (error) {
+          if (error instanceof HarnessProviderUnavailable) throw error;
+          const message = error instanceof Error ? error.message : String(error);
+          if (message.includes("ENOENT")) throw providerUnavailable("codeaf", binary);
+          return createRawResult({
+            provider: "codeaf",
+            isError: true,
+            errorMessage: message,
+            failureType: /timed out|deadline exceeded|no progress/i.test(message) ? "timeout" : "crash",
+            metrics: createMetrics({ durationApiMs: Date.now() - startApi, model: effectiveModel })
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/harness/providers/claude.ts
 var claude_exports = {};
 __export(claude_exports, {
@@ -1357,7 +1881,7 @@ function extractOpenCodeError(stderr) {
   }
   return stderr.slice(0, 1e3);
 }
-var ANSI_PATTERN2, STDERR_ERROR_PATTERNS, openCodeConfigSchema, openCodeAgentName, openCodeDefaultSteps, openCodeInlineSystemPromptEnv, openCodeStepsEnv, agentFieldWorkerInstruction, trueEnvValues, OpenCodeProvider;
+var ANSI_PATTERN3, STDERR_ERROR_PATTERNS, openCodeConfigSchema, openCodeAgentName, openCodeDefaultSteps, openCodeInlineSystemPromptEnv, openCodeStepsEnv, agentFieldWorkerInstruction, trueEnvValues, OpenCodeProvider;
 var init_opencode = __esm({
   "src/harness/providers/opencode.ts"() {
     init_base();
@@ -1366,7 +1890,7 @@ var init_opencode = __esm({
     init_availability();
     init_modelVariant();
     init_openrouterAttribution();
-    ANSI_PATTERN2 = /\x1B\[[0-?]*[ -/]*[@-~]/g;
+    ANSI_PATTERN3 = /\x1B\[[0-?]*[ -/]*[@-~]/g;
     STDERR_ERROR_PATTERNS = [
       /^Error:/m,
       /\bModel not found\b/,
@@ -1429,18 +1953,18 @@ var init_opencode = __esm({
         try {
           const { stdout, stderr, exitCode } = await runCli(markProviderCommand("opencode", cmd), { env });
           const resultText = stdout.trim() || void 0;
-          const cleanStderr = stderr.trim().replace(ANSI_PATTERN2, "");
+          const cleanStderr = stderr.trim().replace(ANSI_PATTERN3, "");
           let isError = false;
-          let errorMessage;
+          let errorMessage2;
           if (exitCode < 0) {
             isError = true;
-            errorMessage = cleanStderr ? `Process killed by signal ${-exitCode}. stderr: ${cleanStderr.slice(0, 500)}` : `Process killed by signal ${-exitCode}.`;
+            errorMessage2 = cleanStderr ? `Process killed by signal ${-exitCode}. stderr: ${cleanStderr.slice(0, 500)}` : `Process killed by signal ${-exitCode}.`;
           } else if (exitCode !== 0 && !resultText) {
             isError = true;
-            errorMessage = cleanStderr ? extractOpenCodeError(cleanStderr) : `Process exited with code ${exitCode} and produced no output.`;
+            errorMessage2 = cleanStderr ? extractOpenCodeError(cleanStderr) : `Process exited with code ${exitCode} and produced no output.`;
           } else if (!resultText && cleanStderr && STDERR_ERROR_PATTERNS.some((pattern) => pattern.test(cleanStderr))) {
             isError = true;
-            errorMessage = extractOpenCodeError(cleanStderr);
+            errorMessage2 = extractOpenCodeError(cleanStderr);
           }
           return createRawResult({
             result: resultText,
@@ -1452,7 +1976,7 @@ var init_opencode = __esm({
               model: modelValue
             }),
             isError,
-            errorMessage,
+            errorMessage: errorMessage2,
             failureType: isError ? "crash" : "none"
           });
         } catch (err) {
@@ -1506,8 +2030,8 @@ function textContent(message) {
   if (!Array.isArray(message.content)) {
     return void 0;
   }
-  const text2 = message.content.filter((part) => typeof part === "object" && part !== null).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
-  return text2 || void 0;
+  const text3 = message.content.filter((part) => typeof part === "object" && part !== null).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
+  return text3 || void 0;
 }
 function parsePiEvents(events, configuredModel) {
   let result;
@@ -1578,7 +2102,7 @@ function parsePiEvents(events, configuredModel) {
     })
   };
 }
-var READ_ONLY_TOOLS, ANSI_PATTERN3, PiFamilyProvider, PiProvider, OMPProvider;
+var READ_ONLY_TOOLS, ANSI_PATTERN4, PiFamilyProvider, PiProvider, OMPProvider;
 var init_pi = __esm({
   "src/harness/providers/pi.ts"() {
     init_base();
@@ -1587,7 +2111,7 @@ var init_pi = __esm({
     init_availability();
     init_modelVariant();
     READ_ONLY_TOOLS = /* @__PURE__ */ new Set(["read", "grep", "find", "glob", "ls", "lsp"]);
-    ANSI_PATTERN3 = /\x1B\[[0-?]*[ -/]*[@-~]/g;
+    ANSI_PATTERN4 = /\x1B\[[0-?]*[ -/]*[@-~]/g;
     PiFamilyProvider = class {
       constructor(flavor, bin) {
         this.flavor = flavor;
@@ -1646,20 +2170,20 @@ var init_pi = __esm({
           const events = parseJsonl(stdout);
           const parsed = parsePiEvents(events, model);
           parsed.metrics.durationApiMs = Date.now() - startApi;
-          const cleanStderr = stderr.trim().replace(ANSI_PATTERN3, "").slice(0, 1e3);
-          let errorMessage;
+          const cleanStderr = stderr.trim().replace(ANSI_PATTERN4, "").slice(0, 1e3);
+          let errorMessage2;
           let failureType;
           if (exitCode < 0) {
-            errorMessage = `Process killed by signal ${-exitCode}.`;
+            errorMessage2 = `Process killed by signal ${-exitCode}.`;
             failureType = "crash";
           } else if (exitCode !== 0) {
-            errorMessage = cleanStderr || parsed.providerError || `Process exited with code ${exitCode}.`;
+            errorMessage2 = cleanStderr || parsed.providerError || `Process exited with code ${exitCode}.`;
             failureType = "crash";
           } else if (parsed.providerError) {
-            errorMessage = parsed.providerError;
+            errorMessage2 = parsed.providerError;
             failureType = "api_error";
           } else if (!parsed.result) {
-            errorMessage = cleanStderr || `${this.flavor} exited successfully without an assistant response.`;
+            errorMessage2 = cleanStderr || `${this.flavor} exited successfully without an assistant response.`;
             failureType = "no_output";
           } else {
             failureType = "none";
@@ -1669,7 +2193,7 @@ var init_pi = __esm({
             messages: events,
             metrics: parsed.metrics,
             isError: failureType !== "none",
-            errorMessage,
+            errorMessage: errorMessage2,
             failureType,
             returnCode: exitCode
           });
@@ -1713,16 +2237,30 @@ function resolveProviderName(explicit) {
   const envName = process.env[HARNESS_PROVIDER_ENV_VAR]?.trim();
   return envName || DEFAULT_HARNESS_PROVIDER;
 }
+function resolveExecutionProvider(config) {
+  if (!config.provider?.trim() && !process.env[HARNESS_PROVIDER_ENV_VAR]?.trim() && (config.aforgeBin !== void 0 || process.env.AFORGE_BIN?.trim())) {
+    if (!legacyPinLogged) {
+      legacyPinLogged = true;
+      console.info('Legacy aforge pin in effect; unset it or select provider "codeaf" to use CodeAF');
+    }
+    return "aforge";
+  }
+  return resolveProviderName(config.provider);
+}
 async function buildProvider(config) {
-  const provider = resolveProviderName(config.provider);
+  const provider = resolveExecutionProvider(config);
   if (!SUPPORTED_PROVIDERS.has(provider)) {
     throw new Error(
       `Unknown harness provider: "${provider}". Supported: ${[...SUPPORTED_PROVIDERS].sort().join(", ")}`
     );
   }
-  if (provider === "aforge") {
+  if (provider === "aforge" && (config.aforgeBin !== void 0 || process.env.AFORGE_BIN?.trim())) {
     const { AforgeProvider: AforgeProvider2 } = await Promise.resolve().then(() => (init_aforge(), aforge_exports));
-    return new AforgeProvider2(config.aforgeBin ?? "aforge");
+    return new AforgeProvider2(config.aforgeBin);
+  }
+  if (provider === "codeaf" || provider === "aforge") {
+    const { CodeafProvider: CodeafProvider2 } = await Promise.resolve().then(() => (init_codeaf(), codeaf_exports));
+    return new CodeafProvider2(config.codeafBin, provider === "aforge");
   }
   if (provider === "claude-code") {
     const { ClaudeCodeProvider: ClaudeCodeProvider2 } = await Promise.resolve().then(() => (init_claude(), claude_exports));
@@ -1750,13 +2288,14 @@ async function buildProvider(config) {
   }
   throw new Error(`Provider "${provider}" is not yet implemented.`);
 }
-var SUPPORTED_PROVIDERS, DEFAULT_HARNESS_PROVIDER, HARNESS_PROVIDER_ENV_VAR;
+var SUPPORTED_PROVIDERS, DEFAULT_HARNESS_PROVIDER, HARNESS_PROVIDER_ENV_VAR, legacyPinLogged;
 var init_factory = __esm({
   "src/harness/providers/factory.ts"() {
     init_availability();
     SUPPORTED_PROVIDERS = new Set(SUPPORTED_PROVIDER_NAMES);
-    DEFAULT_HARNESS_PROVIDER = "aforge";
+    DEFAULT_HARNESS_PROVIDER = "codeaf";
     HARNESS_PROVIDER_ENV_VAR = "AGENTFIELD_HARNESS_PROVIDER";
+    legacyPinLogged = false;
   }
 });
 function isRecord3(value) {
@@ -1774,7 +2313,7 @@ function getZod4Converter() {
   }
   const requires = [];
   try {
-    requires.push(createRequire(path5__default.join(process.cwd(), "package.json")));
+    requires.push(createRequire(path__default.join(process.cwd(), "package.json")));
   } catch {
   }
   requires.push(createRequire(import.meta.url));
@@ -1829,17 +2368,17 @@ function hasJsonSchema(value) {
 function hasParse(value) {
   return isRecord4(value) && typeof value.parse === "function";
 }
-function estimateTokens(text2) {
-  return Math.floor(text2.length / 4);
+function estimateTokens(text3) {
+  return Math.floor(text3.length / 4);
 }
 function writeSchemaFile(schemaJson, cwd) {
   const filePath = getSchemaPath(cwd);
-  fs2.mkdirSync(path5__default.dirname(filePath), { recursive: true });
-  const fd = fs2.openSync(filePath, "w", 384);
+  fs.mkdirSync(path__default.dirname(filePath), { recursive: true });
+  const fd = fs.openSync(filePath, "w", 384);
   try {
-    fs2.writeFileSync(fd, schemaJson, "utf8");
+    fs.writeFileSync(fd, schemaJson, "utf8");
   } finally {
-    fs2.closeSync(fd);
+    fs.closeSync(fd);
   }
   return filePath;
 }
@@ -1850,10 +2389,10 @@ function validateAgainstSchema(data, schema) {
   return data;
 }
 function getOutputPath(cwd) {
-  return path5__default.join(cwd, OUTPUT_FILENAME);
+  return path__default.join(cwd, OUTPUT_FILENAME);
 }
 function getSchemaPath(cwd) {
-  return path5__default.join(cwd, SCHEMA_FILENAME);
+  return path__default.join(cwd, SCHEMA_FILENAME);
 }
 function schemaToJsonSchema(schema) {
   if (isZod4Schema(schema)) {
@@ -1902,28 +2441,28 @@ ${schemaJson}
 Do not include any text outside the JSON in that file. Do not wrap in markdown fences.`;
 }
 function cosmeticRepair(raw) {
-  let text2 = raw.trim();
-  const fenceMatch = text2.match(/^```(?:json)?\s*\n([\s\S]*?)```\s*$/);
+  let text3 = raw.trim();
+  const fenceMatch = text3.match(/^```(?:json)?\s*\n([\s\S]*?)```\s*$/);
   if (fenceMatch) {
-    text2 = fenceMatch[1].trim();
+    text3 = fenceMatch[1].trim();
   }
-  if (text2.length > 0 && text2[0] !== "{" && text2[0] !== "[") {
-    const firstJsonCharIndex = [...text2].findIndex((char) => char === "{" || char === "[");
+  if (text3.length > 0 && text3[0] !== "{" && text3[0] !== "[") {
+    const firstJsonCharIndex = [...text3].findIndex((char) => char === "{" || char === "[");
     if (firstJsonCharIndex >= 0) {
-      text2 = text2.slice(firstJsonCharIndex);
+      text3 = text3.slice(firstJsonCharIndex);
     }
   }
-  text2 = text2.replace(/,\s*([}\]])/g, "$1");
-  const openBraces = (text2.match(/{/g)?.length ?? 0) - (text2.match(/}/g)?.length ?? 0);
-  const openBrackets = (text2.match(/\[/g)?.length ?? 0) - (text2.match(/\]/g)?.length ?? 0);
+  text3 = text3.replace(/,\s*([}\]])/g, "$1");
+  const openBraces = (text3.match(/{/g)?.length ?? 0) - (text3.match(/}/g)?.length ?? 0);
+  const openBrackets = (text3.match(/\[/g)?.length ?? 0) - (text3.match(/\]/g)?.length ?? 0);
   if (openBraces > 0 || openBrackets > 0) {
-    text2 += "]".repeat(openBrackets) + "}".repeat(openBraces);
+    text3 += "]".repeat(openBrackets) + "}".repeat(openBraces);
   }
-  return text2;
+  return text3;
 }
 function readAndParse(filePath) {
   try {
-    const content = fs2.readFileSync(filePath, "utf8");
+    const content = fs.readFileSync(filePath, "utf8");
     if (content.trim().length === 0) {
       return null;
     }
@@ -1934,7 +2473,7 @@ function readAndParse(filePath) {
 }
 function readRepairAndParse(filePath) {
   try {
-    const content = fs2.readFileSync(filePath, "utf8");
+    const content = fs.readFileSync(filePath, "utf8");
     if (content.trim().length === 0) {
       return null;
     }
@@ -1964,7 +2503,7 @@ function parseAndValidate(filePath, schema) {
 function cleanupTempFiles(cwd) {
   for (const filename of [OUTPUT_FILENAME, SCHEMA_FILENAME]) {
     try {
-      fs2.unlinkSync(path5__default.join(cwd, filename));
+      fs.unlinkSync(path__default.join(cwd, filename));
     } catch {
     }
   }
@@ -1986,7 +2525,7 @@ __export(runner_exports, {
 });
 function tokenMetrics(raw) {
   const { inputTokens, outputTokens, cacheReadTokens, cacheCreationTokens, totalTokens, model } = raw.metrics;
-  return { inputTokens, outputTokens, cacheReadTokens, cacheCreationTokens, totalTokens, model };
+  return { inputTokens, outputTokens, cacheReadTokens, cacheCreationTokens, totalTokens, model, provider: raw.provider };
 }
 var TRANSIENT_PATTERNS, HarnessRunner;
 var init_runner = __esm({
@@ -2019,18 +2558,19 @@ var init_runner = __esm({
       async run(prompt, options = {}) {
         const { schema, ...rest } = options;
         const resolved = this.resolveOptions(this.config, rest);
-        resolved.provider = resolveProviderName(resolved.provider);
+        resolved.provider = resolveExecutionProvider(resolved);
         const provider = await this.buildProvider(resolved.provider, resolved);
         const outputRoot = resolveRoot(resolved) ?? ".";
         let outputDir;
         if (schema !== void 0) {
-          fs2.mkdirSync(outputRoot, { recursive: true });
-          outputDir = fs2.mkdtempSync(path5__default.join(outputRoot, ".agentfield-out-"));
+          fs.mkdirSync(outputRoot, { recursive: true });
+          outputDir = fs.mkdtempSync(path__default.join(outputRoot, ".agentfield-out-"));
         }
         const effectivePrompt = schema === void 0 ? prompt : `${prompt}${buildPromptSuffix(schema, outputDir)}`;
         const startTime = Date.now();
         try {
           const raw = await this.executeWithRetry(provider, effectivePrompt, resolved);
+          raw.provider ??= resolved.provider;
           if (schema !== void 0) {
             return this.handleSchemaOutput(raw, schema, outputDir, startTime);
           }
@@ -2050,7 +2590,7 @@ var init_runner = __esm({
         } finally {
           if (schema !== void 0) {
             cleanupTempFiles(outputDir);
-            fs2.rmSync(outputDir, { recursive: true, force: true });
+            fs.rmSync(outputDir, { recursive: true, force: true });
           }
         }
       }
@@ -2073,6 +2613,7 @@ var init_runner = __esm({
             "env",
             "cwd",
             "projectDir",
+            "codeafBin",
             "aforgeBin",
             "codexBin",
             "geminiBin",
@@ -2477,13 +3018,13 @@ function installApprovalWebhookRoute(app, manager, logger) {
     }
   );
 }
-var httpAgent = new http.Agent({
+var httpAgent = new http2.Agent({
   keepAlive: true,
   maxSockets: 10,
   maxTotalSockets: 50,
   maxFreeSockets: 5
 });
-var httpsAgent = new https.Agent({
+var httpsAgent = new https2.Agent({
   keepAlive: true,
   maxSockets: 10,
   maxTotalSockets: 50,
@@ -2968,6 +3509,29 @@ function recordAiSdkUsage(params) {
   }
 }
 
+// src/ai/PromptTemplates.ts
+var DEFAULT_TOOL_CALL_LIMIT_REACHED = "Tool call limit reached. Please provide a final response.";
+var defaultToolErrorFormatter = (toolName, error) => ({
+  error,
+  tool: toolName
+});
+var defaultToolResultFormatter = (_toolName, result) => result;
+function resolvePromptTemplates(overrides) {
+  const limit = overrides?.toolCallLimitReached;
+  return {
+    toolSystemPrompt: overrides?.toolSystemPrompt,
+    toolCallLimitReached: limit && limit.length > 0 ? limit : DEFAULT_TOOL_CALL_LIMIT_REACHED,
+    toolErrorFormatter: overrides?.toolErrorFormatter ?? defaultToolErrorFormatter,
+    toolResultFormatter: overrides?.toolResultFormatter ?? defaultToolResultFormatter
+  };
+}
+var TRACE_SOURCE_USER = "user";
+var TRACE_SOURCE_ASSISTANT = "assistant";
+var TRACE_SOURCE_TOOL_SYSTEM_PROMPT = "sdk.tool_system_prompt";
+var TRACE_SOURCE_TOOL_RESULT = "sdk.tool_result";
+var TRACE_SOURCE_TOOL_ERROR = "sdk.tool_error";
+var TRACE_SOURCE_TOOL_LIMIT = "sdk.tool_limit";
+
 // src/ai/ToolCalling.ts
 var DEFAULT_MAX_TURNS = 10;
 var DEFAULT_MAX_TOOL_CALLS = 25;
@@ -3095,7 +3659,8 @@ function isToolCallConfig(obj) {
     "healthStatus",
     "fallbackBroadening",
     "maxCandidateTools",
-    "maxHydratedTools"
+    "maxHydratedTools",
+    "promptTemplates"
   ];
   return typeof obj === "object" && !Array.isArray(obj) && keys.some((k) => k in obj);
 }
@@ -3138,7 +3703,7 @@ async function buildToolConfig(toolsParam, agent) {
     `Invalid tools parameter: expected "discover", ToolCallConfig, DiscoveryResult, capability array, or tool map, got ${typeof toolsParam}`
   );
 }
-function wrapToolsWithObservability(toolMap, agent, trace, maxToolCalls, getCurrentTurn) {
+function wrapToolsWithObservability(toolMap, agent, trace, maxToolCalls, getCurrentTurn, templates, toolMessageSources) {
   let totalCalls = 0;
   const observableTools = {};
   for (const [name, t] of Object.entries(toolMap)) {
@@ -3146,9 +3711,13 @@ function wrapToolsWithObservability(toolMap, agent, trace, maxToolCalls, getCurr
     observableTools[name] = tool({
       description: originalTool.description ?? "",
       inputSchema: originalTool.inputSchema,
-      execute: async (args) => {
+      execute: async (args, opts) => {
         totalCalls++;
         trace.totalToolCalls = totalCalls;
+        const toolCallId = opts?.toolCallId;
+        const recordSource = (source) => {
+          if (toolCallId) toolMessageSources.set(toolCallId, source);
+        };
         if (totalCalls > maxToolCalls) {
           const record2 = {
             toolName: name,
@@ -3158,7 +3727,9 @@ function wrapToolsWithObservability(toolMap, agent, trace, maxToolCalls, getCurr
             turn: getCurrentTurn()
           };
           trace.calls.push(record2);
-          return { error: "Tool call limit reached. Please provide a final response." };
+          recordSource(TRACE_SOURCE_TOOL_LIMIT);
+          const limitContent = { error: templates.toolCallLimitReached };
+          return limitContent;
         }
         const record = {
           toolName: name,
@@ -3174,12 +3745,17 @@ function wrapToolsWithObservability(toolMap, agent, trace, maxToolCalls, getCurr
           record.result = result;
           record.latencyMs = Date.now() - start;
           trace.calls.push(record);
-          return result;
+          recordSource(TRACE_SOURCE_TOOL_RESULT);
+          const resultContent = templates.toolResultFormatter(name, result);
+          return resultContent;
         } catch (err) {
-          record.error = err.message ?? String(err);
+          const message = err.message ?? String(err);
+          record.error = message;
           record.latencyMs = Date.now() - start;
           trace.calls.push(record);
-          return { error: record.error, tool: name };
+          recordSource(TRACE_SOURCE_TOOL_ERROR);
+          const errorContent = templates.toolErrorFormatter(name, message);
+          return errorContent;
         }
       }
     });
@@ -3189,6 +3765,10 @@ function wrapToolsWithObservability(toolMap, agent, trace, maxToolCalls, getCurr
 async function executeToolCallLoop(agent, prompt, toolMap, config, needsLazyHydration, buildModel, options = {}, modelChoice) {
   const maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
   const maxToolCalls = config.maxToolCalls ?? DEFAULT_MAX_TOOL_CALLS;
+  const templates = resolvePromptTemplates(config.promptTemplates);
+  const effectiveSystem = templates.toolSystemPrompt ? options.system ? `${options.system}
+
+${templates.toolSystemPrompt}` : templates.toolSystemPrompt : options.system;
   const usageModel = modelChoice?.modelName ?? options.model;
   const recordLoopUsage = (result2) => {
     if (usageModel) {
@@ -3200,6 +3780,16 @@ async function executeToolCallLoop(agent, prompt, toolMap, config, needsLazyHydr
     totalTurns: 0,
     totalToolCalls: 0
   };
+  if (effectiveSystem) {
+    (trace.messages ??= []).push({
+      message: { role: "system", content: effectiveSystem },
+      source: templates.toolSystemPrompt ? TRACE_SOURCE_TOOL_SYSTEM_PROMPT : TRACE_SOURCE_USER
+    });
+  }
+  (trace.messages ??= []).push({
+    message: { role: "user", content: prompt },
+    source: TRACE_SOURCE_USER
+  });
   let activeTools = toolMap;
   if (needsLazyHydration) {
     const selectionTools = {};
@@ -3214,7 +3804,7 @@ async function executeToolCallLoop(agent, prompt, toolMap, config, needsLazyHydr
     const selectionResult = await generateText({
       model: buildModel(),
       prompt,
-      system: options.system,
+      system: effectiveSystem,
       temperature: options.temperature,
       maxOutputTokens: options.maxTokens,
       tools: selectionTools,
@@ -3229,6 +3819,7 @@ async function executeToolCallLoop(agent, prompt, toolMap, config, needsLazyHydr
       }
     }
     if (selectedNames.size > 0) {
+      appendResponseMessages(trace, selectionResult);
       const hydratedTools = await hydrateSelectedTools(
         agent,
         config,
@@ -3240,22 +3831,26 @@ async function executeToolCallLoop(agent, prompt, toolMap, config, needsLazyHydr
     } else {
       trace.totalTurns = selectionResult.steps.length;
       trace.finalResponse = selectionResult.text;
+      appendResponseMessages(trace, selectionResult);
       return { text: selectionResult.text, trace };
     }
   }
   let currentTurn = 0;
+  const toolMessageSources = /* @__PURE__ */ new Map();
   const { tools: observableTools } = wrapToolsWithObservability(
     activeTools,
     agent,
     trace,
     maxToolCalls,
-    () => currentTurn
+    () => currentTurn,
+    templates,
+    toolMessageSources
   );
   const model = buildModel();
   const result = await generateText({
     model,
     prompt,
-    system: options.system,
+    system: effectiveSystem,
     temperature: options.temperature,
     maxOutputTokens: options.maxTokens,
     tools: observableTools,
@@ -3268,8 +3863,53 @@ async function executeToolCallLoop(agent, prompt, toolMap, config, needsLazyHydr
   recordLoopUsage(result);
   trace.finalResponse = result.text;
   trace.totalTurns = result.steps.length;
+  appendResponseMessages(trace, result, toolMessageSources);
   return { text: result.text, trace };
 }
+function appendResponseMessages(trace, result, toolMessageSources) {
+  const responseMessages = result.response?.messages;
+  if (!Array.isArray(responseMessages)) {
+    return;
+  }
+  for (const message of responseMessages) {
+    const role = message?.role;
+    let source;
+    if (role === "assistant") {
+      source = TRACE_SOURCE_ASSISTANT;
+    } else if (role === "tool") {
+      source = toolSourceForMessage(message, toolMessageSources);
+    } else if (role === "system") {
+      source = TRACE_SOURCE_TOOL_SYSTEM_PROMPT;
+    } else {
+      source = TRACE_SOURCE_USER;
+    }
+    (trace.messages ??= []).push({ message, source });
+  }
+}
+function toolSourceForMessage(message, toolMessageSources) {
+  const parts = Array.isArray(message?.content) ? message.content : [];
+  let sawNativeError = false;
+  let fallback = TRACE_SOURCE_TOOL_RESULT;
+  for (const part of parts) {
+    const id = part?.toolCallId;
+    if (id && toolMessageSources?.has(id)) {
+      const recorded = toolMessageSources.get(id);
+      if (recorded !== TRACE_SOURCE_TOOL_RESULT) {
+        return recorded;
+      }
+      fallback = recorded;
+      continue;
+    }
+    const outputType = part?.output?.type ?? part?.type;
+    if (typeof outputType === "string" && outputType.startsWith("error")) {
+      sawNativeError = true;
+    }
+  }
+  if (sawNativeError) {
+    return TRACE_SOURCE_TOOL_ERROR;
+  }
+  return fallback;
+}
 
 // src/context/ReasonerContext.ts
 var ReasonerContext = class {
@@ -3360,7 +4000,9 @@ var ReasonerContext = class {
     const mergedConfig = {
       ...config,
       maxTurns: options.maxTurns ?? config.maxTurns ?? 10,
-      maxToolCalls: options.maxToolCalls ?? config.maxToolCalls ?? 25
+      maxToolCalls: options.maxToolCalls ?? config.maxToolCalls ?? 25,
+      // Carry the agent's prompt-template overrides into the loop (issue #229).
+      promptTemplates: this.aiClient.promptTemplates ?? config.promptTemplates
     };
     const modelChoice = typeof this.aiClient.resolveModelChoice === "function" ? this.aiClient.resolveModelChoice(options) : void 0;
     return executeToolCallLoop(
@@ -3538,7 +4180,7 @@ var StatelessRateLimiter = class {
     this._containerSeed = this._getContainerSeed();
   }
   _getContainerSeed() {
-    const identifier = `${os.hostname()}-${process.pid}`;
+    const identifier = `${os2.hostname()}-${process.pid}`;
     const hash = crypto2.createHash("md5").update(identifier).digest("hex");
     return parseInt(hash.slice(0, 8), 16);
   }
@@ -3761,8 +4403,8 @@ var VIDEO_MIME_TYPES = {
 var Text = class {
   type = "text";
   text;
-  constructor(text2) {
-    this.text = text2;
+  constructor(text3) {
+    this.text = text3;
   }
 };
 var Image = class _Image {
@@ -4027,8 +4669,8 @@ async function fileFromBase64(base64Data, mimeType) {
 }
 
 // src/ai/AIClient.ts
-function repairJsonText(text2) {
-  let cleaned = text2.trim();
+function repairJsonText(text3) {
+  let cleaned = text3.trim();
   const codeBlockMatch = cleaned.match(/```(?:json)?\s*([\s\S]*?)```/);
   if (codeBlockMatch) {
     cleaned = codeBlockMatch[1].trim();
@@ -4060,6 +4702,10 @@ var AIClient = class {
       ...config
     };
   }
+  /** Prompt-template overrides configured on this agent, if any (issue #229). */
+  get promptTemplates() {
+    return this.config.promptTemplates;
+  }
   async generate(prompt, options = {}) {
     const { provider, modelName, routingProvider: routingProvider2 } = this.resolveModelChoice(options);
     const model = this.buildModel(options);
@@ -4074,7 +4720,7 @@ var AIClient = class {
         temperature: options.temperature ?? this.config.temperature,
         maxOutputTokens: options.maxTokens ?? this.config.maxTokens,
         schema,
-        experimental_repairText: async ({ text: text2 }) => repairJsonText(text2)
+        experimental_repairText: async ({ text: text3 }) => repairJsonText(text3)
       });
       const response2 = await this.withRateLimitRetry(call2);
       recordAiSdkUsage({ source: response2, model: modelName, provider, routingProvider: routingProvider2 });
@@ -4107,7 +4753,7 @@ var AIClient = class {
     return (async function* () {
       let completed = false;
       try {
-        for await (const text2 of streamResult.textStream) yield text2;
+        for await (const text3 of streamResult.textStream) yield text3;
         try {
           const usage = await streamResult.totalUsage;
           if (usage) recordAiSdkUsage({ source: { totalUsage: usage }, model: modelName, provider, routingProvider: routingProvider2, tracker });
@@ -4933,11 +5579,11 @@ var AgentFieldClient = class {
             return snapshot.result?.result ?? snapshot.result;
           }
           const detail = snapshot.error || snapshot.statusReason || status;
-          const failure = Object.assign(
+          const failure2 = Object.assign(
             new Error(`execution ${executionId} ${status}: ${detail}`),
             { status: 0, responseData: snapshot.errorDetails ?? snapshot.error }
           );
-          throw failure;
+          throw failure2;
         }
         if (opts.timeoutMs != null && activeElapsed() >= opts.timeoutMs) {
           throw new Error(`waitForExecutionResult(${executionId}) timed out`);
@@ -5602,11 +6248,11 @@ var MemoryInterface = class _MemoryInterface {
       metadata: this.metadata
     });
   }
-  async embedText(text2, options) {
+  async embedText(text3, options) {
     if (!this.aiClient) {
       throw new Error("AI client not configured for embeddings");
     }
-    return this.aiClient.embed(text2, options);
+    return this.aiClient.embed(text3, options);
   }
   async embedTexts(texts, options) {
     if (!this.aiClient) {
@@ -5614,8 +6260,8 @@ var MemoryInterface = class _MemoryInterface {
     }
     return this.aiClient.embedMany(texts, options);
   }
-  async embedAndSet(key, text2, metadata, scope = this.defaultScope, scopeId = this.defaultScopeId, embeddingOptions) {
-    const embedding = await this.embedText(text2, embeddingOptions);
+  async embedAndSet(key, text3, metadata, scope = this.defaultScope, scopeId = this.defaultScopeId, embeddingOptions) {
+    const embedding = await this.embedText(text3, embeddingOptions);
     await this.setVector(key, embedding, metadata, scope, scopeId);
     return embedding;
   }
@@ -6613,9 +7259,9 @@ function buildSessionDefinition(name, options) {
 var DEFAULT_SHUTDOWN_TIMEOUT_MS = 3e4;
 function parseShutdownTimeout(value, warn = console.warn) {
   if (!value?.trim()) return DEFAULT_SHUTDOWN_TIMEOUT_MS;
-  const text2 = value.trim();
-  if (/^\d+$/.test(text2)) return Number(text2) * 1e3;
-  const match = text2.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/);
+  const text3 = value.trim();
+  if (/^\d+$/.test(text3)) return Number(text3) * 1e3;
+  const match = text3.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/);
   if (match) {
     const factors = { ms: 1, s: 1e3, m: 6e4, h: 36e5 };
     return Number(match[1]) * factors[match[2]];
@@ -6896,7 +7542,7 @@ var Agent = class {
       if (!inputTokens && !outputTokens && !cacheRead && !cacheCreation && !reportedTotal && cost === null) {
         return;
       }
-      const providerName = resolveProviderName(options?.provider ?? this.config.harnessConfig?.provider);
+      const providerName = result.provider ?? resolveProviderName(options?.provider ?? this.config.harnessConfig?.provider);
       const harnessName = providerName ? String(providerName).replace(/-/g, "_") : null;
       const rawModelName = String(
         result.model ?? options?.model ?? this.config.harnessConfig?.model ?? providerName ?? "harness"
@@ -7488,22 +8134,22 @@ var Agent = class {
         },
         message: { error: "rate_limit_exceeded", message: "Too many authentication attempts. Try again later." },
         skip: (req) => {
-          const path6 = req.path;
-          if (!path6.startsWith("/reasoners/") && !path6.startsWith("/skills/") && !path6.startsWith("/execute") && !path6.startsWith("/api/v1/reasoners/") && !path6.startsWith("/api/v1/skills/")) {
+          const path8 = req.path;
+          if (!path8.startsWith("/reasoners/") && !path8.startsWith("/skills/") && !path8.startsWith("/execute") && !path8.startsWith("/api/v1/reasoners/") && !path8.startsWith("/api/v1/skills/")) {
             return true;
           }
-          const parts = path6.replace(/^\/+/, "").split("/");
+          const parts = path8.replace(/^\/+/, "").split("/");
           const funcName = parts[parts.length - 1] ?? "";
           return realtimeFunctions.has(funcName);
         }
       });
       this.app.use(authRateLimiter);
       this.app.use(async (req, res, next) => {
-        const path6 = req.path;
-        if (!path6.startsWith("/reasoners/") && !path6.startsWith("/skills/") && !path6.startsWith("/execute") && !path6.startsWith("/api/v1/reasoners/") && !path6.startsWith("/api/v1/skills/")) {
+        const path8 = req.path;
+        if (!path8.startsWith("/reasoners/") && !path8.startsWith("/skills/") && !path8.startsWith("/execute") && !path8.startsWith("/api/v1/reasoners/") && !path8.startsWith("/api/v1/skills/")) {
           return next();
         }
-        const parts = path6.replace(/^\/+/, "").split("/");
+        const parts = path8.replace(/^\/+/, "").split("/");
         const funcName = parts[parts.length - 1] ?? "";
         if (realtimeFunctions.has(funcName)) {
           return next();
@@ -7717,9 +8363,9 @@ var Agent = class {
     return handler(req, res);
   }
   async handleServerlessEvent(event) {
-    const path6 = event?.path ?? event?.rawPath ?? "";
+    const path8 = event?.path ?? event?.rawPath ?? "";
     const action = event?.action ?? "";
-    if (path6 === "/discover" || action === "discover") {
+    if (path8 === "/discover" || action === "discover") {
       return {
         statusCode: 200,
         headers: { "content-type": "application/json" },
@@ -7728,7 +8374,7 @@ var Agent = class {
     }
     const body = this.normalizeEventBody(event);
     const invocation = this.extractInvocationDetails({
-      path: path6,
+      path: path8,
       query: event?.queryStringParameters,
       body,
       reasoner: event?.reasoner,
@@ -7807,9 +8453,9 @@ var Agent = class {
     const input = this.normalizeInputPayload(params.body);
     return { name: name ?? void 0, targetType: typeValue, input };
   }
-  parsePathTarget(path6) {
-    if (!path6) return {};
-    const normalized = path6.split("?")[0];
+  parsePathTarget(path8) {
+    if (!path8) return {};
+    const normalized = path8.split("?")[0];
     const reasonerMatch = normalized.match(/\/reasoners\/([^/]+)/);
     if (reasonerMatch?.[1]) {
       return { name: reasonerMatch[1], targetType: "reasoner" };
@@ -8549,8 +9195,8 @@ var MultimodalResponse = class {
   _rawResponse;
   _costUsd;
   _usage;
-  constructor(text2 = "", audio = null, images = [], files = [], rawResponse = null, costUsd = null, usage = {}) {
-    this._text = text2;
+  constructor(text3 = "", audio = null, images = [], files = [], rawResponse = null, costUsd = null, usage = {}) {
+    this._text = text3;
     this._audio = audio;
     this._images = images;
     this._files = files;
@@ -8703,7 +9349,7 @@ var MultimodalResponse = class {
    */
   async saveImage(image, imagePath) {
     const bytes = await this.getImageBytes(image);
-    await promises.mkdir(path5.dirname(imagePath), { recursive: true });
+    await promises.mkdir(path.dirname(imagePath), { recursive: true });
     await promises.writeFile(imagePath, bytes);
   }
   /**
@@ -8711,7 +9357,7 @@ var MultimodalResponse = class {
    */
   async saveAudio(audio, audioPath) {
     const bytes = await this.getAudioBytes(audio);
-    await promises.mkdir(path5.dirname(audioPath), { recursive: true });
+    await promises.mkdir(path.dirname(audioPath), { recursive: true });
     await promises.writeFile(audioPath, bytes);
   }
   /**
@@ -8719,7 +9365,7 @@ var MultimodalResponse = class {
    */
   async saveFile(file, filePath) {
     const bytes = await this.getFileBytes(file);
-    await promises.mkdir(path5.dirname(filePath), { recursive: true });
+    await promises.mkdir(path.dirname(filePath), { recursive: true });
     await promises.writeFile(filePath, bytes);
   }
   /**
@@ -8730,7 +9376,7 @@ var MultimodalResponse = class {
     const savedFiles = {};
     await promises.mkdir(outputDir, { recursive: true });
     if (this._audio) {
-      const audioPath = path5.join(outputDir, `${prefix}_audio.${this._audio.format}`);
+      const audioPath = path.join(outputDir, `${prefix}_audio.${this._audio.format}`);
       await this.saveAudio(this._audio, audioPath);
       savedFiles["audio"] = audioPath;
     }
@@ -8738,22 +9384,22 @@ var MultimodalResponse = class {
       const image = this._images[i];
       let ext = "png";
       if (image.url) {
-        const urlExt = path5.extname(image.url).slice(1);
+        const urlExt = path.extname(image.url).slice(1);
         if (urlExt) ext = urlExt;
       }
-      const imagePath = path5.join(outputDir, `${prefix}_image_${i}.${ext}`);
+      const imagePath = path.join(outputDir, `${prefix}_image_${i}.${ext}`);
       await this.saveImage(image, imagePath);
       savedFiles[`image_${i}`] = imagePath;
     }
     for (let i = 0; i < this._files.length; i++) {
       const file = this._files[i];
       const filename = file.filename || `${prefix}_file_${i}`;
-      const filePath = path5.join(outputDir, filename);
+      const filePath = path.join(outputDir, filename);
       await this.saveFile(file, filePath);
       savedFiles[`file_${i}`] = filePath;
     }
     if (this._text) {
-      const textPath = path5.join(outputDir, `${prefix}_text.txt`);
+      const textPath = path.join(outputDir, `${prefix}_text.txt`);
       await promises.writeFile(textPath, this._text, "utf-8");
       savedFiles["text"] = textPath;
     }
@@ -8782,7 +9428,7 @@ var MultimodalResponse = class {
     };
   }
 };
-function createMultimodalResponse(rawResponse, text2 = "") {
+function createMultimodalResponse(rawResponse, text3 = "") {
   let audio = null;
   let images = [];
   let files = [];
@@ -8798,7 +9444,7 @@ function createMultimodalResponse(rawResponse, text2 = "") {
   if (extractedFiles.length > 0) {
     files = extractedFiles;
   }
-  return new MultimodalResponse(text2, audio, images, files, rawResponse);
+  return new MultimodalResponse(text3, audio, images, files, rawResponse);
 }
 function extractImages(data) {
   const images = [];
@@ -9462,12 +10108,12 @@ var OpenRouterMediaProvider = class {
    * Call OpenRouter's OpenAI-compatible TTS endpoint (`POST /audio/speech`).
    * Returns raw bytes for the requested format; wraps PCM → WAV when needed.
    */
-  async generateAudioViaSpeechEndpoint(model, text2, voice, requestedFormat, request) {
+  async generateAudioViaSpeechEndpoint(model, text3, voice, requestedFormat, request) {
     const wireFormat = requestedFormat === "wav" || requestedFormat === "pcm" || requestedFormat === "pcm16" ? "pcm" : requestedFormat;
     const endpoint = `${this.baseUrl}/audio/speech`;
     const body = {
       model,
-      input: text2,
+      input: text3,
       voice,
       response_format: wireFormat
     };
@@ -9487,7 +10133,7 @@ var OpenRouterMediaProvider = class {
       model,
       mime_type: res.headers.get("content-type") ?? ""
     });
-    resp.text = text2;
+    resp.text = text3;
     resp.audio = {
       data: bytesToBase64(finalBytes),
       format: requestedFormat
@@ -9530,6 +10176,8 @@ init_availability();
 init_modelVariant();
 init_factory();
 init_runner();
+init_aforge();
+init_codeaf();
 async function simulateTrigger(handler, options) {
   const body = options.body ?? {};
   const triggerContext = {
@@ -9579,6 +10227,6 @@ function loadFixture(source) {
   );
 }
 
-export { ACTIVE_STATUSES, AIClient, Agent, AgentRouter, ApprovalClient, ApprovalResult, Audio, CANONICAL_STATUSES, CostTracker, DEFAULT_HARNESS_PROVIDER, DIDAuthenticator, DidClient, DidInterface, DidManager, ExecutionContext, ExecutionLogger, ExecutionStatus, File, HARNESS_PROVIDER_ENV_VAR, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, HarnessProviderUnavailable, HarnessRunner, Image, JWE_ALG, JWE_ENC, KEY_AGREEMENT_TYPE, MODEL_VARIANT_SEP, MediaProviderError, MediaRouter, MemoryClient, MemoryClientBase, MemoryEventClient, MemoryInterface, MultimodalResponse, OpenRouterMediaProvider, PauseClock, PauseManager, PayloadEncryptionError, RateLimitError, RealtimeSession, ReasonerContext, SUPPORTED_PROVIDERS, SUPPORTED_PROVIDER_NAMES, SUPPORTED_SESSION_TRANSPORTS, SessionTransportError, SkillContext, StatelessRateLimiter, TERMINAL_STATUSES, Text, USAGE_ENVELOPE_KEY, Video, WorkflowReporter, applyTriggerTransform, attachUsageToSyncResult, audioFromBase64, audioFromBuffer, audioFromFile, audioFromUrl, audioMediaType, buildProvider, buildSessionDefinition, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createExecutionLogger, createHarnessResult, createMetrics, createMultimodalResponse, createRawResult, decrypt, decryptToString, deriveProvider, encryptForDid, encryptToJwk, ensureCliAvailable, eventTrigger, executeToolCallLoop, extractKeyAgreementJwk, fileFromBase64, fileFromBuffer, fileFromPath, fileFromUrl, findExecutable, generateX25519KeyPair, getCurrentContext, getCurrentSkillContext, guessUrlMimeType, harnessDoctor, imageFromBase64, imageFromBuffer, imageFromFile, imageFromUrl, installApprovalWebhookRoute, isActive, isExecutionLogBatchPayload, isTerminal, isTriggerEnvelope, loadFixture, normalizeExecutionLogEntry, normalizeSessionTransportValue, normalizeStatus, normalizeTurnDetection, resolveModelAndVariant, resolveProviderName, scheduleTrigger, serializeExecutionLogEntry, simulateSchedule, simulateTrigger, splitModelVariant, text, triggerToPayload, unwrapEnvelope, usageSummaryOrNull, validateSessionTransport, videoFromBase64, videoFromBuffer, videoFromFile, videoFromUrl };
+export { ACTIVE_STATUSES, AIClient, AforgeProvider, Agent, AgentRouter, ApprovalClient, ApprovalResult, Audio, CANONICAL_STATUSES, CODEAF_DEFAULT_MODEL, CodeafProvider, CostTracker, DEFAULT_HARNESS_PROVIDER, DEFAULT_TOOL_CALL_LIMIT_REACHED, DIDAuthenticator, DidClient, DidInterface, DidManager, ExecutionContext, ExecutionLogger, ExecutionStatus, File, HARNESS_PROVIDER_ENV_VAR, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, HarnessProviderUnavailable, HarnessRunner, Image, JWE_ALG, JWE_ENC, KEY_AGREEMENT_TYPE, MODEL_VARIANT_SEP, MediaProviderError, MediaRouter, MemoryClient, MemoryClientBase, MemoryEventClient, MemoryInterface, MultimodalResponse, OpenRouterMediaProvider, PauseClock, PauseManager, PayloadEncryptionError, RateLimitError, RealtimeSession, ReasonerContext, SUPPORTED_PROVIDERS, SUPPORTED_PROVIDER_NAMES, SUPPORTED_SESSION_TRANSPORTS, SessionTransportError, SkillContext, StatelessRateLimiter, TERMINAL_STATUSES, TRACE_SOURCE_ASSISTANT, TRACE_SOURCE_TOOL_ERROR, TRACE_SOURCE_TOOL_LIMIT, TRACE_SOURCE_TOOL_RESULT, TRACE_SOURCE_TOOL_SYSTEM_PROMPT, TRACE_SOURCE_USER, Text, USAGE_ENVELOPE_KEY, Video, WorkflowReporter, applyTriggerTransform, attachUsageToSyncResult, audioFromBase64, audioFromBuffer, audioFromFile, audioFromUrl, audioMediaType, buildProvider, buildSessionDefinition, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createExecutionLogger, createHarnessResult, createMetrics, createMultimodalResponse, createRawResult, decrypt, decryptToString, defaultToolErrorFormatter, defaultToolResultFormatter, deriveProvider, encryptForDid, encryptToJwk, ensureCliAvailable, eventTrigger, executeToolCallLoop, extractKeyAgreementJwk, fileFromBase64, fileFromBuffer, fileFromPath, fileFromUrl, findExecutable, generateX25519KeyPair, getCurrentContext, getCurrentSkillContext, guessUrlMimeType, harnessDoctor, imageFromBase64, imageFromBuffer, imageFromFile, imageFromUrl, installApprovalWebhookRoute, isActive, isExecutionLogBatchPayload, isTerminal, isTriggerEnvelope, loadFixture, normalizeExecutionLogEntry, normalizeSessionTransportValue, normalizeStatus, normalizeTurnDetection, resolveModelAndVariant, resolvePromptTemplates, resolveProviderName, scheduleTrigger, serializeExecutionLogEntry, simulateSchedule, simulateTrigger, splitModelVariant, text, triggerToPayload, unwrapEnvelope, usageSummaryOrNull, validateSessionTransport, videoFromBase64, videoFromBuffer, videoFromFile, videoFromUrl };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map