@citeark/agent 0.3.20

package/src/runtime/codex-capacity-retry.mjs

@@ -0,0 +1,87 @@
+import { spawn } from "node:child_process";
+import { setTimeout as sleep } from "node:timers/promises";
+import { pathToFileURL } from "node:url";
+
+const CONTINUE_PROMPT = "Continue only the unfinished work in this session after a temporary model-capacity error. Preserve completed work, the original task, and its resource and evidence requirements.";
+
+export function resumeCapacityArguments(args, threadId) {
+  const resumed = [...args];
+  const index = resumed.indexOf("exec");
+  if (index < 0 || !threadId) return resumed;
+  if (resumed[index + 1] === "resume") {
+    const last = resumed.indexOf("--last", index + 2);
+    if (last >= 0) resumed.splice(last, 1);
+    else resumed.splice(index + 2, 1);
+    resumed.splice(index + 2, 0, threadId);
+  } else resumed.splice(index + 1, 0, "resume", threadId);
+  resumed[resumed.length - 1] = CONTINUE_PROMPT;
+  return resumed;
+}
+
+// This supervisor stays in the existing VM, UID, account lock and runtime
+// deadline. Only an explicit terminal capacity error permits another CLI turn.
+export async function runCodexWithCapacityRetry({ args, command = "codex", commandPrefix = [],
+  retryDelayMs = 10_000, maxRetries = 30, stdout = process.stdout, stderr = process.stderr,
+  signal, wait = sleep }) {
+  if (!Number.isInteger(retryDelayMs) || retryDelayMs < 0 || retryDelayMs > 60_000
+    || !Number.isInteger(maxRetries) || maxRetries < 0 || maxRetries > 30) {
+    throw new Error("Invalid Codex capacity recovery limits");
+  }
+  let currentArgs = [...args], threadId = null;
+  const event = (type, details) => stdout.write(`${JSON.stringify({ type, ...details, timestamp: new Date().toISOString() })}\n`);
+  for (let retries = 0; ; retries++) {
+    if (signal?.aborted) return 143;
+    let pending = "", capacityFailure = false;
+    const observe = (line) => {
+      let entry;
+      try { entry = JSON.parse(line); } catch { return; }
+      if (entry.type === "thread.started" && typeof entry.thread_id === "string") threadId = entry.thread_id;
+      if (entry.type === "turn.failed") {
+        capacityFailure = /^Selected model is at capacity\. Please try a different model\.?$/i.test(entry.error?.message ?? "");
+      }
+    };
+    const child = spawn(command, [...commandPrefix, ...currentArgs], { stdio: ["ignore", "pipe", "pipe"] });
+    child.stdout.pipe(stdout, { end: false });
+    child.stderr.pipe(stderr, { end: false });
+    child.stdout.on("data", chunk => {
+      pending += chunk.toString();
+      let newline;
+      while ((newline = pending.indexOf("\n")) >= 0) {
+        observe(pending.slice(0, newline));
+        pending = pending.slice(newline + 1);
+      }
+      if (pending.length > 1_048_576) pending = pending.slice(-262_144);
+    });
+    const abort = () => child.kill("SIGTERM");
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+    let result;
+    try {
+      result = await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("close", (code, stoppedBy) => resolve({ code: code ?? 143, stoppedBy }));
+      });
+    } finally { signal?.removeEventListener("abort", abort); }
+    observe(pending);
+    if (pending) stdout.write("\n");
+    if (signal?.aborted || result.stoppedBy || result.code === 0 || !capacityFailure) return result.code;
+    if (retries >= maxRetries) {
+      event("citeark.codex_capacity_retries_exhausted", { retries, retryDelayMs, error: { message: "Codex capacity retry limit exhausted" } });
+      return result.code;
+    }
+    event("citeark.codex_capacity_retry_scheduled", { retry: retries + 1, maxRetries, retryDelayMs });
+    try { await wait(retryDelayMs, undefined, { signal }); }
+    catch (error) { if (signal?.aborted) return 143; throw error; }
+    currentArgs = resumeCapacityArguments(currentArgs, threadId);
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const [delay, retries, ...args] = process.argv.slice(2);
+  const controller = new AbortController();
+  process.once("SIGTERM", () => controller.abort());
+  process.once("SIGINT", () => controller.abort());
+  runCodexWithCapacityRetry({ args, retryDelayMs: Number(delay), maxRetries: Number(retries), signal: controller.signal })
+    .then(code => { process.exitCode = code; })
+    .catch(error => { console.error(error.message); process.exitCode = 1; });
+}

