@poetic-ai/poetic 1.42.0

package/dist/api-transport-4TYTNLTJ.js

@@ -0,0 +1,1087 @@
+import {
+  TransportExecutionError
+} from "./chunk-DCYF7EKG.js";
+import {
+  UniversalCostCalculator,
+  resolveAvailableTotalCostUsd
+} from "./chunk-ASEP3M2W.js";
+import {
+  shouldExcludeFile
+} from "./chunk-NS33V3IM.js";
+import "./chunk-H2AYQIHW.js";
+import {
+  buildChildProcessEnv
+} from "./chunk-ZYG7GGKO.js";
+import {
+  TelemetryLogger
+} from "./chunk-CKNX3TTP.js";
+import "./chunk-FYOILAN5.js";
+import "./chunk-J62KPGII.js";
+import "./chunk-XAONGNST.js";
+import "./chunk-GAFJEYLK.js";
+import "./chunk-H6G7QRMQ.js";
+import "./chunk-J6P3FWWW.js";
+import "./chunk-CP7H3HSP.js";
+import "./chunk-ETYDXCK7.js";
+import "./chunk-BSE4R6XD.js";
+import "./chunk-UR2IBGIM.js";
+import "./chunk-JSWMRQYG.js";
+import "./chunk-XGYF2QMZ.js";
+import "./chunk-72YTZMAM.js";
+import "./chunk-S2VQCZO4.js";
+import "./chunk-WMPU2UOV.js";
+import "./chunk-VX3UMWB7.js";
+import "./chunk-XT2ZQVTC.js";
+import "./chunk-YGXKOBQQ.js";
+import "./chunk-V72RMBM4.js";
+import "./chunk-ZDTGECTN.js";
+import "./chunk-G36W2T2S.js";
+import "./chunk-GKN3HMN4.js";
+import "./chunk-QVZMFDYG.js";
+import "./chunk-S54MKU6V.js";
+import "./chunk-3S62LLWJ.js";
+import "./chunk-45FPSA3B.js";
+import "./chunk-YMX76IOS.js";
+import "./chunk-6Y5U7UFY.js";
+import "./chunk-XV7NZL4B.js";
+import "./chunk-CD7ISXA4.js";
+import "./chunk-QGJDMEOV.js";
+import {
+  isSandboxAuthorityEnvVar
+} from "./chunk-6TZJRKNW.js";
+import {
+  wrapWithSandbox
+} from "./chunk-PCAGC5MR.js";
+import "./chunk-5WCQRDRB.js";
+import "./chunk-5WRLK5KW.js";
+import "./chunk-C57KJOUQ.js";
+import "./chunk-DF5SLDE4.js";
+import "./chunk-TGON4N4O.js";
+import "./chunk-I5WRT7ZR.js";
+import "./chunk-A3YGID55.js";
+import "./chunk-5EERLVZB.js";
+import "./chunk-XQD2B6BB.js";
+import "./chunk-34CNP2HB.js";
+import "./chunk-KNDYMVWN.js";
+import "./chunk-RWREC3KJ.js";
+import "./chunk-LAMKBTXX.js";
+import "./chunk-FD4ERYEG.js";
+import "./chunk-KTMW65UX.js";
+import "./chunk-FHOWVDF5.js";
+import "./chunk-UDMS5AD3.js";
+import "./chunk-MWHLBPNU.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-TRSVUPCX.js";
+import "./chunk-FKAUPHMR.js";
+import "./chunk-TSXGRLPR.js";
+import "./chunk-LUVKFFWR.js";
+import "./chunk-ENRGKNR5.js";
+import "./chunk-XB5YLCLB.js";
+import "./chunk-QOCOVLUH.js";
+import "./chunk-2VSQMRCB.js";
+import {
+  modelSupportsAdaptiveThinking,
+  modelSupportsManualThinkingBudget,
+  resolveReasoningEffort
+} from "./chunk-ON3G73BU.js";
+import "./chunk-3G6FZCRF.js";
+import "./chunk-N5DX4JAK.js";
+import "./chunk-2QLYTVYX.js";
+import "./chunk-7GDRQBQC.js";
+import "./chunk-PGSPX4SU.js";
+import {
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+import "./chunk-GSGD5E4C.js";
+import "./chunk-UI2F6DJ5.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-L6OM4A22.js";
+import "./chunk-G4THLFV3.js";
+import "./chunk-RGWHUI5E.js";
+import "./chunk-UUH2RVKS.js";
+import "./chunk-LEIIWPWQ.js";
+import "./chunk-L7JZLXQL.js";
+import "./chunk-IZYIQQ7X.js";
+import "./chunk-JPKSXKNB.js";
+import "./chunk-TAJPCXSB.js";
+import "./chunk-XZE4XARH.js";
+import "./chunk-EJGCZGUF.js";
+import "./chunk-LPITVM7M.js";
+import "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/core/providers/shared/transports/api-tool-executor.ts
+import { constants as fsConstants } from "fs";
+import { lstat, mkdir, open, readFile, realpath, stat } from "fs/promises";
+import path from "path";
+import { execa } from "execa";
+var DEFAULT_MAX_READ_SIZE = 1 * 1024 * 1024;
+var DEFAULT_MAX_WRITE_SIZE = 10 * 1024 * 1024;
+var DEFAULT_MAX_BASH_OUTPUT = 100 * 1024;
+var API_TOOL_BLOCKED_ENV_KEYS = [
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "GOOGLE_APPLICATION_CREDENTIALS",
+  "GROK_CODE_XAI_API_KEY",
+  "XAI_API_KEY",
+  "OPENAI_API_KEY",
+  "OPENROUTER_API_KEY",
+  "OPENROUTER_KEY",
+  "BLACKBOX_API_KEY",
+  "AWS_SECRET_ACCESS_KEY",
+  "AWS_SESSION_TOKEN",
+  "AWS_ACCESS_KEY_ID",
+  "GITHUB_TOKEN",
+  "GH_TOKEN",
+  "SSH_AUTH_SOCK",
+  "GIT_SSH",
+  "GIT_SSH_COMMAND"
+];
+function requireStringInput(input, key) {
+  const value = input[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Tool input "${key}" must be a non-empty string`);
+  }
+  return value;
+}
+function optionalStringInput(input, key) {
+  const value = input[key];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Tool input "${key}" must be a non-empty string when provided`);
+  }
+  return value;
+}
+function buildApiToolEnv() {
+  const env = buildChildProcessEnv({ blockedKeys: API_TOOL_BLOCKED_ENV_KEYS });
+  for (const key of Object.keys(env)) {
+    if (isSandboxAuthorityEnvVar(key)) {
+      delete env[key];
+    }
+  }
+  return env;
+}
+var ApiToolExecutor = class {
+  workingDir;
+  perToolTimeoutMs;
+  maxReadFileSizeBytes;
+  maxWriteFileSizeBytes;
+  maxBashOutputBytes;
+  /** Tracks all files modified during this executor's lifetime. */
+  _filesModified = /* @__PURE__ */ new Set();
+  /** Resolved workingDir (resolves symlinks at construction time). */
+  resolvedWorkingDir;
+  constructor(workingDir, options) {
+    this.workingDir = workingDir;
+    this.perToolTimeoutMs = options.perToolTimeoutMs;
+    this.maxReadFileSizeBytes = options.maxReadFileSizeBytes ?? DEFAULT_MAX_READ_SIZE;
+    this.maxWriteFileSizeBytes = options.maxWriteFileSizeBytes ?? DEFAULT_MAX_WRITE_SIZE;
+    this.maxBashOutputBytes = options.maxBashOutputBytes ?? DEFAULT_MAX_BASH_OUTPUT;
+  }
+  /** Returns list of all files modified during execution. */
+  get filesModified() {
+    return Array.from(this._filesModified);
+  }
+  /**
+   * Execute a tool call by name.
+   *
+   * @throws Error for unknown tool names.
+   */
+  async executeTool(name, input, abortSignal) {
+    try {
+      if (abortSignal?.aborted) {
+        return { output: "", error: "Tool execution aborted" };
+      }
+      switch (name) {
+        case "read_file":
+          return this.readFile(requireStringInput(input, "path"));
+        case "write_file":
+          return this.writeFile(
+            requireStringInput(input, "path"),
+            requireStringInput(input, "content")
+          );
+        case "edit_file":
+          return this.editFile(
+            requireStringInput(input, "path"),
+            requireStringInput(input, "old_text"),
+            requireStringInput(input, "new_text")
+          );
+        case "bash":
+          return this.bash(requireStringInput(input, "command"), abortSignal);
+        case "list_files":
+          return this.listFiles(requireStringInput(input, "pattern"), abortSignal);
+        case "search_files":
+          return this.searchFiles(
+            requireStringInput(input, "pattern"),
+            optionalStringInput(input, "path"),
+            abortSignal
+          );
+        default:
+          return { output: "", error: `Unknown tool: ${name}` };
+      }
+    } catch (err) {
+      return { output: "", error: `Invalid tool input: ${err.message}` };
+    }
+  }
+  //  Path Security
+  /**
+   * Resolves a relative path to an absolute path within workingDir.
+   * Validates that the resolved real path is within the jail.
+   *
+   * @throws Error if path escapes the working directory.
+   */
+  /**
+   * Gets the real (symlink-resolved) working directory. Cached after first call.
+   */
+  async getResolvedWorkingDir() {
+    if (!this.resolvedWorkingDir) {
+      this.resolvedWorkingDir = await realpath(this.workingDir);
+    }
+    return this.resolvedWorkingDir;
+  }
+  async resolveAndValidatePath(inputPath) {
+    const resolvedWd = await this.getResolvedWorkingDir();
+    const resolved = path.resolve(resolvedWd, inputPath);
+    if (!resolved.startsWith(resolvedWd + path.sep) && resolved !== resolvedWd) {
+      throw new Error(`Path '${inputPath}' escapes working directory`);
+    }
+    try {
+      const real = await realpath(resolved);
+      if (!real.startsWith(resolvedWd + path.sep) && real !== resolvedWd) {
+        throw new Error(`Path '${inputPath}' resolves outside working directory via symlink`);
+      }
+      return real;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        await this.rejectDanglingFinalSymlink(resolved, inputPath);
+        await this.validateNearestExistingParent(resolved, resolvedWd, inputPath);
+        return resolved;
+      }
+      throw err;
+    }
+  }
+  async rejectDanglingFinalSymlink(resolvedPath, inputPath) {
+    try {
+      const stats = await lstat(resolvedPath);
+      if (stats.isSymbolicLink()) {
+        throw new Error(`Path '${inputPath}' resolves outside working directory via symlink`);
+      }
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return;
+      }
+      throw err;
+    }
+  }
+  async validateNearestExistingParent(resolvedPath, resolvedWd, inputPath) {
+    let parent = path.dirname(resolvedPath);
+    while (parent.startsWith(resolvedWd + path.sep) && parent !== resolvedWd) {
+      try {
+        const realParent2 = await realpath(parent);
+        if (!realParent2.startsWith(resolvedWd + path.sep) && realParent2 !== resolvedWd) {
+          throw new Error(`Path '${inputPath}' resolves outside working directory via symlink`);
+        }
+        return;
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          parent = path.dirname(parent);
+          continue;
+        }
+        throw err;
+      }
+    }
+    const realParent = await realpath(resolvedWd);
+    if (realParent !== resolvedWd) {
+      throw new Error("Working directory changed during path validation");
+    }
+  }
+  /**
+   * Returns a repo-relative path for tracking.
+   */
+  relativePath(absolutePath) {
+    const base = this.resolvedWorkingDir ?? this.workingDir;
+    return path.relative(base, absolutePath);
+  }
+  async assertWritePathAllowed(inputPath) {
+    const base = await this.getResolvedWorkingDir();
+    const resolved = path.resolve(base, inputPath);
+    const normalized = path.relative(base, resolved).replace(/\\/g, "/").toLowerCase();
+    if (normalized.startsWith("..") || path.isAbsolute(normalized)) {
+      throw new Error(`Path '${inputPath}' escapes working directory`);
+    }
+    const segments = normalized.split("/").filter(Boolean);
+    if (segments.includes(".git") || shouldExcludeFile(normalized)) {
+      throw new Error(`Path '${inputPath}' is an excluded repository authority path`);
+    }
+  }
+  async writeFileNoFollow(targetPath, content) {
+    const noFollow = fsConstants.O_NOFOLLOW ?? 0;
+    const flags = fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_TRUNC | noFollow;
+    const handle = await open(targetPath, flags);
+    try {
+      await handle.writeFile(content, "utf8");
+    } finally {
+      await handle.close();
+    }
+  }
+  //  Tool Implementations
+  async readFile(filePath) {
+    try {
+      const resolved = await this.resolveAndValidatePath(filePath);
+      const stats = await stat(resolved);
+      if (stats.size > this.maxReadFileSizeBytes) {
+        return {
+          output: "",
+          error: `File too large: ${stats.size} bytes (limit: ${this.maxReadFileSizeBytes} bytes)`
+        };
+      }
+      const content = await readFile(resolved, "utf-8");
+      return { output: content };
+    } catch (err) {
+      return { output: "", error: `read_file error: ${err.message}` };
+    }
+  }
+  async writeFile(filePath, content) {
+    try {
+      await this.assertWritePathAllowed(filePath);
+      if (Buffer.byteLength(content, "utf-8") > this.maxWriteFileSizeBytes) {
+        return {
+          output: "",
+          error: `Content too large (limit: ${this.maxWriteFileSizeBytes} bytes)`
+        };
+      }
+      const resolved = await this.resolveAndValidatePath(filePath);
+      await this.assertWritePathAllowed(resolved);
+      await mkdir(path.dirname(resolved), { recursive: true });
+      await this.writeFileNoFollow(resolved, content);
+      const rel = this.relativePath(resolved);
+      this._filesModified.add(rel);
+      return { output: `Wrote ${rel}`, filesModified: [rel] };
+    } catch (err) {
+      return { output: "", error: `write_file error: ${err.message}` };
+    }
+  }
+  async editFile(filePath, oldText, newText) {
+    try {
+      await this.assertWritePathAllowed(filePath);
+      const resolved = await this.resolveAndValidatePath(filePath);
+      await this.assertWritePathAllowed(resolved);
+      const content = await readFile(resolved, "utf-8");
+      const index = content.indexOf(oldText);
+      if (index === -1) {
+        return { output: "", error: `old_text not found in ${filePath}` };
+      }
+      const secondIndex = content.indexOf(oldText, index + 1);
+      if (secondIndex !== -1) {
+        return {
+          output: "",
+          error: `old_text matches multiple locations in ${filePath}. Provide more context.`
+        };
+      }
+      const updated = content.slice(0, index) + newText + content.slice(index + oldText.length);
+      await this.writeFileNoFollow(resolved, updated);
+      const rel = this.relativePath(resolved);
+      this._filesModified.add(rel);
+      return { output: `Edited ${rel}`, filesModified: [rel] };
+    } catch (err) {
+      return { output: "", error: `edit_file error: ${err.message}` };
+    }
+  }
+  async bash(command, abortSignal) {
+    try {
+      const sandboxed = wrapWithSandbox({
+        workingDir: this.workingDir,
+        command: "bash",
+        args: ["-c", command],
+        providerName: "api-transport",
+        extraWritePaths: ["/tmp"],
+        // Runs a model-supplied shell command with write access, so it must not
+        // proceed without an accepted boundary. The sibling listFiles/grep tools
+        // are read-only and deliberately do not opt in.
+        requiresBoundaryForWrites: true
+      });
+      const result = await execa(sandboxed.command, sandboxed.args, {
+        cwd: this.workingDir,
+        timeout: this.perToolTimeoutMs,
+        reject: false,
+        env: buildApiToolEnv(),
+        extendEnv: false,
+        cancelSignal: abortSignal
+      });
+      let stdout = result.stdout ?? "";
+      let stderr = result.stderr ?? "";
+      if (Buffer.byteLength(stdout, "utf-8") > this.maxBashOutputBytes) {
+        stdout = `${stdout.slice(0, this.maxBashOutputBytes)}
+[truncated]`;
+      }
+      if (Buffer.byteLength(stderr, "utf-8") > this.maxBashOutputBytes) {
+        stderr = `${stderr.slice(0, this.maxBashOutputBytes)}
+[truncated]`;
+      }
+      if (result.exitCode !== 0) {
+        return {
+          output: stdout,
+          error: `Exit code ${result.exitCode}: ${stderr}`
+        };
+      }
+      return { output: stdout || "(no output)" };
+    } catch (err) {
+      return { output: "", error: `bash error: ${err.message}` };
+    }
+  }
+  async listFiles(pattern, abortSignal) {
+    try {
+      const sandboxed = wrapWithSandbox({
+        workingDir: this.workingDir,
+        command: "find",
+        args: [
+          ".",
+          "-name",
+          pattern,
+          "-not",
+          "-path",
+          "*/node_modules/*",
+          "-not",
+          "-path",
+          "*/.git/*",
+          "-type",
+          "f"
+        ],
+        providerName: "api-transport",
+        readOnlyWorkingDir: true
+      });
+      const result = await execa(sandboxed.command, sandboxed.args, {
+        cwd: this.workingDir,
+        timeout: this.perToolTimeoutMs,
+        reject: false,
+        env: buildApiToolEnv(),
+        extendEnv: false,
+        cancelSignal: abortSignal
+      });
+      const stdout = result.stdout ?? "";
+      if (!stdout.trim()) {
+        return { output: "No files found." };
+      }
+      const matches = stdout.split("\n").filter(Boolean).map((f) => f.replace(/^\.\//, ""));
+      const capped = matches.slice(0, 500);
+      const output = capped.join("\n");
+      if (matches.length > 500) {
+        return { output: `${output}
+... and ${matches.length - 500} more` };
+      }
+      return { output };
+    } catch (err) {
+      return { output: "", error: `list_files error: ${err.message}` };
+    }
+  }
+  async searchFiles(pattern, searchPath, abortSignal) {
+    try {
+      const searchDir = searchPath ? await this.resolveAndValidatePath(searchPath) : await this.getResolvedWorkingDir();
+      const sandboxed = wrapWithSandbox({
+        workingDir: this.workingDir,
+        command: "grep",
+        args: ["-rn", "-l", "-e", pattern, "--", searchDir],
+        providerName: "api-transport",
+        readOnlyWorkingDir: true
+      });
+      const result = await execa(sandboxed.command, sandboxed.args, {
+        cwd: this.workingDir,
+        timeout: this.perToolTimeoutMs,
+        reject: false,
+        env: buildApiToolEnv(),
+        extendEnv: false,
+        cancelSignal: abortSignal
+      });
+      const stdout = result.stdout ?? "";
+      if (!stdout.trim()) {
+        return { output: "No matches found." };
+      }
+      const lines = stdout.split("\n").filter(Boolean).map((line) => path.relative(this.resolvedWorkingDir ?? this.workingDir, line)).slice(0, 200);
+      return { output: lines.join("\n") };
+    } catch (err) {
+      return { output: "", error: `search_files error: ${err.message}` };
+    }
+  }
+};
+
+// src/core/providers/shared/transports/api-transport.ts
+var CODING_TOOLS = [
+  {
+    name: "read_file",
+    description: "Read the contents of a file at the given path",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path from working directory" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "write_file",
+    description: "Write content to a file, creating it if needed",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path from working directory" },
+        content: { type: "string", description: "Full file content to write" }
+      },
+      required: ["path", "content"]
+    }
+  },
+  {
+    name: "edit_file",
+    description: "Replace exact text in a file (old_text must match uniquely)",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path" },
+        old_text: { type: "string", description: "Exact text to find" },
+        new_text: { type: "string", description: "Replacement text" }
+      },
+      required: ["path", "old_text", "new_text"]
+    }
+  },
+  {
+    name: "bash",
+    description: "Run a bash command in the working directory",
+    input_schema: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "Bash command to execute" }
+      },
+      required: ["command"]
+    }
+  },
+  {
+    name: "list_files",
+    description: "List files matching a glob pattern",
+    input_schema: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: 'Glob pattern (e.g., "src/**/*.ts")' }
+      },
+      required: ["pattern"]
+    }
+  },
+  {
+    name: "search_files",
+    description: "Search file contents with a regex pattern",
+    input_schema: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: "Regex pattern to search for" },
+        path: { type: "string", description: "Directory to search in (optional)" }
+      },
+      required: ["pattern"]
+    }
+  }
+];
+var CODING_TOOL_NAMES = CODING_TOOLS.map((t) => t.name);
+var READ_ONLY_CODING_TOOL_NAMES = /* @__PURE__ */ new Set(["read_file", "list_files", "search_files"]);
+function resolveRequestCodingTools(request) {
+  let tools = request.tools !== void 0 ? request.tools : CODING_TOOLS;
+  if (request.allowedTools !== void 0) {
+    const allow = new Set(request.allowedTools);
+    tools = tools.filter((tool) => allow.has(tool.name));
+  }
+  if (request.disallowedTools !== void 0 && request.disallowedTools.length > 0) {
+    const deny = new Set(request.disallowedTools);
+    tools = tools.filter((tool) => !deny.has(tool.name));
+  }
+  if (request.readOnlyWorkingDir === true) {
+    tools = tools.filter((tool) => READ_ONLY_CODING_TOOL_NAMES.has(tool.name));
+  }
+  return tools;
+}
+function buildStructuredOutputToolName(request) {
+  const normalized = request.name.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "").slice(0, 59);
+  return `emit_${normalized || "structured_output"}`;
+}
+function buildStructuredOutputTool(request) {
+  return {
+    name: buildStructuredOutputToolName(request),
+    description: request.description ?? `Emit ${request.name} as schema-constrained JSON.`,
+    input_schema: request.schema
+  };
+}
+async function loadAnthropicSdk() {
+  try {
+    const module = await import("@anthropic-ai/sdk");
+    return module.default;
+  } catch (error) {
+    const details = error instanceof Error ? error.message : String(error);
+    throw new TransportExecutionError(
+      `Anthropic SDK is required for API transport but is not available. Install dependencies (npm ci). Details: ${details}`,
+      "api",
+      { retryable: false, reason: "missing_runtime_dependency" }
+    );
+  }
+}
+function isAnthropicApiError(err) {
+  return typeof err === "object" && err !== null && typeof err.status === "number" && (err.name === "APIError" || typeof err.error?.type === "string");
+}
+var ApiTransport = class _ApiTransport {
+  type = "api";
+  static costCalculator = null;
+  async execute(request) {
+    const meta = request.transportMeta;
+    const apiConfig = meta?.apiConfig;
+    if (!apiConfig?.base_url || !apiConfig?.api_key_env_var) {
+      throw new TransportExecutionError(
+        "ApiTransport requires transportMeta.apiConfig with base_url and api_key_env_var",
+        "api",
+        { retryable: false, reason: "missing_api_config" }
+      );
+    }
+    const apiKey = request.env?.[apiConfig.api_key_env_var] ?? process.env[apiConfig.api_key_env_var];
+    if (!apiKey) {
+      throw new TransportExecutionError(
+        `API key not found in environment variable '${apiConfig.api_key_env_var}'`,
+        "api",
+        { retryable: false, reason: "missing_api_key" }
+      );
+    }
+    const baseURL = apiConfig.base_url.replace(/\/+$/, "").replace(/\/v1(?:\/messages)?$/, "");
+    if (!request.model) {
+      throw new TransportExecutionError(
+        "ApiTransport requires request.model to be set (no hardcoded fallback)",
+        "api",
+        { retryable: false, reason: "missing_model" }
+      );
+    }
+    const AnthropicSdk = await loadAnthropicSdk();
+    const client = new AnthropicSdk({
+      apiKey,
+      baseURL,
+      defaultHeaders: apiConfig.headers
+    });
+    const maxIterations = apiConfig.max_tool_iterations ?? 50;
+    const perToolTimeoutMs = apiConfig.per_tool_timeout_ms ?? 3e4;
+    const overallTimeoutMs = normalizeOverallTimeoutMs(request.timeout);
+    const startTime = Date.now();
+    const executor = new ApiToolExecutor(request.workingDir, {
+      perToolTimeoutMs
+    });
+    const structuredOutputTool = request.structuredOutput ? buildStructuredOutputTool(request.structuredOutput) : void 0;
+    const codingTools = resolveRequestCodingTools(request);
+    const tools = structuredOutputTool ? [structuredOutputTool] : codingTools;
+    const executableToolNames = new Set(tools.map((tool) => tool.name));
+    const messages = [{ role: "user", content: request.prompt }];
+    const textParts = [];
+    const allToolInvocations = [];
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCacheReadTokens = 0;
+    let totalCacheCreationTokens = 0;
+    let iteration = 0;
+    try {
+      while (iteration < maxIterations) {
+        if (request.abortSignal?.aborted) {
+          return this.buildResult(
+            textParts,
+            allToolInvocations,
+            executor,
+            "aborted",
+            {
+              inputTokens: totalInputTokens,
+              outputTokens: totalOutputTokens,
+              cacheReadTokens: totalCacheReadTokens,
+              cacheCreationTokens: totalCacheCreationTokens
+            },
+            request.model
+          );
+        }
+        if (overallTimeoutMs && Date.now() - startTime > overallTimeoutMs) {
+          return this.buildResult(
+            textParts,
+            allToolInvocations,
+            executor,
+            "timeout",
+            {
+              inputTokens: totalInputTokens,
+              outputTokens: totalOutputTokens,
+              cacheReadTokens: totalCacheReadTokens,
+              cacheCreationTokens: totalCacheCreationTokens
+            },
+            request.model
+          );
+        }
+        const elapsed = Date.now() - startTime;
+        const remainingMs = overallTimeoutMs ? overallTimeoutMs - elapsed : void 0;
+        const response = await this.callApi(client, {
+          model: request.model,
+          system: request.systemPrompt,
+          messages,
+          tools,
+          maxTokens: apiConfig.max_tokens ?? 16384,
+          reasoningEffort: request.generationSettings?.reasoningEffort,
+          thinkingBudget: request.generationSettings?.thinkingBudget,
+          toolChoice: structuredOutputTool ? { type: "tool", name: structuredOutputTool.name } : void 0,
+          stream: apiConfig.stream ?? true,
+          onData: request.onData,
+          abortSignal: request.abortSignal,
+          timeoutMs: remainingMs
+        });
+        totalInputTokens += response.usage.input_tokens;
+        totalOutputTokens += response.usage.output_tokens;
+        const cacheTokens = response.usage.cache_read_input_tokens;
+        if (typeof cacheTokens === "number" && Number.isFinite(cacheTokens)) {
+          totalCacheReadTokens += cacheTokens;
+        }
+        const cacheCreationTokens = response.usage.cache_creation_input_tokens;
+        if (typeof cacheCreationTokens === "number" && Number.isFinite(cacheCreationTokens)) {
+          totalCacheCreationTokens += cacheCreationTokens;
+        }
+        const toolUseBlocks = [];
+        for (const block of response.content) {
+          if (block.type === "text") {
+            if (!structuredOutputTool) {
+              textParts.push(block.text);
+              request.onData?.(block.text);
+            }
+          } else if (block.type === "tool_use") {
+            toolUseBlocks.push(block);
+          }
+        }
+        if (structuredOutputTool) {
+          const structuredBlock = toolUseBlocks.find(
+            (block) => block.name === structuredOutputTool.name
+          );
+          if (!structuredBlock) {
+            return {
+              ...this.buildResult(
+                [],
+                allToolInvocations,
+                executor,
+                "error",
+                {
+                  inputTokens: totalInputTokens,
+                  outputTokens: totalOutputTokens,
+                  cacheReadTokens: totalCacheReadTokens,
+                  cacheCreationTokens: totalCacheCreationTokens
+                },
+                request.model
+              ),
+              stderr: `Structured output tool ${structuredOutputTool.name} was not returned`,
+              errorCode: "structured_output_missing"
+            };
+          }
+          const output = JSON.stringify(structuredBlock.input);
+          request.onData?.(output);
+          const structuredInvocations = [
+            {
+              name: structuredBlock.name,
+              input: structuredBlock.input,
+              output,
+              durationMs: 0
+            }
+          ];
+          return this.buildResult(
+            [output],
+            structuredInvocations,
+            executor,
+            "success",
+            {
+              inputTokens: totalInputTokens,
+              outputTokens: totalOutputTokens,
+              cacheReadTokens: totalCacheReadTokens,
+              cacheCreationTokens: totalCacheCreationTokens
+            },
+            request.model
+          );
+        }
+        if (toolUseBlocks.length === 0) {
+          const status = response.stop_reason === "max_tokens" ? "error" : "success";
+          const result = this.buildResult(
+            textParts,
+            allToolInvocations,
+            executor,
+            status,
+            {
+              inputTokens: totalInputTokens,
+              outputTokens: totalOutputTokens,
+              cacheReadTokens: totalCacheReadTokens,
+              cacheCreationTokens: totalCacheCreationTokens
+            },
+            request.model
+          );
+          if (response.stop_reason === "max_tokens") {
+            return {
+              ...result,
+              stderr: "Claude API response stopped at max_tokens before completion",
+              errorCode: "output_truncated"
+            };
+          }
+          return this.buildResult(
+            textParts,
+            allToolInvocations,
+            executor,
+            "success",
+            {
+              inputTokens: totalInputTokens,
+              outputTokens: totalOutputTokens,
+              cacheReadTokens: totalCacheReadTokens,
+              cacheCreationTokens: totalCacheCreationTokens
+            },
+            request.model
+          );
+        }
+        const toolResults = [];
+        for (const toolUse of toolUseBlocks) {
+          if (request.abortSignal?.aborted) {
+            return this.buildResult(
+              textParts,
+              allToolInvocations,
+              executor,
+              "aborted",
+              {
+                inputTokens: totalInputTokens,
+                outputTokens: totalOutputTokens,
+                cacheReadTokens: totalCacheReadTokens,
+                cacheCreationTokens: totalCacheCreationTokens
+              },
+              request.model
+            );
+          }
+          const toolStart = Date.now();
+          const toolResult = executableToolNames.has(toolUse.name) ? await executor.executeTool(
+            toolUse.name,
+            toolUse.input,
+            request.abortSignal
+          ) : {
+            output: "",
+            error: `Tool "${toolUse.name}" is not available for this request`
+          };
+          const toolDuration = Date.now() - toolStart;
+          allToolInvocations.push({
+            name: toolUse.name,
+            input: toolUse.input,
+            output: toolResult.output,
+            durationMs: toolDuration,
+            error: toolResult.error
+          });
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: toolUse.id,
+            content: toolResult.error ? `Error: ${toolResult.error}` : toolResult.output,
+            is_error: !!toolResult.error
+          });
+        }
+        messages.push({ role: "assistant", content: response.content });
+        messages.push({ role: "user", content: toolResults });
+        iteration++;
+      }
+      textParts.push(`
+[Transport: max tool iterations (${maxIterations}) reached]`);
+      return this.buildResult(
+        textParts,
+        allToolInvocations,
+        executor,
+        "error",
+        {
+          inputTokens: totalInputTokens,
+          outputTokens: totalOutputTokens,
+          cacheReadTokens: totalCacheReadTokens,
+          cacheCreationTokens: totalCacheCreationTokens
+        },
+        request.model
+      );
+    } catch (err) {
+      return this.handleApiError(
+        err,
+        textParts,
+        allToolInvocations,
+        executor,
+        {
+          inputTokens: totalInputTokens,
+          outputTokens: totalOutputTokens,
+          cacheReadTokens: totalCacheReadTokens,
+          cacheCreationTokens: totalCacheCreationTokens
+        },
+        AnthropicSdk,
+        request.model
+      );
+    }
+  }
+  /**
+   * Makes a single API call, optionally streaming.
+   */
+  async callApi(client, params) {
+    const requestParams = {
+      model: params.model,
+      max_tokens: params.maxTokens,
+      messages: params.messages,
+      tools: params.tools
+    };
+    if (params.toolChoice) {
+      requestParams.tool_choice = params.toolChoice;
+    }
+    if (params.system) {
+      requestParams.system = params.system;
+    }
+    const requestParamsWithThinking = requestParams;
+    if (!params.toolChoice) {
+      const supportsAdaptiveThinking = modelSupportsAdaptiveThinking("claude", params.model);
+      const supportsManualThinkingBudget = modelSupportsManualThinkingBudget(
+        "claude",
+        params.model
+      );
+      const requestedEffort = params.reasoningEffort ?? (supportsAdaptiveThinking ? "high" : void 0);
+      if (requestedEffort) {
+        const effortResolution = resolveReasoningEffort(
+          "claude",
+          requestedEffort,
+          false,
+          params.model
+        );
+        requestParamsWithThinking.output_config = {
+          effort: effortResolution.nativeParam ?? effortResolution.resolvedLevel
+        };
+      }
+      if (supportsAdaptiveThinking) {
+        requestParamsWithThinking.thinking = { type: "adaptive" };
+      } else if (supportsManualThinkingBudget && typeof params.thinkingBudget === "number" && Number.isFinite(params.thinkingBudget) && params.thinkingBudget > 0) {
+        requestParamsWithThinking.thinking = {
+          type: "enabled",
+          budget_tokens: Math.floor(params.thinkingBudget)
+        };
+      }
+    }
+    const response = await client.messages.create(requestParams, {
+      signal: params.abortSignal,
+      timeout: params.timeoutMs
+    });
+    return response;
+  }
+  /**
+   * Builds a TransportResult from accumulated data.
+   */
+  buildResult(textParts, toolInvocations, executor, status, usage, model) {
+    const totalCostUsd = model ? this.calculateCostUsd(model, usage) : void 0;
+    return {
+      stdout: textParts.join("\n"),
+      stderr: "",
+      status,
+      tokenUsage: {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cachedInputTokens: usage.cacheReadTokens || void 0,
+        cacheCreationInputTokens: usage.cacheCreationTokens || void 0
+      },
+      totalCostUsd,
+      toolInvocations,
+      filesModified: executor.filesModified
+    };
+  }
+  /**
+   * Maps API errors to TransportResult.
+   */
+  handleApiError(err, textParts, toolInvocations, executor, usage, anthropicSdk, model) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    let status = "error";
+    let errorCode;
+    let retryable = false;
+    const runtimeApiErrorCtor = anthropicSdk?.APIError;
+    const isSdkApiError = runtimeApiErrorCtor ? err instanceof runtimeApiErrorCtor : false;
+    if (isSdkApiError || isAnthropicApiError(err)) {
+      const statusCode = Number(err.status);
+      const typedErrorCode = typeof err.error?.type === "string" ? err.error?.type : void 0;
+      errorCode = typedErrorCode ?? (Number.isFinite(statusCode) ? `http_${statusCode}` : void 0);
+      if (statusCode === 529 || errorCode === "overloaded_error") {
+        errorCode = "overloaded_error";
+      } else if (statusCode === 429) {
+        errorCode = "rate_limit_error";
+      }
+      if (Number.isFinite(statusCode)) {
+        retryable = statusCode === 408 || statusCode === 425 || statusCode === 429 || statusCode >= 500 && statusCode <= 599;
+      }
+    }
+    if (err instanceof Error && (err.name === "AbortError" || err.message.includes("aborted"))) {
+      status = "aborted";
+      retryable = false;
+    } else if (err instanceof Error && (err.name === "APIConnectionTimeoutError" || err.name === "TimeoutError" || err.message.toLowerCase().includes("request timed out"))) {
+      status = "timeout";
+      errorCode = errorCode ?? "timeout";
+      retryable = true;
+    } else if (status === "error" && !retryable && err instanceof Error && (err.name === "APIConnectionError" || /econnreset|econnrefused|enotfound|eai_again|socket hang up|fetch failed|network error/i.test(
+      err.message
+    ))) {
+      retryable = true;
+    }
+    return {
+      stdout: textParts.join("\n"),
+      stderr: errorMessage,
+      status,
+      errorCode,
+      retryable,
+      tokenUsage: {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cachedInputTokens: usage.cacheReadTokens || void 0,
+        cacheCreationInputTokens: usage.cacheCreationTokens || void 0
+      },
+      totalCostUsd: model ? this.calculateCostUsd(model, usage) : void 0,
+      toolInvocations,
+      filesModified: executor.filesModified
+    };
+  }
+  getCostCalculator() {
+    if (!_ApiTransport.costCalculator) {
+      _ApiTransport.costCalculator = new UniversalCostCalculator(TelemetryLogger.getInstance());
+      _ApiTransport.costCalculator.ensurePricingLoadedSync();
+    }
+    return _ApiTransport.costCalculator;
+  }
+  calculateCostUsd(model, usage) {
+    try {
+      const amount = resolveAvailableTotalCostUsd(
+        this.getCostCalculator().calculateCost("claude", this.resolveCostModelId(model), {
+          inputTokens: usage.inputTokens,
+          outputTokens: usage.outputTokens,
+          cacheReadTokens: usage.cacheReadTokens || void 0,
+          cacheWriteTokens: usage.cacheCreationTokens || void 0,
+          tools: []
+        })
+      );
+      return amount === null ? void 0 : amount;
+    } catch {
+      return void 0;
+    }
+  }
+  resolveCostModelId(model) {
+    try {
+      const available = ProviderRegistry.getProviderConfig("claude").models.available;
+      const trimmed = model.trim();
+      const matched = available.find(
+        (entry) => entry.id === trimmed || entry.full_name === trimmed || entry.routing_id === trimmed || entry.canonical_id === trimmed
+      );
+      return matched?.id ?? trimmed;
+    } catch {
+      return model;
+    }
+  }
+};
+function normalizeOverallTimeoutMs(timeout) {
+  if (timeout === void 0) {
+    return void 0;
+  }
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    throw new TransportExecutionError(
+      `ApiTransport requires a positive finite timeout, received ${String(timeout)}`,
+      "api",
+      { retryable: false, reason: "invalid_timeout" }
+    );
+  }
+  return timeout;
+}
+export {
+  ApiTransport,
+  CODING_TOOL_NAMES,
+  resolveRequestCodingTools
+};
+//# sourceMappingURL=api-transport-4TYTNLTJ.js.map