@opencow-ai/opencow-agent-sdk 0.4.13 → 0.4.15

package/dist/client.js

@@ -35041,7 +35041,8 @@ function normalizeGithubModelsApiModel(requestedModel) {
   return segment;
 }
 function resolveProviderTransport(options) {
-  const rawBaseUrl = asEnvUrl(options?.baseUrl) ?? asEnvUrl(getQueryEnvVar("OPENAI_BASE_URL")) ?? asEnvUrl(getQueryEnvVar("OPENAI_API_BASE"));
+  const optionBaseUrl = asEnvUrl(options?.baseUrl);
+  const rawBaseUrl = optionBaseUrl ?? asEnvUrl(getQueryEnvVar("OPENAI_BASE_URL")) ?? asEnvUrl(getQueryEnvVar("OPENAI_API_BASE"));
   const envOverride = options?.transportOverride ?? getQueryEnvVar(QUERY_ENV_KEY_TRANSPORT_OVERRIDE);
   if (envOverride && envOverride !== "auto") {
     let normalized;
@@ -35051,7 +35052,8 @@ function resolveProviderTransport(options) {
     } else {
       normalized = envOverride;
     }
-    const baseUrl2 = (rawBaseUrl ?? (normalized === "openai_responses" ? DEFAULT_CODEX_BASE_URL : DEFAULT_OPENAI_BASE_URL)).replace(/\/+$/, "");
+    const baseUrlSource = rawBaseUrl ?? (normalized === "openai_responses" ? DEFAULT_CODEX_BASE_URL : DEFAULT_OPENAI_BASE_URL);
+    const baseUrl2 = baseUrlSource.replace(/\/+$/, "");
     return { transport: normalized, baseUrl: baseUrl2 };
   }
   const modelForDetection = options?.model?.trim() ?? "";
@@ -35179,7 +35181,7 @@ function resolveCodexApiCredentials(env2 = process.env) {
     originator: "opencow"
   };
 }
-var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1", DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex", DEFAULT_GITHUB_MODELS_API_MODEL = "openai/gpt-4.1", CODEX_ALIAS_MODELS, QUERY_ENV_KEY_TRANSPORT_OVERRIDE = "__OPENCOW_TRANSPORT_OVERRIDE", QUERY_ENV_KEY_REASONING_EFFORT_OVERRIDE = "__OPENCOW_REASONING_EFFORT_OVERRIDE", QUERY_ENV_VALUE_REASONING_EFFORT_CLEAR = "__OPENCOW_CLEAR_REASONING_EFFORT__", QUERY_ENV_KEY_PROVIDER_SPECIFIC_OPENAI_RESPONSES = "__OPENCOW_PROVIDER_SPECIFIC_OPENAI_RESPONSES", LOCALHOST_HOSTNAMES, warnedCodexAliasOnce = false, MissingProviderModelError;
+var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1", DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex", DEFAULT_GITHUB_MODELS_API_MODEL = "openai/gpt-4.1", CODEX_ALIAS_MODELS, QUERY_ENV_KEY_TRANSPORT_OVERRIDE = "__OPENCOW_TRANSPORT_OVERRIDE", QUERY_ENV_KEY_REASONING_EFFORT_OVERRIDE = "__OPENCOW_REASONING_EFFORT_OVERRIDE", QUERY_ENV_VALUE_REASONING_EFFORT_CLEAR = "__OPENCOW_CLEAR_REASONING_EFFORT__", QUERY_ENV_KEY_PROVIDER_SPECIFIC_OPENAI_RESPONSES = "__OPENCOW_PROVIDER_SPECIFIC_OPENAI_RESPONSES", QUERY_ENV_KEY_EXTRA_BODY = "__OPENCOW_EXTRA_BODY", LOCALHOST_HOSTNAMES, warnedCodexAliasOnce = false, MissingProviderModelError;
 var init_config2 = __esm(() => {
   init_envUtils();
   init_state2();
@@ -94704,6 +94706,48 @@ var init_proxy = __esm(() => {
   });
 });
 
+// src/providers/shared/httpObservability.ts
+function classifyModelHttpEndpoint(url3) {
+  try {
+    const pathname = new URL(url3).pathname.replace(/\/+$/, "");
+    if (pathname.endsWith("/messages/count_tokens"))
+      return "count_tokens";
+    if (pathname.endsWith("/chat/completions"))
+      return "messages";
+    if (pathname.endsWith("/messages"))
+      return "messages";
+    if (pathname.endsWith("/responses"))
+      return "responses";
+    return pathname || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function errorToFailureReason(error41) {
+  if (error41 instanceof Error)
+    return error41.message;
+  return String(error41);
+}
+function responseBodyToFailureReason(status, body) {
+  let detail = body.trim();
+  try {
+    const parsed = JSON.parse(body);
+    const message = typeof parsed.error?.message === "string" ? parsed.error.message : typeof parsed.message === "string" ? parsed.message : undefined;
+    const code = typeof parsed.error?.code === "string" ? parsed.error.code : typeof parsed.error?.type === "string" ? parsed.error.type : undefined;
+    detail = [code, message].filter(Boolean).join(": ") || detail;
+  } catch {}
+  const compact = detail.replace(/\s+/g, " ").slice(0, 240);
+  return compact ? `HTTP ${status}: ${compact}` : `HTTP ${status}`;
+}
+function emitSdkHttp(event) {
+  try {
+    emitHttp(event);
+  } catch {}
+}
+var init_httpObservability = __esm(() => {
+  init_observer();
+});
+
 // src/providers/shared/geminiAuth.ts
 import { homedir as homedir11 } from "node:os";
 import { join as join23 } from "node:path";
@@ -95334,6 +95378,44 @@ var init_capabilities2 = __esm(() => {
   ]);
 });
 