package/src/runtime/codex.mjs

@@ -0,0 +1,64 @@
+import { modelRoute } from "../provider/model-route.mjs";
+import { composeAgentPrompt } from "./prompt.mjs";
+import { CODEX_FINAL_MESSAGE_PATH } from "./final-output.mjs";
+
+export async function buildCodexInvocation({
+  bundle,
+  attempt,
+  prompt,
+  instructions,
+  providerSession,
+}) {
+  const agent = bundle.runtimeAgent;
+  const route = modelRoute(agent);
+  const provider = route.transport === "codex_subscription"
+    ? ["--config", 'model_provider="openai"', "--config", 'forced_login_method="chatgpt"', "--config", 'cli_auth_credentials_store="file"']
+    : codexProviderArguments(providerSession.containerBaseUrl);
+  const common = [
+    "--json",
+    "--ignore-user-config",
+    "--ignore-rules",
+    "--skip-git-repo-check",
+    "--dangerously-bypass-approvals-and-sandbox",
+    "--model",
+    route.nativeModel ?? agent.model,
+    "--output-last-message",
+    CODEX_FINAL_MESSAGE_PATH,
+    "--config",
+    `model_reasoning_effort=${JSON.stringify(agent.effort)}`,
+    ...provider,
+  ];
+  const fullPrompt = composeAgentPrompt(instructions, prompt);
+  return {
+    command: "codex",
+    capacityRecovery: { retryDelayMs: (agent.capacityRetryDelaySeconds ?? 10) * 1_000, maxRetries: agent.capacityMaxRetries ?? 30 },
+    args:
+      attempt === 1
+        ? ["--search", "exec", ...common, fullPrompt]
+        : ["--search", "exec", "resume", "--last", ...common, fullPrompt],
+    prompt,
+    promptArgument: fullPrompt,
+  };
+}
+
+function codexProviderArguments(baseUrl) {
+  return [
+    "--config",
+    'model_provider="citeark"',
+    "--config",
+    'model_providers.citeark.name="CiteArk Relay"',
+    "--config",
+    `model_providers.citeark.base_url=${JSON.stringify(`${baseUrl}/v1`)}`,
+    "--config",
+    'model_providers.citeark.env_key="OPENAI_API_KEY"',
+    "--config",
+    'model_providers.citeark.wire_api="responses"',
+  ];
+}
+
+export function freshCodexInvocation(invocation) {
+  const args = [...invocation.args];
+  const execIndex = args.indexOf("exec");
+  if (invocation.command === "codex" && execIndex >= 0 && args[execIndex + 1] === "resume" && args[execIndex + 2] === "--last") args.splice(execIndex + 1, 2);
+  return { ...invocation, args };
+}

package/src/runtime/config.mjs

