@trailstep/core 0.1.0 → 0.1.1

package/dist/index.js

@@ -192,17 +192,21 @@ function parseTargetArray(path, value, diagnostics) {
         `${targetPath}.thinking must be one of low, medium, high, xhigh, or max when present.`
       );
     }
+    const model = typeof target.model === "string" ? optionalNonEmptyString(target.model) : void 0;
     const args = parseOptionalStringArray(`${targetPath}.args`, target.args, diagnostics);
     return [
       {
         provider: target.provider,
-        ...typeof target.model === "string" ? { model: target.model } : {},
+        ...model === void 0 ? {} : { model },
         ...typeof target.thinking === "string" && THINKING_LEVELS.has(target.thinking) ? { thinking: target.thinking } : {},
         ...args === void 0 ? {} : { args }
       }
     ];
   });
 }
+function optionalNonEmptyString(value) {
+  return value.trim().length === 0 ? void 0 : value;
+}
 
 // src/agent-targeting/parse-trailstep-config/parse-agent-mappings.ts
 function parseAgentMappings(path, value, diagnostics) {
@@ -218,6 +222,7 @@ function parseAgentMappings(path, value, diagnostics) {
 }
 
 // src/agent-targeting/parse-trailstep-config/parse-custom-providers.ts
+var THINKING_LEVELS2 = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max"]);
 function parseCustomProviders(value, diagnostics) {
   const customProviders = {};
   if (!isRecord(value)) {
@@ -243,6 +248,16 @@ function parseCustomProviders(value, diagnostics) {
       providerConfig.interactiveArgs,
       diagnostics
     );
+    const model = parseCustomProviderModelSupport(
+      `customProviders.${name}.model`,
+      providerConfig.model,
+      diagnostics
+    );
+    const thinking = parseCustomProviderThinkingSupport(
+      `customProviders.${name}.thinking`,
+      providerConfig.thinking,
+      diagnostics
+    );
     const env = parseOptionalStringRecord(
       `customProviders.${name}.env`,
       providerConfig.env,
@@ -255,12 +270,74 @@ function parseCustomProviders(value, diagnostics) {
       binary: providerConfig.binary,
       ...args === void 0 ? {} : { args },
       ...interactiveArgs === void 0 ? {} : { interactiveArgs },
+      ...model === void 0 ? {} : { model },
+      ...thinking === void 0 ? {} : { thinking },
       ...typeof providerConfig.cwd === "string" ? { cwd: providerConfig.cwd } : {},
       ...env === void 0 ? {} : { env }
     };
   }
   return customProviders;
 }
+function parseCustomProviderModelSupport(path, value, diagnostics) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value) || typeof value.supported !== "boolean") {
+    diagnostics.push(`${path} must be an object with a boolean supported field when present.`);
+    return void 0;
+  }
+  if (!value.supported) {
+    return { supported: false };
+  }
+  if (value.flag !== void 0 && (typeof value.flag !== "string" || value.flag.length === 0)) {
+    diagnostics.push(`${path}.flag must be a non-empty string when present.`);
+    return void 0;
+  }
+  return {
+    supported: true,
+    ...typeof value.flag === "string" ? { flag: value.flag } : {}
+  };
+}
+function parseCustomProviderThinkingSupport(path, value, diagnostics) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value) || typeof value.supported !== "boolean") {
+    diagnostics.push(`${path} must be an object with a boolean supported field when present.`);
+    return void 0;
+  }
+  if (!value.supported) {
+    if (value.levels !== void 0 && (!Array.isArray(value.levels) || value.levels.length > 0)) {
+      diagnostics.push(`${path}.levels must be an empty array when thinking support is disabled.`);
+      return void 0;
+    }
+    return value.levels === void 0 ? { supported: false } : { supported: false, levels: [] };
+  }
+  if (value.flag !== void 0 && (typeof value.flag !== "string" || value.flag.length === 0)) {
+    diagnostics.push(`${path}.flag must be a non-empty string when present.`);
+    return void 0;
+  }
+  if (!Array.isArray(value.levels) || value.levels.length === 0) {
+    diagnostics.push(`${path}.levels must be a non-empty array of supported thinking levels.`);
+    return void 0;
+  }
+  const levels = [];
+  for (const [index, level] of value.levels.entries()) {
+    if (typeof level !== "string" || !THINKING_LEVELS2.has(level)) {
+      diagnostics.push(`${path}.levels[${index}] must be one of low, medium, high, xhigh, or max.`);
+      continue;
+    }
+    levels.push(level);
+  }
+  if (levels.length !== value.levels.length) {
+    return void 0;
+  }
+  return {
+    supported: true,
+    ...typeof value.flag === "string" ? { flag: value.flag } : {},
+    levels
+  };
+}
 
 // src/agent-targeting/parse-trailstep-config/parse-settings.ts
 function parseSettings(path, value, diagnostics) {
@@ -530,6 +607,41 @@ function promptFileReference(promptFile) {
 
 // src/known-cli-providers/providers/claude/claude-provider.ts
 var CLAUDE_BINARY = "claude";
+var CLAUDE_RESULT_FIELD = "result";
+var CLAUDE_SPEC = {
+  id: "claude",
+  displayName: "Claude",
+  model: { supported: true, flag: "--model" },
+  thinking: {
+    supported: true,
+    flag: "--effort",
+    levels: ["low", "medium", "high", "xhigh", "max"]
+  },
+  working: {
+    command: CLAUDE_BINARY,
+    prompt: { kind: "prompt-file", reference: "at-prefixed-argument" },
+    baseArgs: [
+      "-p",
+      "@{{promptFile}}",
+      "--output-format",
+      "json",
+      "--dangerously-skip-permissions"
+    ],
+    output: {
+      style: "stdout-json-envelope",
+      parsing: { resultField: CLAUDE_RESULT_FIELD }
+    },
+    repair: { supported: true, resumeFlag: "--resume", promptDelivery: "stdin" }
+  },
+  interactive: {
+    supported: true,
+    command: CLAUDE_BINARY,
+    requiresSystemPromptFile: true,
+    systemPromptFileFlag: "--append-system-prompt-file",
+    modelFlag: "--model",
+    permissionBypassFlag: "--dangerously-skip-permissions"
+  }
+};
 async function runWorking(request, runner = spawnClaudeCapturingStdout) {
   const args = buildClaudeWorkingArgs(request);
   let result;
@@ -569,7 +681,7 @@ function extractFailureContext(rawStdout) {
   const metadata = extractEnvelopeMetadata(rawStdout, { harnessDurationMs: 0 });
   let rawResultText;
   try {
-    rawResultText = extractEnvelopeText(rawStdout, { resultField: "result" });
+    rawResultText = extractEnvelopeText(rawStdout, { resultField: CLAUDE_RESULT_FIELD });
   } catch {
     rawResultText = void 0;
   }
@@ -583,7 +695,7 @@ async function writeCapturedOutput(options) {
   if (options.captureMode === "raw-text") {
     let text;
     try {
-      text = extractEnvelopeText(options.stdout, { resultField: "result" });
+      text = extractEnvelopeText(options.stdout, { resultField: CLAUDE_RESULT_FIELD });
     } catch (error) {
       throw new TrailStepFailureError({
         code: "agent_provider_output_invalid",
@@ -598,7 +710,7 @@ async function writeCapturedOutput(options) {
   } else {
     let output;
     try {
-      output = extractEnvelopeOutput(options.stdout, { resultField: "result" });
+      output = extractEnvelopeOutput(options.stdout, { resultField: CLAUDE_RESULT_FIELD });
     } catch (error) {
       throw new TrailStepFailureError({
         code: "agent_provider_output_invalid",
@@ -819,6 +931,7 @@ function terminateChildProcessTree(child) {
 }
 var claudeProvider = {
   id: "claude",
+  spec: CLAUDE_SPEC,
   runWorking,
   repairOutput,
   runInteractive
@@ -827,7 +940,31 @@ var claudeProvider = {
 // src/known-cli-providers/providers/codex/codex-provider.ts
 import { spawn as spawn2 } from "child_process";
 var CODEX_BINARY = "codex";
-var SUPPORTED_CODEX_THINKING = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh"]);
+var CODEX_THINKING_LEVELS = ["low", "medium", "high", "xhigh"];
+var SUPPORTED_CODEX_THINKING = new Set(CODEX_THINKING_LEVELS);
+var CODEX_SPEC = {
+  id: "codex",
+  displayName: "Codex",
+  model: { supported: true, flag: "-m" },
+  thinking: {
+    supported: true,
+    flag: "-c model_reasoning_effort",
+    levels: CODEX_THINKING_LEVELS
+  },
+  working: {
+    command: CODEX_BINARY,
+    prompt: { kind: "prompt-file", reference: "at-prefixed-argument" },
+    baseArgs: [
+      "exec",
+      "--dangerously-bypass-approvals-and-sandbox",
+      "-o",
+      "{{outputFile}}",
+      "@{{promptFile}}"
+    ],
+    output: { style: "provider-output-file" }
+  },
+  interactive: { supported: true, command: CODEX_BINARY, modelFlag: "--model" }
+};
 async function runWorking2(request, runner = spawnCodexInheritingStdio) {
   const args = buildCodexWorkingArgs(request);
   let result;
@@ -945,6 +1082,7 @@ function terminateChildProcessTree2(child) {
 }
 var codexProvider = {
   id: "codex",
+  spec: CODEX_SPEC,
   runWorking: runWorking2,
   runInteractive: runInteractive2
 };
@@ -954,6 +1092,22 @@ import { spawn as spawn3 } from "child_process";
 import { writeFile as writeFile2 } from "fs/promises";
 var GEMINI_BINARY = "gemini";
 var GEMINI_RESULT_FIELD = "response";
+var GEMINI_SPEC = {
+  id: "gemini",
+  displayName: "Gemini",
+  model: { supported: true, flag: "-m" },
+  thinking: { supported: false },
+  working: {
+    command: GEMINI_BINARY,
+    prompt: { kind: "prompt-file", reference: "at-prefixed-argument" },
+    baseArgs: ["-p", "@{{promptFile}}", "--yolo", "--output-format", "json"],
+    output: {
+      style: "stdout-json-envelope",
+      parsing: { resultField: GEMINI_RESULT_FIELD }
+    }
+  },
+  interactive: { supported: true, command: GEMINI_BINARY, modelFlag: "-m" }
+};
 async function runWorking3(request, runner = spawnGeminiCapturingStdout) {
   const args = buildGeminiWorkingArgs(request);
   let result;
@@ -1095,6 +1249,7 @@ function terminateChildProcessTree3(child) {
 }
 var geminiProvider = {
   id: "gemini",
+  spec: GEMINI_SPEC,
   runWorking: runWorking3,
   runInteractive: runInteractive3
 };
@@ -1203,6 +1358,34 @@ function windowsPathDelimiter() {
 var PI_BINARY = "pi";
 var PI_RESULT_FIELD = "message";
 var PI_STDOUT_FALLBACK_TAIL_CHARS = 128e3;
+var PI_SPEC = {
+  id: "pi",
+  displayName: "Pi",
+  model: {
+    supported: true,
+    flag: "--model",
+    discovery: {
+      command: PI_BINARY,
+      args: ["--list-models"],
+      outputParser: "pi-list-models-table"
+    }
+  },
+  thinking: {
+    supported: true,
+    flag: "--thinking",
+    levels: ["low", "medium", "high", "xhigh", "max"]
+  },
+  working: {
+    command: PI_BINARY,
+    prompt: { kind: "prompt-file", reference: "at-prefixed-argument" },
+    baseArgs: ["-p", "@{{promptFile}}", "--mode", "json"],
+    output: {
+      style: "stdout-jsonl-transcript",
+      parsing: { resultField: PI_RESULT_FIELD }
+    }
+  },
+  interactive: { supported: true, command: PI_BINARY, modelFlag: "--model" }
+};
 async function runWorking4(request, runner = spawnPiCapturingStdout) {
   const args = buildPiWorkingArgs(request);
   let result;
@@ -1386,6 +1569,7 @@ function terminateChildProcessTree4(child) {
 }
 var piProvider = {
   id: "pi",
+  spec: PI_SPEC,
   runWorking: runWorking4,
   runInteractive: runInteractive4
 };
@@ -1511,6 +1695,7 @@ function defaultRunsRoot(cwd) {
 }
 async function createRunDirectory(options) {
   const runsRoot = options.runsRoot ?? defaultRunsRoot(options.cwd);
+  validateRunName(options.runName);
   await mkdir(runsRoot, { recursive: true });
   await ensureTrailStepGitignoreForRunsRoot(runsRoot);
   for (let suffix = 1; ; suffix += 1) {
@@ -1593,6 +1778,15 @@ async function writeRunState(runDir, state2) {
 function isNodeError(error) {
   return error instanceof Error && "code" in error;
 }
+function validateRunName(runName) {
+  if (runName.trim().length === 0 || runName === "." || runName === ".." || runName.includes("/") || runName.includes("\\")) {
+    throw new TrailStepFailureError({
+      code: "run_name_invalid",
+      message: "Run name must be a non-empty single path segment.",
+      details: { runName }
+    });
+  }
+}
 function isRunState(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
 }
@@ -2113,6 +2307,168 @@ function formatDiagnostics3(diagnostics) {
   return diagnostics.map((diagnostic) => `${diagnostic.path} ${diagnostic.message}`).join("; ");
 }
 
+// src/agent-execution/custom-provider/render-custom-provider-args.ts
+var PLACEHOLDER_NAMES = /* @__PURE__ */ new Set([
+  "prompt",
+  "promptFile",
+  "outputFile",
+  "model",
+  "thinking"
+]);
+var CONDITIONAL_NAMES = /* @__PURE__ */ new Set(["model", "thinking"]);
+var TEMPLATE_TOKEN_PATTERN = /^{{([#/]?)([A-Za-z][A-Za-z0-9]*)}}$/;
+function renderCustomProviderArgs(options) {
+  const values = {
+    ...options.values.prompt === void 0 ? {} : { prompt: options.values.prompt },
+    ...options.values.promptFile === void 0 ? {} : { promptFile: options.values.promptFile },
+    ...options.values.outputFile === void 0 ? {} : { outputFile: options.values.outputFile },
+    ...optionalNonEmptyString2(options.values.model) === void 0 ? {} : { model: optionalNonEmptyString2(options.values.model) },
+    ...options.values.thinking === void 0 ? {} : { thinking: options.values.thinking }
+  };
+  return renderRange({
+    argv: options.argv,
+    values,
+    errorCode: options.errorCode,
+    commandDescription: options.commandDescription
+  });
+}
+function renderRange(options) {
+  const rendered = [];
+  for (let index = 0; index < options.argv.length; index += 1) {
+    const arg = options.argv[index] ?? "";
+    const token = parseTemplateToken(arg);
+    if (token?.kind === "open") {
+      const closeIndex = findConditionalClose({
+        argv: options.argv,
+        openIndex: index,
+        condition: token.name,
+        errorCode: options.errorCode,
+        commandDescription: options.commandDescription
+      });
+      if (options.values[token.name] !== void 0) {
+        rendered.push(
+          ...renderRange({
+            ...options,
+            argv: options.argv.slice(index + 1, closeIndex)
+          })
+        );
+      }
+      index = closeIndex;
+      continue;
+    }
+    if (token?.kind === "close") {
+      throw templateError({
+        code: options.errorCode,
+        message: `${options.commandDescription} template has unexpected ${closingToken(token.name)} without a matching ${openingToken(token.name)}.`
+      });
+    }
+    if (token?.kind === "placeholder") {
+      rendered.push(renderPlaceholder({ ...options, name: token.name }));
+      continue;
+    }
+    if (TEMPLATE_TOKEN_PATTERN.test(arg)) {
+      throw templateError({
+        code: options.errorCode,
+        message: `${options.commandDescription} template token ${arg} is not supported.`,
+        details: { arg }
+      });
+    }
+    if (arg.includes("{{") || arg.includes("}}")) {
+      throw templateError({
+        code: options.errorCode,
+        message: `${options.commandDescription} placeholders and conditional blocks must be whole argv values.`,
+        details: { arg }
+      });
+    }
+    rendered.push(arg);
+  }
+  return rendered;
+}
+function parseTemplateToken(arg) {
+  const match = TEMPLATE_TOKEN_PATTERN.exec(arg);
+  if (!match) {
+    return void 0;
+  }
+  const prefix = match[1] ?? "";
+  const name = match[2] ?? "";
+  if (prefix === "") {
+    if (PLACEHOLDER_NAMES.has(name)) {
+      return { kind: "placeholder", name };
+    }
+    return void 0;
+  }
+  if (CONDITIONAL_NAMES.has(name)) {
+    return {
+      kind: prefix === "#" ? "open" : "close",
+      name
+    };
+  }
+  return void 0;
+}
+function findConditionalClose(options) {
+  let depth = 1;
+  for (let index = options.openIndex + 1; index < options.argv.length; index += 1) {
+    const token = parseTemplateToken(options.argv[index] ?? "");
+    if (token?.name !== options.condition) {
+      continue;
+    }
+    if (token.kind === "open") {
+      depth += 1;
+      continue;
+    }
+    if (token.kind === "close") {
+      depth -= 1;
+      if (depth === 0) {
+        return index;
+      }
+    }
+  }
+  throw templateError({
+    code: options.errorCode,
+    message: `${options.commandDescription} template is missing ${closingToken(options.condition)} for ${openingToken(options.condition)}.`
+  });
+}
+function renderPlaceholder(options) {
+  const value = options.values[options.name];
+  if (value !== void 0) {
+    return value;
+  }
+  if (options.name === "model" || options.name === "thinking") {
+    throw templateError({
+      code: options.errorCode,
+      message: `${options.commandDescription} placeholder ${placeholderToken(options.name)} must be guarded with ${openingToken(options.name)} ... ${closingToken(options.name)} when no ${options.name} override is set.`,
+      details: { placeholder: placeholderToken(options.name) }
+    });
+  }
+  throw templateError({
+    code: options.errorCode,
+    message: `${options.commandDescription} placeholder ${placeholderToken(options.name)} is not available in this command template.`,
+    details: { placeholder: placeholderToken(options.name) }
+  });
+}
+function templateError(options) {
+  return new TrailStepFailureError({
+    code: options.code,
+    message: options.message,
+    ...options.details === void 0 ? {} : { details: options.details }
+  });
+}
+function placeholderToken(name) {
+  return `{{${name}}}`;
+}
+function openingToken(name) {
+  return `{{#${name}}}`;
+}
+function closingToken(name) {
+  return `{{/${name}}}`;
+}
+function optionalNonEmptyString2(value) {
+  if (value === void 0 || value.trim().length === 0) {
+    return void 0;
+  }
+  return value;
+}
+
 // src/agent-execution/interactive-agent/run-interactive-agent-command.ts
 async function runInteractiveAgentCommand(options) {
   const [target] = resolveAgentTargets({
@@ -2187,12 +2543,22 @@ async function runInteractiveAgentTarget(options) {
       details: { provider: options.target.provider }
     });
   }
-  const args = await substitutePromptPlaceholders({
+  const thinking = options.target.thinking ?? options.role.thinking;
+  const args = renderCustomProviderArgs({
     argv: options.target.args ?? agentConfig.interactiveArgs,
-    prompt,
-    promptFile: files.promptFile,
-    model: options.target.model
+    values: {
+      prompt,
+      promptFile: files.promptFile,
+      ...options.target.model === void 0 ? {} : { model: options.target.model },
+      ...thinking === void 0 ? {} : { thinking }
+    },
+    errorCode: "interactive_command_invalid",
+    commandDescription: "Interactive agent command"
   });
+  if (args.includes(files.promptFile)) {
+    await mkdir2(dirname3(files.promptFile), { recursive: true });
+    await writeFile5(files.promptFile, prompt, "utf8");
+  }
   return await runProcessUntilExitOrCompletion({
     stepId: options.stepId,
     target: options.target.provider,
@@ -2331,33 +2697,6 @@ function exampleJsonObject(schema) {
     })
   );
 }
-async function substitutePromptPlaceholders(options) {
-  let needsPromptFile = false;
-  const substituted = options.argv.map((arg) => {
-    if (arg === "{{prompt}}") {
-      return options.prompt;
-    }
-    if (arg === "{{promptFile}}") {
-      needsPromptFile = true;
-      return options.promptFile;
-    }
-    if (arg === "{{model}}") {
-      return options.model ?? "";
-    }
-    if (arg.includes("{{prompt}}") || arg.includes("{{promptFile}}") || arg.includes("{{model}}")) {
-      throw new TrailStepFailureError({
-        code: "interactive_command_invalid",
-        message: "Interactive prompt placeholders must be whole argv values."
-      });
-    }
-    return arg;
-  });
-  if (needsPromptFile) {
-    await mkdir2(dirname3(options.promptFile), { recursive: true });
-    await writeFile5(options.promptFile, options.prompt, "utf8");
-  }
-  return substituted;
-}
 var spawnInteractiveProcess = async ({
   command,
   args,
@@ -2503,23 +2842,16 @@ function buildWorkingAgentArgs(options) {
       ...options.model ? ["--model", options.model] : []
     ];
   }
-  return options.argv.map((arg) => {
-    switch (arg) {
-      case "{{promptFile}}":
-        return options.promptFile;
-      case "{{outputFile}}":
-        return options.outputFile;
-      case "{{model}}":
-        return options.model ?? "";
-      default:
-        if (arg.includes("{{promptFile}}") || arg.includes("{{outputFile}}") || arg.includes("{{model}}")) {
-          throw new TrailStepFailureError({
-            code: "agent_provider_invalid",
-            message: "Working agent command placeholders must be whole argv values."
-          });
-        }
-        return arg;
-    }
+  return renderCustomProviderArgs({
+    argv: options.argv,
+    values: {
+      promptFile: options.promptFile,
+      outputFile: options.outputFile,
+      ...options.model === void 0 ? {} : { model: options.model },
+      ...options.thinking === void 0 ? {} : { thinking: options.thinking }
+    },
+    errorCode: "agent_provider_invalid",
+    commandDescription: "Working agent command"
   });
 }
 
@@ -2573,11 +2905,13 @@ async function runCustomWorkingProvider(options) {
       details: { provider: options.target.provider }
     });
   }
+  const thinking = options.target.thinking ?? options.role.thinking;
   const args = buildWorkingAgentArgs({
     argv: options.target.args ?? agentConfig.args,
     promptFile: options.files.promptFile,
     outputFile: options.files.outputFile,
-    model: options.target.model
+    model: options.target.model,
+    thinking
   });
   let result;
   try {
@@ -2786,6 +3120,7 @@ async function runWorkingAgentTargetAttempt(options) {
   return runCustomWorkingProvider({
     config: options.config,
     step: options.step,
+    role: options.role,
     cwd: options.cwd,
     runner: options.runner,
     target: options.target,
@@ -4315,7 +4650,13 @@ function isFlattenedAgentMappings(value) {
   );
 }
 function isFlattenedAgentTarget(value) {
-  return isPlainRecord(value) && typeof value.provider === "string";
+  if (!isPlainRecord(value) || typeof value.provider !== "string") {
+    return false;
+  }
+  if (value.model !== void 0) {
+    return typeof value.model === "string" && value.model.trim().length > 0;
+  }
+  return true;
 }
 function isPlainRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);