+// src/providers/shared/requestSideChannels.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonObject(raw) {
+  if (!raw)
+    return;
+  try {
+    const parsed = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function readExplicitExtraBodyParams() {
+  return parseJsonObject(getQueryEnvVar(QUERY_ENV_KEY_EXTRA_BODY)) ?? parseJsonObject(resolveEnvVar("EXTRA_BODY"));
+}
+function mergeOpenAICompatibleExtraBodyParams(body, params) {
+  const extra = {};
+  const shouldMerge = (key, value) => value !== undefined && !(key in body);
+  const explicitExtraBody = readExplicitExtraBodyParams();
+  if (explicitExtraBody) {
+    Object.assign(extra, explicitExtraBody);
+  }
+  const nestedExtraBody = params.extra_body;
+  if (isRecord(nestedExtraBody)) {
+    Object.assign(extra, nestedExtraBody);
+  }
+  for (const [key, value] of Object.entries(extra)) {
+    if (shouldMerge(key, value))
+      body[key] = value;
+  }
+}
+var init_requestSideChannels = __esm(() => {
+  init_state2();
+  init_config2();
+});
+
 // src/providers/codex/shim.ts
 function parseSseChunk(chunk) {
   const lines = chunk.split(`
@@ -95682,6 +95764,7 @@ async function performCodexRequest(options) {
       body.top_p = options.params.top_p;
     }
   }
+  mergeOpenAICompatibleExtraBodyParams(body, options.params);
   const headers = {
     "Content-Type": "application/json",
     ...options.defaultHeaders,
@@ -96053,6 +96136,7 @@ var init_shim = __esm(() => {
   init_sdk();
   init_schema();
   init_capabilities2();
+  init_requestSideChannels();
   init_canonical();
 });
 
@@ -96250,7 +96334,7 @@ function convertContentBlocks(content) {
     return parts[0].text ?? "";
   return parts;
 }
-function convertMessages(messages, system) {
+function convertMessages(messages, system, options = {}) {
   const result = [];
   const sysText = convertSystemPrompt2(system);
   if (sysText) {
@@ -96313,7 +96397,7 @@ function convertMessages(messages, system) {
             return text || null;
           })()
         };
-        if (thinkingBlocks.length > 0) {
+        if (options.replayReasoningContent !== false && thinkingBlocks.length > 0) {
           const reasoningText = thinkingBlocks.map((b) => b.thinking ?? "").filter(Boolean).join(`
 `);
           if (reasoningText) {
@@ -96446,7 +96530,8 @@ function serializeParallelToolCalls(messages, capabilities) {
 }
 function buildOpenAIRequestBody(params, ctx) {
   const capabilities = getOpenAIChatProviderCapabilities(ctx.resolvedModel);
-  const openaiMessages = serializeParallelToolCalls(convertMessages(params.messages, params.system), capabilities);
+  const replayReasoningContent = !isGeminiTarget(ctx.resolvedModel);
+  const openaiMessages = serializeParallelToolCalls(convertMessages(params.messages, params.system, { replayReasoningContent }), capabilities);
   const body = {
     model: ctx.resolvedModel,
     messages: openaiMessages,
@@ -96497,6 +96582,7 @@ function buildOpenAIRequestBody(params, ctx) {
       }
     }
   }
+  mergeOpenAICompatibleExtraBodyParams(body, params);
   return body;
 }
 async function* openaiStreamToAnthropic(response, model) {
@@ -96823,10 +96909,12 @@ class OpenAIShimMessages {
   defaultHeaders;
   reasoningEffort;
   providerOverride;
-  constructor(defaultHeaders, reasoningEffort, providerOverride) {
+  source;
+  constructor(defaultHeaders, reasoningEffort, providerOverride, source) {
     this.defaultHeaders = defaultHeaders;
     this.reasoningEffort = reasoningEffort;
     this.providerOverride = providerOverride;
+    this.source = source;
   }
   create(params, options) {
     const self2 = this;
@@ -96961,28 +97049,93 @@ class OpenAIShimMessages {
       signal: options?.signal
     };
     const maxAttempts = isGithub ? GITHUB_429_MAX_RETRIES : 1;
+    const endpoint = classifyModelHttpEndpoint(chatCompletionsUrl);
     let response;
     for (let attempt = 0;attempt < maxAttempts; attempt++) {
+      const attemptNumber = attempt + 1;
+      const requestId = `req_${crypto.randomUUID().replace(/-/g, "")}`;
+      const requestStartedAt = Date.now();
+      emitSdkHttp({
+        type: "request_start",
+        requestId,
+        method: fetchInit.method,
+        url: chatCompletionsUrl,
+        source: this.source,
+        endpoint,
+        attempt: attemptNumber,
+        maxAttempts,
+        timestamp: requestStartedAt
+      });
       try {
         response = await fetch(chatCompletionsUrl, fetchInit);
       } catch (fetchErr) {
         const msg = fetchErr instanceof Error ? `${fetchErr.message}${fetchErr.cause ? ` (${fetchErr.cause?.code ?? fetchErr.cause?.message ?? ""})` : ""}` : String(fetchErr);
+        emitSdkHttp({
+          type: "error",
+          requestId,
+          error: fetchErr instanceof Error ? fetchErr : new Error(String(fetchErr)),
+          durationMs: Date.now() - requestStartedAt,
+          source: this.source,
+          endpoint,
+          attempt: attemptNumber,
+          maxAttempts,
+          failureReason: msg,
+          timestamp: Date.now()
+        });
         throw new APIConnectionError({
           message: `OpenAI-compat connection failed: ${msg}`,
           cause: fetchErr
         });
       }
       if (response.ok) {
+        emitSdkHttp({
+          type: "response_start",
+          requestId,
+          status: response.status,
+          durationMs: Date.now() - requestStartedAt,
+          source: this.source,
+          endpoint,
+          attempt: attemptNumber,
+          maxAttempts,
+          timestamp: Date.now()
+        });
         return response;
       }
       if (isGithub && response.status === 429 && attempt < maxAttempts - 1) {
         await response.text().catch(() => {});
         const delaySec = Math.min(GITHUB_429_BASE_DELAY_SEC * 2 ** attempt, GITHUB_429_MAX_DELAY_SEC);
+        emitSdkHttp({
+          type: "response_start",
+          requestId,
+          status: response.status,
+          durationMs: Date.now() - requestStartedAt,
+          source: this.source,
+          endpoint,
+          attempt: attemptNumber,
+          maxAttempts,
+          willRetry: true,
+          retryDelayMs: delaySec * 1000,
+          failureReason: `HTTP ${response.status}${formatRetryAfterHint(response)}`,
+          timestamp: Date.now()
+        });
         await sleepMs(delaySec * 1000);
         continue;
       }
       const errorBody = await response.text().catch(() => "unknown error");
       const rateHint = isGithub && response.status === 429 ? formatRetryAfterHint(response) : "";
+      const failureReason = `${responseBodyToFailureReason(response.status, errorBody)}${rateHint}`;
+      emitSdkHttp({
+        type: "response_start",
+        requestId,
+        status: response.status,
+        durationMs: Date.now() - requestStartedAt,
+        source: this.source,
+        endpoint,
+        attempt: attemptNumber,
+        maxAttempts,
+        failureReason,
+        timestamp: Date.now()
+      });
       let errorResponse;
       try {
         errorResponse = JSON.parse(errorBody);
@@ -97071,8 +97224,8 @@ function convertOpenAIResponseToAnthropic(data, model) {
 class OpenAIShimBeta {
   messages;
   reasoningEffort;
-  constructor(defaultHeaders, reasoningEffort, providerOverride) {
-    this.messages = new OpenAIShimMessages(defaultHeaders, reasoningEffort, providerOverride);
+  constructor(defaultHeaders, reasoningEffort, providerOverride, source) {
+    this.messages = new OpenAIShimMessages(defaultHeaders, reasoningEffort, providerOverride, source);
     this.reasoningEffort = reasoningEffort;
   }
 }
@@ -97094,7 +97247,7 @@ function createOpenAIShimClient(options) {
   }
   const beta = new OpenAIShimBeta({
     ...options.defaultHeaders ?? {}
-  }, options.reasoningEffort, options.providerOverride);
+  }, options.reasoningEffort, options.providerOverride, options.source);
   return {
     beta,
     messages: beta.messages
@@ -97113,7 +97266,9 @@ var init_shim2 = __esm(() => {
   init_schemaSanitizer();
   init_providerProfile();
   init_capabilities2();
+  init_httpObservability();
   init_canonical();
+  init_requestSideChannels();
   OpenAIShimStream = class OpenAIShimStream {
     generator;
     controller = new AbortController;
@@ -97210,7 +97365,8 @@ async function getNormalizedClient({
       defaultHeaders: safeHeaders,
       maxRetries,
       timeout: parseInt(process.env.API_TIMEOUT_MS || String(600000), 10),
-      providerOverride
+      providerOverride,
+      source
     });
   }
   const transportOverride = getQueryEnvVar(QUERY_ENV_KEY_TRANSPORT_OVERRIDE);
@@ -97220,7 +97376,8 @@ async function getNormalizedClient({
     return createOpenAIShimClient2({
       defaultHeaders,
       maxRetries,
-      timeout: parseInt(process.env.API_TIMEOUT_MS || String(600000), 10)
+      timeout: parseInt(process.env.API_TIMEOUT_MS || String(600000), 10),
+      source
     });
   }
   const stagingOauthBaseUrl = process.env.USER_TYPE === "ant" && isEnvTruthy(process.env.USE_STAGING_OAUTH) ? getOauthConfig().BASE_API_URL : undefined;
@@ -97272,42 +97429,49 @@ function buildFetch(fetchOverride, source) {
     const url3 = input instanceof Request ? input.url : String(input);
     const method = init?.method ?? (input instanceof Request ? input.method : "GET");
     const requestId = headers.get(CLIENT_REQUEST_ID_HEADER) ?? randomUUID();
+    const endpoint = classifyModelHttpEndpoint(url3);
     try {
       logForDebugging(`[API REQUEST] ${new URL(url3).pathname} ${CLIENT_REQUEST_ID_HEADER}=${requestId} source=${source ?? "unknown"}`);
     } catch {}
     const requestStartedAt = Date.now();
+    emitSdkHttp({
+      type: "request_start",
+      requestId,
+      method,
+      url: url3,
+      source,
+      endpoint,
+      attempt: 1,
+      maxAttempts: 1,
+      timestamp: requestStartedAt
+    });
     try {
-      emitHttp({
-        type: "request_start",
+      const response = await inner(input, { ...init, headers });
+      emitSdkHttp({
+        type: "response_start",
         requestId,
-        method,
-        url: url3,
+        status: response.status,
+        durationMs: Date.now() - requestStartedAt,
         source,
-        timestamp: requestStartedAt
+        endpoint,
+        attempt: 1,
+        maxAttempts: 1,
+        timestamp: Date.now()
       });
-    } catch {}
-    try {
-      const response = await inner(input, { ...init, headers });
-      try {
-        emitHttp({
-          type: "response_start",
-          requestId,
-          status: response.status,
-          durationMs: Date.now() - requestStartedAt,
-          timestamp: Date.now()
-        });
-      } catch {}
       return response;
     } catch (err) {
-      try {
-        emitHttp({
-          type: "error",
-          requestId,
-          error: err instanceof Error ? err : new Error(String(err)),
-          durationMs: Date.now() - requestStartedAt,
-          timestamp: Date.now()
-        });
-      } catch {}
+      emitSdkHttp({
+        type: "error",
+        requestId,
+        error: err instanceof Error ? err : new Error(String(err)),
+        durationMs: Date.now() - requestStartedAt,
+        source,
+        endpoint,
+        attempt: 1,
+        maxAttempts: 1,
+        failureReason: errorToFailureReason(err),
+        timestamp: Date.now()
+      });
       throw err;
     }
   };
@@ -97326,7 +97490,7 @@ var init_clientFactory = __esm(() => {
   init_oauth();
   init_debug();
   init_envUtils();
-  init_observer();
+  init_httpObservability();
 });
 
 // src/providers/anthropic/index.ts
@@ -133214,6 +133378,17 @@ async function* withRetry(getClient, operation, options2) {
         status: error41.status,
         provider: getAPIProviderForStatsig()
       });
+      emitSdkHttp({
+        type: "retry",
+        source: options2.querySource,
+        endpoint: "messages",
+        attempt: reportedAttempt,
+        ...persistent ? {} : { maxAttempts: maxRetries + 1 },
+        retryDelayMs: delayMs,
+        status: error41 instanceof APIError ? error41.status : undefined,
+        failureReason: errorToFailureReason(error41),
+        timestamp: Date.now()
+      });
       if (persistent) {
         if (delayMs > 60000) {
           logEvent("tengu_api_persistent_retry_wait", {
@@ -133467,6 +133642,7 @@ var init_retry = __esm(() => {
   init_mocking();
   init_errors7();
   init_errorUtils();
+  init_httpObservability();
   FOREGROUND_529_RETRY_SOURCES = new Set([
     "repl_main_thread",
     "repl_main_thread:outputStyle:custom",
@@ -233784,6 +233960,27 @@ function isResultSuccessful(message, stopReason = null) {
   }
   return stopReason === "end_turn";
 }
+function buildErrorDuringExecutionDiagnostic({
+  resultType,
+  lastContentType,
+  stopReason
+}) {
+  return `${ERROR_DURING_EXECUTION_DIAGNOSTIC_PREFIX} result_type=${resultType} last_content_type=${lastContentType} stop_reason=${stopReason}`;
+}
+function buildErrorDuringExecutionErrors({
+  recentErrors,
+  stopReason
+}) {
+  const visibleErrors = recentErrors.filter((error41) => !error41.startsWith(ERROR_DURING_EXECUTION_DIAGNOSTIC_PREFIX));
+  if (visibleErrors.length > 0)
+    return visibleErrors;
+  if (stopReason === "tool_use") {
+    return [
+      "The upstream model requested a tool but did not produce a final assistant response after the tool result."
+    ];
+  }
+  return ["The upstream model stopped before producing a final assistant response."];
+}
 function normalizeUserMessageForSdk(message) {
   const content = message.content;
   if (!Array.isArray(content))
@@ -233971,7 +234168,7 @@ async function* handleOrphanedPermission(orphanedPermission, tools, mutableMessa
     }
   }
 }
-var MAX_TOOL_PROGRESS_TRACKING_ENTRIES = 100, TOOL_PROGRESS_THROTTLE_MS = 30000, toolProgressLastSentTime, STRIPPED_COMMANDS;
+var ERROR_DURING_EXECUTION_DIAGNOSTIC_PREFIX = "[ede_diagnostic]", MAX_TOOL_PROGRESS_TRACKING_ENTRIES = 100, TOOL_PROGRESS_THROTTLE_MS = 30000, toolProgressLastSentTime, STRIPPED_COMMANDS;
 var init_queryHelpers = __esm(() => {
   init_last();
   init_state();
@@ -235103,6 +235300,11 @@ var FINGERPRINT_SALT = "59cf53e54c78";
 var init_fingerprint = () => {};
 
 // src/session/sideQuery.ts
+function headersForBetas(betas) {
+  if (!betas || betas.length === 0)
+    return;
+  return { "anthropic-beta": betas.join(",") };
+}
 function extractFirstUserMessageText(messages) {
   const firstUserMessage = messages.find((m) => m.role === "user");
   if (!firstUserMessage)
@@ -235165,7 +235367,7 @@ async function sideQuery(opts) {
   }
   const normalizedModel = normalizeModelStringForAPI(model);
   const start = Date.now();
-  const response = await client.beta.messages.create({
+  const response = await client.messages.create({
     model: normalizedModel,
     max_tokens,
     system: systemBlocks,
@@ -235176,9 +235378,12 @@ async function sideQuery(opts) {
     ...temperature !== undefined && { temperature },
     ...stop_sequences && { stop_sequences },
     ...thinkingConfig && { thinking: thinkingConfig },
-    ...betas.length > 0 && { betas },
-    metadata: getAPIMetadata()
-  }, { signal });
+    metadata: getAPIMetadata(),
+    ...getExtraBodyParams()
+  }, {
+    signal,
+    ...betas.length > 0 ? { headers: headersForBetas(betas) } : {}
+  });
   const requestId = response._request_id ?? undefined;
   const now = Date.now();
   const lastCompletion = getLastApiCompletionTimestamp();
@@ -250648,49 +250853,36 @@ assistant: Still waiting on the audit — that's one of the things it's checking
 
 <example>
 user: "Can you get a second opinion on whether this migration is safe?"
-assistant: <thinking>I'll ask the code-reviewer agent — it won't see my analysis, so it can give an independent read.</thinking>
+assistant: <thinking>Forking this review keeps the detailed audit out of my context while I keep steering the work.</thinking>
 <commentary>
-A subagent_type is specified, so the agent starts fresh. It needs full context in the prompt. The briefing explains what to assess and why.
+No subagent_type is specified, so this uses the fork path. If you do specify subagent_type, copy an exact type from the available agent list; never invent one from an example.
 </commentary>
 ${AGENT_TOOL_NAME2}({
   name: "migration-review",
   description: "Independent migration review",
-  subagent_type: "code-reviewer",
   prompt: "Review migration 0042_user_schema.sql for safety. Context: we're adding a NOT NULL column to a 50M-row table. Existing rows get a backfill default. I want a second opinion on whether the backfill approach is safe under concurrent writes — I've checked locking behavior but want independent verification. Report: is this safe, and if not, what specifically breaks?"
 })
 </example>
 `;
   const currentExamples = `Example usage:
 
-<example_agent_descriptions>
-"test-runner": use this agent after you are done writing code to run tests
-"greeting-responder": use this agent to respond to user greetings with a friendly joke
-</example_agent_descriptions>
-
 <example>
-user: "Please write a function that checks if a number is prime"
-assistant: I'm going to use the ${FILE_WRITE_TOOL_NAME2} tool to write the following code:
-<code>
-function isPrime(n) {
-  if (n <= 1) return false
-  for (let i = 2; i * i <= n; i++) {
-    if (n % i === 0) return false
-  }
-  return true
-}
-</code>
+user: "Hello"
 <commentary>
-Since a significant piece of code was written and the task was completed, now use the test-runner agent to run the tests
+Do not use the ${AGENT_TOOL_NAME2} tool for a simple greeting or a short reply. Answer directly.
 </commentary>
-assistant: Uses the ${AGENT_TOOL_NAME2} tool to launch the test-runner agent
+assistant: "Hi! Nice to see you. What shall we work on today?"
 </example>
 
 <example>
-user: "Hello"
+user: "Can you investigate whether this migration is safe?"
 <commentary>
-Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
+This is a multi-step review, so the ${AGENT_TOOL_NAME2} tool can help. Omit subagent_type to use the default general-purpose agent, or specify a subagent_type only by copying an exact type from the available agent list.
 </commentary>
-assistant: "I'm going to use the ${AGENT_TOOL_NAME2} tool to launch the greeting-responder agent"
+${AGENT_TOOL_NAME2}({
+  description: "Review migration safety",
+  prompt: "Review migration 0042_user_schema.sql for safety. Context: we're adding a NOT NULL column to a 50M-row table. Existing rows get a backfill default. Check whether the backfill approach is safe under concurrent writes. Report: is this safe, and if not, what specifically breaks?"
+})
 </example>
 `;
   const listViaAttachment = shouldInjectAgentListInMessages();
@@ -250703,7 +250895,7 @@ The ${AGENT_TOOL_NAME2} tool launches specialized agents (subprocesses) that aut
 
 ${agentListSection}
 
-${forkEnabled ? `When using the ${AGENT_TOOL_NAME2} tool, specify a subagent_type to use a specialized agent, or omit it to fork yourself — a fork inherits your full conversation context.` : `When using the ${AGENT_TOOL_NAME2} tool, specify a subagent_type parameter to select which agent type to use. If omitted, the general-purpose agent is used.`}`;
+${forkEnabled ? `When using the ${AGENT_TOOL_NAME2} tool, specify a subagent_type to use a specialized agent, or omit it to fork yourself — a fork inherits your full conversation context. Only use subagent_type values that appear in the available agent types; never invent an agent type from an example.` : `When using the ${AGENT_TOOL_NAME2} tool, specify a subagent_type parameter to select which agent type to use. If omitted, the general-purpose agent is used. Only use subagent_type values that appear in the available agent types; never invent an agent type from an example.`}`;
   if (isCoordinator) {
     return shared2;
   }
@@ -250731,7 +250923,7 @@ Usage notes:
 - The agent's outputs should generally be trusted
 - Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.)${forkEnabled ? "" : ", since it is not aware of the user's intent"}
 - If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
-- If the user specifies that they want you to run agents "in parallel", you MUST send a single message with multiple ${AGENT_TOOL_NAME2} tool use content blocks. For example, if you need to launch both a build-validator agent and a test-runner agent in parallel, send a single message with both tool calls.
+- If the user specifies that they want you to run agents "in parallel", you MUST send a single message with multiple ${AGENT_TOOL_NAME2} tool use content blocks. Each call must either omit subagent_type or use an exact type from the available agent list.
 - You can optionally set \`isolation: "worktree"\` to run the agent in a temporary git worktree, giving it an isolated copy of the repository. The worktree is automatically cleaned up if the agent makes no changes; if changes are made, the worktree path and branch are returned in the result.${process.env.USER_TYPE === "ant" ? `
 - You can set \`isolation: "remote"\` to run the agent in a remote CCR environment. This is always a background task; you'll be notified when it completes. Use for long-running tasks that need a fresh sandbox.` : ""}${isInProcessTeammate() ? `
 - The run_in_background, name, team_name, and mode parameters are not available in this context. Only synchronous subagents are supported.` : isTeammate() ? `
@@ -250746,7 +250938,6 @@ var init_prompt7 = __esm(() => {
   init_teammate();
   init_teammateContext();
   init_prompt2();
-  init_prompt3();
   init_constants4();
   init_forkSubagent();
   init_state2();
@@ -269671,7 +269862,7 @@ async function loadPluginSettings(pluginPath, manifest) {
   try {
     const content = await getFsImplementation().readFile(settingsJsonPath, { encoding: "utf-8" });
     const parsed = jsonParse(content);
-    if (isRecord(parsed)) {
+    if (isRecord2(parsed)) {
       const filtered = parsePluginSettings(parsed);
       if (filtered) {
         logForDebugging(`Loaded settings from settings.json for plugin ${manifest.name}`);
@@ -270350,7 +270541,7 @@ function cachePluginSettings(plugins) {
     logForDebugging(`Cached plugin settings with keys: ${Object.keys(settings).join(", ")}`);
   }
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var PluginSettingsSchema, loadAllPlugins, loadAllPluginsCacheOnly;
@@ -282702,7 +282893,7 @@ function getAnthropicEnvMetadata() {
 function getBuildAgeMinutes() {
   if (false)
     ;
-  const buildTime = new Date("2026-06-25T12:29:02.938Z").getTime();
+  const buildTime = new Date("2026-07-07T09:41:37.769Z").getTime();
   if (isNaN(buildTime))
     return;
   return Math.floor((Date.now() - buildTime) / 60000);
@@ -285553,6 +285744,11 @@ var init_toolSearch = __esm(() => {
 });
 
 // src/providers/shared/tokenCount.ts
+function headersForBetas2(betas) {
+  if (!betas || betas.length === 0)
+    return;
+  return { "anthropic-beta": betas.join(",") };
+}
 function hasThinkingBlocks(messages) {
   for (const message of messages) {
     if (message.role === "assistant" && Array.isArray(message.content)) {
@@ -285627,17 +285823,18 @@ async function countMessagesTokensWithAPI(messages, tools) {
         model,
         source: "count_tokens"
       });
-      const response = await anthropic.beta.messages.countTokens({
+      const response = await anthropic.messages.countTokens({
         model: normalizeModelStringForAPI(model),
         messages: messages.length > 0 ? messages : [{ role: "user", content: "foo" }],
         tools,
-        ...betas.length > 0 && { betas },
         ...containsThinking && {
           thinking: {
             type: "enabled",
             budget_tokens: TOKEN_COUNT_THINKING_BUDGET
           }
         }
+      }, {
+        ...betas.length > 0 ? { headers: headersForBetas2(betas) } : {}
       });
       if (typeof response.input_tokens !== "number") {
         return null;
@@ -285676,12 +285873,11 @@ async function countTokensViaHaikuFallback(messages, tools) {
   const normalizedMessages = stripToolSearchFieldsFromMessages(messages);
   const messagesToSend = normalizedMessages.length > 0 ? normalizedMessages : [{ role: "user", content: "count" }];
   const betas = getModelBetas(model);
-  const response = await anthropic.beta.messages.create({
+  const response = await anthropic.messages.create({
     model: normalizeModelStringForAPI(model),
     max_tokens: containsThinking ? TOKEN_COUNT_MAX_TOKENS : 1,
     messages: messagesToSend,
     tools: tools.length > 0 ? tools : undefined,
-    ...betas.length > 0 && { betas },
     metadata: getAPIMetadata(),
     ...getExtraBodyParams(),
     ...containsThinking && {
@@ -285690,6 +285886,8 @@ async function countTokensViaHaikuFallback(messages, tools) {
         budget_tokens: TOKEN_COUNT_THINKING_BUDGET
       }
     }
+  }, {
+    ...betas.length > 0 ? { headers: headersForBetas2(betas) } : {}
   });
   const usage = response.usage;
   const inputTokens = usage.input_tokens;
@@ -293420,6 +293618,11 @@ var init_apiMicrocompact = __esm(() => {
 
 // src/controller/loop.ts
 import { randomUUID as randomUUID17 } from "crypto";
+function headersForBetas3(betas) {
+  if (!betas || betas.length === 0)
+    return;
+  return { "anthropic-beta": betas.join(",") };
+}
 function adjustParamsForNonStreaming(params, maxTokensCap) {
   const cappedMaxTokens = Math.min(params.max_tokens, maxTokensCap);
   const adjustedParams = { ...params };
@@ -293497,13 +293700,16 @@ async function* executeNonStreamingRequest(clientOptions, retryOptions, paramsFr
     captureRequest(retryParams);
     onAttempt(attempt, start, retryParams.max_tokens);
     const adjustedParams = adjustParamsForNonStreaming(retryParams, MAX_NON_STREAMING_TOKENS);
+    const { betas: requestBetas, ...standardParams } = adjustedParams;
+    const headers = headersForBetas3(requestBetas);
     try {
-      return await anthropic.beta.messages.create({
-        ...adjustedParams,
-        model: normalizeModelStringForAPI(adjustedParams.model)
+      return await anthropic.messages.create({
+        ...standardParams,
+        model: normalizeModelStringForAPI(standardParams.model)
       }, {
         signal: retryOptions.signal,
-        timeout: fallbackTimeoutMs
+        timeout: fallbackTimeoutMs,
+        ...headers ? { headers } : {}
       });
     } catch (err2) {
       if (err2 instanceof APIUserAbortError)
@@ -293985,11 +294191,19 @@ ${deferredToolList}
         headlessProfilerCheckpoint("api_request_sent");
       }
       clientRequestId = shouldSendClientRequestId() ? randomUUID17() : undefined;
-      const result = await anthropic.beta.messages.create({ ...params, stream: true }, {
-        signal,
+      const { betas: requestBetas, ...standardParams } = params;
+      const headers = {
+        ...headersForBetas3(requestBetas) ?? {},
         ...clientRequestId && {
-          headers: { [CLIENT_REQUEST_ID_HEADER]: clientRequestId }
+          [CLIENT_REQUEST_ID_HEADER]: clientRequestId
         }
+      };
+      const result = await anthropic.messages.create({
+        ...standardParams,
+        stream: true
+      }, {
+        signal,
+        ...Object.keys(headers).length > 0 ? { headers } : {}
       }).withResponse();
       queryCheckpoint("query_response_headers_received");
       streamRequestId = result.request_id;
@@ -297044,6 +297258,11 @@ function stripToolReferenceBlocksFromUserMessage(message) {
     }
   };
 }
+function omitToolSearchCaller(block2) {
+  const blockWithoutCaller = { ...block2 };
+  delete blockWithoutCaller.caller;
+  return blockWithoutCaller;
+}
 function stripCallerFieldFromAssistantMessage(message) {
   const hasCallerField = message.message.content.some((block2) => block2.type === "tool_use" && ("caller" in block2) && block2.caller !== null);
   if (!hasCallerField) {
@@ -297057,12 +297276,7 @@ function stripCallerFieldFromAssistantMessage(message) {
         if (block2.type !== "tool_use") {
           return block2;
         }
-        return {
-          type: "tool_use",
-          id: block2.id,
-          name: block2.name,
-          input: block2.input
-        };
+        return omitToolSearchCaller(block2);
       })
     }
   };
@@ -297339,9 +297553,9 @@ function normalizeMessagesForAPI(messages, tools = []) {
                     input: normalizedInput
                   };
                 }
+                const blockWithoutCaller = omitToolSearchCaller(block2);
                 return {
-                  type: "tool_use",
-                  id: block2.id,
+                  ...blockWithoutCaller,
                   name: canonicalName,
                   input: normalizedInput
                 };
@@ -297538,6 +297752,15 @@ function mergeUserContentBlocks(a2, b) {
   }
   return [...a2.slice(0, -1), smooshed, ...toolResults];
 }
+function normalizeToolUseIdFromAPI(contentBlock) {
+  if (typeof contentBlock.id === "string" && contentBlock.id.trim().length > 0) {
+    return contentBlock.id;
+  }
+  logEvent("tengu_tool_use_missing_id_repaired", {
+    toolName: sanitizeToolNameForAnalytics(contentBlock.name)
+  });
+  return `toolu_${randomUUID18().replace(/-/g, "")}`;
+}
 function normalizeContentFromAPI(contentBlocks, tools, agentId) {
   if (!contentBlocks) {
     return [];
@@ -297576,6 +297799,7 @@ function normalizeContentFromAPI(contentBlocks, tools, agentId) {
         }
         return {
           ...contentBlock,
+          id: normalizeToolUseIdFromAPI(contentBlock),
           input: normalizedInput
         };
       }
@@ -300659,6 +300883,17 @@ class QueryEngine {
         };
         return;
       }
+      const recentErrors = (() => {
+        const all4 = getInMemoryErrors();
+        const start = errorLogWatermark ? all4.lastIndexOf(errorLogWatermark) + 1 : 0;
+        return all4.slice(start).map((_) => _.error);
+      })();
+      const edeDiagnostic = buildErrorDuringExecutionDiagnostic({
+        resultType: edeResultType,
+        lastContentType: edeLastContentType,
+        stopReason: lastStopReason
+      });
+      logForDebugging(edeDiagnostic, { level: "warn" });
       yield {
         type: "result",
         subtype: "error_during_execution",
@@ -300674,14 +300909,10 @@ class QueryEngine {
         permission_denials: this.permissionDenials,
         fast_mode_state: getFastModeState(mainLoopModel, initialAppState.fastMode),
         uuid: randomUUID23(),
-        errors: (() => {
-          const all4 = getInMemoryErrors();
-          const start = errorLogWatermark ? all4.lastIndexOf(errorLogWatermark) + 1 : 0;
-          return [
-            `[ede_diagnostic] result_type=${edeResultType} last_content_type=${edeLastContentType} stop_reason=${lastStopReason}`,
-            ...all4.slice(start).map((_) => _.error)
-          ];
-        })()
+        errors: buildErrorDuringExecutionErrors({
+          recentErrors,
+          stopReason: lastStopReason
+        })
       };
       return;
     }
@@ -329561,7 +329792,7 @@ function extractToolUseId2(message) {
     return;
   for (let i3 = content.length - 1;i3 >= 0; i3--) {
     const block2 = content[i3];
-    if (block2?.type === "tool_use" && typeof block2.id === "string") {
+    if (block2?.type === "tool_use" && typeof block2.id === "string" && block2.id.trim().length > 0) {
       return block2.id;
     }
   }
@@ -329651,6 +329882,7 @@ function mergeAndFilterTools(initialTools, assembled, mode) {
 
 // src/session/sdkRuntime.ts
 init_config2();
+init_envVars();
 var getAsk = () => (init_QueryEngine(), __toCommonJS(exports_QueryEngine)).ask;
 var getModelInvocableCommands2 = async (cwd) => {
   const mod = (init_runtime(), __toCommonJS(exports_runtime));
@@ -329809,11 +330041,19 @@ function normalizeInitialMessages(raw) {
   }
   return normalized;
 }
+function extraBodyFromOptions(options2) {
+  const extraBody = options2.extra_body;
+  if (!extraBody || typeof extraBody !== "object" || Array.isArray(extraBody)) {
+    return;
+  }
+  return extraBody;
+}
 function optionsWithProviderRoutingEnv(options2) {
   const transport = options2.transport;
   const reasoningEffort = options2.reasoningEffort;
   const openaiResponses = options2.providerSpecific?.openaiResponses;
-  if (transport === undefined && reasoningEffort === undefined && openaiResponses === undefined) {
+  const extraBody = extraBodyFromOptions(options2);
+  if (transport === undefined && reasoningEffort === undefined && openaiResponses === undefined && extraBody === undefined) {
     return options2;
   }
   const mergedEnv = { ...options2.env ?? {} };
@@ -329828,6 +330068,11 @@ function optionsWithProviderRoutingEnv(options2) {
   if (openaiResponses && typeof openaiResponses === "object") {
     mergedEnv[QUERY_ENV_KEY_PROVIDER_SPECIFIC_OPENAI_RESPONSES] = JSON.stringify(openaiResponses);
   }
+  if (extraBody) {
+    const rawExtraBody = JSON.stringify(extraBody);
+    mergedEnv[ENV_VARS.EXTRA_BODY.primary] = rawExtraBody;
+    mergedEnv[QUERY_ENV_KEY_EXTRA_BODY] = rawExtraBody;
+  }
   return { ...options2, env: mergedEnv };
 }
 function createQueryLike(generator, runtimeState, onClose) {
@@ -335712,6 +335957,11 @@ init_generators();
 init_clientFactory();
 init_retry();
 init_requestShaping();
+function headersForBetas4(betas) {
+  if (!betas || betas.length === 0)
+    return;
+  return { "anthropic-beta": betas.join(",") };
+}
 async function verifyApiKey(apiKey, isNonInteractiveSession) {
   if (isNonInteractiveSession) {
     return true;
@@ -335726,14 +335976,15 @@ async function verifyApiKey(apiKey, isNonInteractiveSession) {
       source: "verify_api_key"
     }), async (anthropic) => {
       const messages = [{ role: "user", content: "test" }];
-      await anthropic.beta.messages.create({
+      await anthropic.messages.create({
         model,
         max_tokens: 1,
         messages,
         temperature: 1,
-        ...betas.length > 0 && { betas },
         metadata: getAPIMetadata(),
         ...getExtraBodyParams()
+      }, {
+        ...betas.length > 0 ? { headers: headersForBetas4(betas) } : {}
       });
       return true;
     }, { maxRetries: 2, model, thinkingConfig: { type: "disabled" } }));
@@ -336132,4 +336383,4 @@ export {
   AbortError2 as AbortError
 };
 
-//# debugId=F19FA9D2F1AEFB9664756E2164756E21
+//# debugId=7503E4A2FEE6F7C164756E2164756E21