@@ -0,0 +1,157 @@
+import { CiteArkError } from "../util.mjs";
+
+export const AGENT_RUNTIMES = Object.freeze({
+  "claude-code": {
+    apiProtocol: "anthropic-messages",
+    apiLabel: "Anthropic Messages API",
+  },
+  codex: {
+    apiProtocol: "openai-responses",
+    apiLabel: "OpenAI Responses API",
+  },
+  opencode: {
+    apiProtocol: "openai-chat-completions",
+    apiLabel: "OpenAI Chat Completions API",
+  },
+});
+
+export function resolveAgentRuntime({
+  taskAgent = {},
+  runtime,
+  apiBaseUrl,
+  apiKey,
+  apiKeySource = "parameter",
+  billingMode,
+  codexAccountId,
+  model,
+  subagentModel,
+  effort,
+  reasoningMode,
+  maxTurns,
+  maxBudgetUsd,
+  capacityRetryDelaySeconds,
+  capacityMaxRetries,
+  requireApi = true,
+} = {}) {
+  const selectedRuntime = runtime ?? taskAgent.runtime ?? "opencode";
+  const definition = AGENT_RUNTIMES[selectedRuntime];
+  if (!definition) {
+    throw new CiteArkError(
+      `agent must be one of ${Object.keys(AGENT_RUNTIMES).join(", ")}`,
+    );
+  }
+
+  const selectedModel = nonEmpty(model) ?? nonEmpty(taskAgent.model);
+  const selectedBaseUrl = nonEmpty(apiBaseUrl);
+  const selectedApiKey = nonEmpty(apiKey);
+  const selectedEffort = effort ?? taskAgent.effort ?? "high";
+  const selectedReasoningMode = reasoningMode ?? taskAgent.reasoningMode ?? "standard";
+  const requestedMaxTurns = maxTurns ?? taskAgent.maxTurns ?? 200;
+  const requestedMaxBudgetUsd = maxBudgetUsd ?? taskAgent.maxBudgetUsd ?? 20;
+  const selectedMaxTurns = boundedTaskLimit(requestedMaxTurns, taskAgent.budgetCaps?.maxTurns);
+  const selectedMaxBudgetUsd = boundedTaskLimit(
+    requestedMaxBudgetUsd,
+    taskAgent.budgetCaps?.maxBudgetUsd,
+  );
+  const issues = [];
+  const selectedCapacityDelay = capacityRetryDelaySeconds ?? taskAgent.capacityRetryDelaySeconds ?? 10;
+  const selectedCapacityRetries = capacityMaxRetries ?? taskAgent.capacityMaxRetries ?? 30;
+  if (!Number.isInteger(selectedCapacityDelay) || selectedCapacityDelay < 1 || selectedCapacityDelay > 60) issues.push("capacityRetryDelaySeconds must be 1–60");
+  if (!Number.isInteger(selectedCapacityRetries) || selectedCapacityRetries < 0 || selectedCapacityRetries > 30) issues.push("capacityMaxRetries must be 0–30");
+  if (codexAccountId && (selectedRuntime !== "codex" || !/^[a-z0-9][a-z0-9-]{0,47}$/.test(codexAccountId))) issues.push("Invalid Codex account configuration");
+  if (codexAccountId && selectedReasoningMode !== "standard") issues.push("Subscription sign-in uses native Codex reasoning. Select standard mode.");
+  if (codexAccountId && selectedModel?.replace(/^openai\//, "").includes("/")) issues.push("Subscription sign-in requires a native Codex model name");
+  if (!selectedModel) issues.push("Missing model");
+  if (requireApi && !codexAccountId && !selectedBaseUrl) issues.push("Missing API base URL");
+  if (requireApi && !codexAccountId && !selectedApiKey) issues.push("Missing API key");
+  if (selectedBaseUrl) validateBaseUrl(selectedBaseUrl, issues);
+  if (!new Set(["low", "medium", "high", "xhigh", "max"]).has(selectedEffort)) {
+    issues.push("effort must be low, medium, high, xhigh, or max");
+  }
+  if (!new Set(["standard", "pro"]).has(selectedReasoningMode)) {
+    issues.push("reasoningMode must be standard or pro");
+  }
+  if (selectedReasoningMode === "pro" && selectedRuntime === "claude-code") {
+    issues.push("Pro reasoning supports Codex and OpenCode");
+  }
+  if (!Number.isInteger(selectedMaxTurns) || selectedMaxTurns < 1) {
+    issues.push("maxTurns must be a positive integer");
+  }
+  if (typeof selectedMaxBudgetUsd !== "number" || !Number.isFinite(selectedMaxBudgetUsd) || selectedMaxBudgetUsd <= 0) {
+    issues.push("maxBudgetUsd must be greater than 0");
+  }
+  if (issues.length) {
+    throw new CiteArkError(`Invalid Agent configuration: \n- ${issues.join("\n- ")}`);
+  }
+
+  return {
+    runtime: selectedRuntime,
+    ...(codexAccountId ? { codexAccountId, billingMode: "subscription" } : {}),
+    ...(!codexAccountId && billingMode ? { billingMode } : {}),
+    model: selectedModel ?? "<model>",
+    subagentModel:
+      nonEmpty(subagentModel) ?? nonEmpty(taskAgent.subagentModel) ?? selectedModel ?? "<model>",
+    autoCompactWindow: taskAgent.autoCompactWindow ?? 786432,
+    effort: selectedEffort,
+    reasoningMode: selectedReasoningMode,
+    maxTurns: selectedMaxTurns,
+    maxBudgetUsd: selectedMaxBudgetUsd,
+    validationRetries: taskAgent.validationRetries ?? 0,
+    capacityRetryDelaySeconds: selectedCapacityDelay,
+    capacityMaxRetries: selectedCapacityRetries,
+    api: {
+      protocol: definition.apiProtocol,
+      label: definition.apiLabel,
+      baseUrl: selectedBaseUrl ?? "https://api.invalid",
+      apiKey: selectedApiKey ?? null,
+      credentialSource: apiKeySource,
+    },
+  };
+}
+
+function boundedTaskLimit(requested, hardCap) {
+  if (typeof hardCap !== "number" || !Number.isFinite(hardCap) || hardCap <= 0) return requested;
+  if (typeof requested !== "number" || !Number.isFinite(requested)) return requested;
+  return Math.min(requested, hardCap);
+}
+
+export function publicAgentRuntime(runtimeAgent) {
+  return {
+    runtime: runtimeAgent.runtime,
+    ...(runtimeAgent.codexAccountId ? { codexAccountId: runtimeAgent.codexAccountId, billingMode: "subscription" } : {}),
+    ...(!runtimeAgent.codexAccountId && runtimeAgent.billingMode ? { billingMode: runtimeAgent.billingMode } : {}),
+    model: runtimeAgent.model,
+    subagentModel: runtimeAgent.subagentModel,
+    effort: runtimeAgent.effort,
+    reasoningMode: runtimeAgent.reasoningMode,
+    maxTurns: runtimeAgent.maxTurns,
+    maxBudgetUsd: runtimeAgent.maxBudgetUsd,
+    validationRetries: runtimeAgent.validationRetries,
+    capacityRetryDelaySeconds: runtimeAgent.capacityRetryDelaySeconds,
+    capacityMaxRetries: runtimeAgent.capacityMaxRetries,
+    api: {
+      protocol: runtimeAgent.api.protocol,
+      baseUrl: runtimeAgent.api.baseUrl,
+      credentialSource: runtimeAgent.api.credentialSource,
+      credentialRecorded: false,
+    },
+  };
+}
+
+function validateBaseUrl(value, issues) {
+  try {
+    const url = new URL(value);
+    if (!new Set(["http:", "https:"]).has(url.protocol)) {
+      issues.push("apiBaseUrl must use HTTP(S)");
+    }
+    if (url.username || url.password || url.search || url.hash) {
+      issues.push("apiBaseUrl cannot contain credentials, query parameters, or fragments");
+    }
+  } catch {
+    issues.push("apiBaseUrl is not a valid URL");
+  }
+}
+
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}

package/src/runtime/final-output.mjs

@@ -0,0 +1,40 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { pathExists } from "../util.mjs";
+
+export const CODEX_FINAL_MESSAGE_PATH = "/job/execution/codex-final-message.txt";
+
+export async function recoverJsonFromFinalMessage({
+  finalMessagePath,
+  outputPath,
+}) {
+  if (await pathExists(outputPath)) return false;
+
+  let raw;
+  try {
+    raw = await readFile(finalMessagePath, "utf8");
+  } catch {
+    return false;
+  }
+  const candidate = unwrapSingleJsonFence(raw.trim());
+  if (!candidate) return false;
+
+  let parsed;
+  try {
+    parsed = JSON.parse(candidate);
+  } catch {
+    return false;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
+
+  await mkdir(path.dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, `${JSON.stringify(parsed, null, 2)}\n`, "utf8");
+  return true;
+}
+
+function unwrapSingleJsonFence(value) {
+  if (!value.startsWith("```")) return value;
+  const match = value.match(/^```(?:json)?\s*\n([\s\S]*?)\n```$/i);
+  return match?.[1]?.trim() ?? "";
+}

package/src/runtime/index.mjs

@@ -0,0 +1,21 @@
+import { researchInstructions } from '../workspace/control.mjs';
+import { buildClaudeCodeInvocation } from "./claude-code.mjs";
+import { buildCodexInvocation } from "./codex.mjs";
+import { buildOpenCodeInvocation } from "./opencode.mjs";
+import { CiteArkError } from "../util.mjs";
+
+export async function buildAgentInvocation(options) {
+  const notes = await researchInstructions();
+  if (notes) options = { ...options, prompt: `${options.prompt}\n\nUser follow-up instructions:\n${notes}\nApply these within the selected experiments, resource limits and recorded evidence requirements. Explain any request that needs a new plan or authorization.` };
+  const runtime = options.bundle.runtimeAgent.runtime;
+  if (runtime === "claude-code") return buildClaudeCodeInvocation(options);
+  if (runtime === "codex") return buildCodexInvocation(options);
+  if (runtime === "opencode") return buildOpenCodeInvocation(options);
+  throw new CiteArkError(`未实现的 Agent 运行器：${runtime}`);
+}
+
+export function agentInvocationPromptArgument(invocation) {
+  if (typeof invocation?.promptArgument === "string") return invocation.promptArgument;
+  if (typeof invocation?.prompt === "string") return invocation.prompt;
+  throw new TypeError("Agent invocation 缺少可持久化的 prompt 参数");
+}

package/src/runtime/local-codex.mjs

@@ -0,0 +1,74 @@
+import { hasSessionEvents, createRuntimeStream } from '../terminal/events.mjs';
+import { CLI_COMMUNICATION } from './prompt.mjs';
+import { spawn } from "node:child_process";
+import { createWriteStream } from "node:fs";
+import { mkdir, readFile } from "node:fs/promises";
+import path from "node:path";
+
+// Reuse the user's ChatGPT login. Do not inherit provider keys, relay endpoints,
+// cloud credentials, or the parent Codex task's internal runtime settings.
+export function localCodexEnvironment(environment = process.env) {
+  return Object.fromEntries(["HOME", "PATH", "TMPDIR", "LANG", "LC_ALL", "TERM"]
+    .filter((key) => environment[key] !== undefined).map((key) => [key, environment[key]]));
+}
+
+export async function runLocalCodex({ prompt, cwd, directory, model, effort = "medium", writableDirectories = [],
+  readOnly = false, config = [], environment, outputSchemaPath, timeoutMs = 14_400_000, command = "codex", progress = () => {}, signal }) {
+  await mkdir(directory, { recursive: true });
+  const answerPath = path.join(directory, "answer.txt");
+  const tracePath = path.join(directory, "trace.jsonl");
+  const args = ["exec", "--ignore-user-config", "--ignore-rules", "--ephemeral", "--skip-git-repo-check", "--json",
+    "--model", model, "--config", `model_reasoning_effort=${JSON.stringify(effort)}`,
+    "--config", "features.multi_agent=false", "--sandbox", readOnly ? "read-only" : "workspace-write",
+    "--config", "sandbox_workspace_write.network_access=true", "--cd", cwd,
+    "--output-last-message", answerPath,
+    ...(outputSchemaPath ? ["--output-schema", outputSchemaPath] : []),
+    ...writableDirectories.flatMap((entry) => ["--add-dir", entry]),
+    ...config.flatMap((entry) => ["--config", entry]), "-"];
+  const stdout = createWriteStream(tracePath);
+  const stderr = createWriteStream(path.join(directory, "stderr.log"));
+  const startedAt = new Date().toISOString();
+  const child = spawn(command, args, { cwd, env: { ...localCodexEnvironment(environment ?? process.env),
+    ...(environment?.CODEX_HOME ? { CODEX_HOME: environment.CODEX_HOME } : {}) }, detached: true, stdio: ["pipe", "pipe", "pipe"] });
+  let buffer = "", usage = null, sessionId = null, timedOut = false, aborted = false;
+  const stop = () => { try { process.kill(-child.pid, "SIGTERM"); } catch {} };
+  const abort = () => { aborted = true; stop(); };
+  signal?.addEventListener("abort", abort, { once: true });
+  if (signal?.aborted) abort();
+  const timer = setTimeout(() => { timedOut = true; stop(); }, timeoutMs);
+  const interrupt = () => stop();
+  process.on("SIGINT", interrupt); process.on("SIGTERM", interrupt);
+  const stream = hasSessionEvents() ? createRuntimeStream({ source: directory, runtime: 'codex' }) : null;
+  child.stdout.pipe(stdout); child.stderr.pipe(stderr);
+  child.stderr.on('data', chunk => stream?.stderr(chunk));
+  child.stdout.on("data", (bytes) => {
+    stream?.write(bytes);
+    buffer += bytes.toString();
+    let newline;
+    while ((newline = buffer.indexOf("\n")) >= 0) {
+      const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1);
+      try {
+        const event = JSON.parse(line);
+        if (event.type === "thread.started") sessionId = event.thread_id;
+        if (event.type === "turn.completed") usage = event.usage;
+        if (!stream && event.type === "item.completed" && event.item?.type === "agent_message") progress(event.item.text);
+      } catch {}
+    }
+  });
+  child.stdin.on("error", () => {});
+  child.stdin.end(hasSessionEvents() ? `${CLI_COMMUNICATION}\n\n${prompt}` : prompt);
+  let result;
+  try {
+    result = await new Promise((resolve, reject) => {
+      child.once("error", reject);
+      child.once("close", (code, signal) => resolve({ code, signal }));
+    });
+  } finally {
+    clearTimeout(timer); process.off("SIGINT", interrupt); process.off("SIGTERM", interrupt);
+    signal?.removeEventListener("abort", abort);
+    stream?.end(); stdout.end(); stderr.end();
+  }
+  return { ...result, timedOut, aborted, startedAt, finishedAt: new Date().toISOString(), sessionId, usage, tracePath,
+    answer: await readFile(answerPath, "utf8").catch(() => ""),
+    invocation: { command, args, authentication: "existing_chatgpt_login", inheritedProviderKeys: false } };
+}

package/src/runtime/opencode.mjs

@@ -0,0 +1,95 @@
+import { composeAgentPrompt } from "./prompt.mjs";
+
+export async function buildOpenCodeInvocation({
+  bundle,
+  attempt,
+  prompt,
+  instructions,
+}) {
+  const agent = bundle.runtimeAgent;
+  const fullPrompt = composeAgentPrompt(instructions, prompt);
+  const reasoningVariant = openCodeReasoningVariant(agent);
+  return {
+    command: "opencode",
+    args: [
+      "run",
+      "--pure",
+      "--auto",
+      ...(attempt > 1 ? ["--continue"] : []),
+      "--format",
+      "json",
+      "--model",
+      openCodeModelReference(agent),
+      ...(reasoningVariant ? ["--variant", reasoningVariant] : []),
+      fullPrompt,
+    ],
+    prompt,
+    promptArgument: fullPrompt,
+  };
+}
+
+export function openCodeModelDefinition(agent) {
+  const model = agent.model;
+  if (model.startsWith("deepseek-")) {
+    return {
+      name: model,
+      reasoning: true,
+      tool_call: true,
+      interleaved: { field: "reasoning_content" },
+    };
+  }
+  if (openRouterReasoningProvider(agent)) {
+    return {
+      name: model,
+      ...(["openai/gpt-6-astra", "openai/gpt-5.6-sol"].includes(model)
+        ? { modalities: { input: ["text", "image"], output: ["text"] } }
+        : {}),
+      reasoning: true,
+      tool_call: true,
+      variants: {
+        low: { reasoningEffort: "low" },
+        medium: { reasoningEffort: "medium" },
+        high: { reasoningEffort: "high" },
+      },
+    };
+  }
+  return { name: model };
+}
+
+export function openCodeReasoningVariant(agent) {
+  if (nativeDeepSeekProvider(agent)) return agent.effort;
+  if (!openRouterReasoningProvider(agent)) return null;
+  return new Set(["low", "medium", "high"]).has(agent.effort)
+    ? agent.effort
+    : "high";
+}
+
+export function openCodeModelReference(agent) {
+  return nativeDeepSeekProvider(agent)
+    ? `deepseek/${agent.model}`
+    : `citeark/${agent.model}`;
+}
+
+export function nativeDeepSeekProvider(agent) {
+  if (!agent?.model?.startsWith("deepseek-")) return false;
+  try {
+    const url = new URL(agent.api.baseUrl);
+    return (
+      url.protocol === "https:" &&
+      url.hostname === "api.deepseek.com" &&
+      new Set(["", "/", "/v1", "/v1/"]).has(url.pathname)
+    );
+  } catch {
+    return false;
+  }
+}
+
+function openRouterReasoningProvider(agent) {
+  if (!/^(?:google\/gemini-3(?:[.-]|$)|openai\/gpt-[56](?:[.-]|$))/.test(agent?.model ?? "")) return false;
+  try {
+    const url = new URL(agent.api.baseUrl);
+    return url.protocol === "https:" && url.hostname === "openrouter.ai";
+  } catch {
+    return false;
+  }
+}

package/src/runtime/prompt.mjs

@@ -0,0 +1,13 @@
+import { hasSessionEvents } from '../terminal/events.mjs';
+
+export const CLI_COMMUNICATION = 'Use English for user-facing messages. Explain meaningful actions and findings as you work. Preserve source quotations, code, paths, and user-provided text verbatim.';
+
+export function composeAgentPrompt(instructions, prompt) {
+  return [
+    "CiteArk Agent execution instructions:",
+    instructions.trim(),
+    ...(hasSessionEvents() ? [CLI_COMMUNICATION] : []),
+    "Current task:",
+    prompt.trim(),
+  ].join("\n\n");
+}