negotium 0.23.2 → 0.23.4

package/dist/mcp-factories.js

@@ -5015,6 +5015,49 @@ function extractCodexForkedFromId(jsonl) {
     return;
   }
 }
+function extractLatestCodexSystemInstructionsTurn(jsonl) {
+  const lines = jsonl.trimEnd().split(`
+`);
+  for (let index = lines.length - 1;index >= 0; index -= 1) {
+    const line = lines[index] ?? "";
+    if (!line.includes("[System Instructions]"))
+      continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type !== "response_item")
+        continue;
+      if (entry.payload?.type !== "message" || entry.payload.role !== "user")
+        continue;
+      const text = (entry.payload.content ?? []).map((part) => typeof part.text === "string" ? part.text : "").join("");
+      if (text.startsWith(`[System Instructions]
+`))
+        return text;
+    } catch {}
+  }
+  return;
+}
+function codexThreadHasSystemPrompt(threadId, systemPrompt, depth = 0) {
+  const path = latestCodexRolloutPath(threadId);
+  if (!path)
+    return false;
+  try {
+    const jsonl = readFileSync6(path, "utf8");
+    const latest = extractLatestCodexSystemInstructionsTurn(jsonl);
+    if (latest !== undefined) {
+      return latest.startsWith(`[System Instructions]
+${systemPrompt}
+
+`);
+    }
+    if (depth >= 8)
+      return false;
+    const parentId = extractCodexForkedFromId(jsonl);
+    return parentId && parentId !== threadId ? codexThreadHasSystemPrompt(parentId, systemPrompt, depth + 1) : false;
+  } catch (error) {
+    logger.debug({ error, threadId }, "codex system prompt: rollout read failed");
+    return false;
+  }
+}
 function readLatestCodexTokenTotals(threadId, depth = 0) {
   const path = latestCodexRolloutPath(threadId);
   if (!path)
@@ -5284,7 +5327,7 @@ var init_codex = __esm(async () => {
 });
 
 // ../../packages/core/src/version.ts
-var NEGOTIUM_VERSION = "0.23.2";
+var NEGOTIUM_VERSION = "0.23.4";
 
 // ../../packages/core/src/agents/codex-native-multi-agent.ts
 import { spawn as spawn2 } from "child_process";
@@ -9739,6 +9782,97 @@ function memoizeImport(loader) {
   };
 }
 
+// ../../packages/core/src/agents/claude-notices.ts
+function modelLabel(id) {
+  const match = /^claude-([a-z]+)-(\d+)-(\d+)/.exec(id);
+  if (!match)
+    return id;
+  const [, family = "", major, minor] = match;
+  return `${family.charAt(0).toUpperCase()}${family.slice(1)} ${major}.${minor}`;
+}
+function rateLimitNotice(m) {
+  const { status, rateLimitType } = m.rate_limit_info;
+  const limit = rateLimitType ? `${RATE_LIMIT_TEXT[rateLimitType] ?? ""} `.trimStart() : "";
+  if (status === "allowed_warning")
+    return `Nearing your ${limit}Claude usage limit`;
+  if (status === "rejected")
+    return `Reached your ${limit}Claude usage limit`;
+  return;
+}
+function claudeNoticeStatus(message) {
+  try {
+    if (message.type === "rate_limit_event")
+      return rateLimitNotice(message);
+    if (message.type !== "system")
+      return;
+    const handler = SYSTEM_NOTICES[message.subtype];
+    if (!handler) {
+      logger.debug({ subtype: message.subtype, msg: message }, "claudeProvider: system message (unhandled subtype)");
+      return;
+    }
+    const status = handler(message);
+    if (status)
+      logger.warn({ subtype: message.subtype, status }, "claudeProvider: notice");
+    return status;
+  } catch (err) {
+    logger.debug({ err, msg: message }, "claudeProvider: notice mapping failed");
+    return;
+  }
+}
+var API_ERROR_TEXT, RATE_LIMIT_TEXT, DENIAL_TEXT, SYSTEM_NOTICES;
+var init_claude_notices = __esm(() => {
+  init_logger();
+  API_ERROR_TEXT = {
+    overloaded: "Claude is overloaded",
+    rate_limit: "Claude rate limit hit",
+    server_error: "Claude API error",
+    unknown: "Claude request failed",
+    authentication_failed: "Claude sign-in failed",
+    oauth_org_not_allowed: "Organization not allowed for Claude",
+    account_on_hold: "Claude account is on hold",
+    verification_required: "Claude account needs verification",
+    billing_error: "Claude billing issue",
+    invalid_request: "Claude rejected the request",
+    model_not_found: "Claude model not found",
+    max_output_tokens: "Claude reply hit the length limit",
+    cloud_credential_error: "Cloud credentials failed"
+  };
+  RATE_LIMIT_TEXT = {
+    five_hour: "5-hour",
+    seven_day: "weekly",
+    seven_day_opus: "weekly Opus",
+    seven_day_sonnet: "weekly Sonnet",
+    seven_day_overage_included: "weekly",
+    overage: "extra usage"
+  };
+  DENIAL_TEXT = {
+    rule: "by a permission rule",
+    mode: "by the permission mode",
+    classifier: "by the safety check",
+    asyncAgent: "for a background agent"
+  };
+  SYSTEM_NOTICES = {
+    api_retry: (m) => {
+      const reason = m.error_status === null ? "Lost connection to Claude" : API_ERROR_TEXT[m.error] ?? "Claude request failed";
+      const delay2 = Math.round(m.retry_delay_ms / 1000);
+      const when = delay2 > 0 ? `in ${delay2}s` : "now";
+      return `${reason} \xB7 retrying ${when} (${m.attempt}/${m.max_retries})`;
+    },
+    model_refusal_fallback: (m) => m.direction === "retry" ? `${modelLabel(m.original_model)} declined \xB7 ${modelLabel(m.fallback_model)} is answering instead` : m.content || undefined,
+    model_refusal_no_fallback: (m) => `${modelLabel(m.original_model)} declined this request`,
+    permission_denied: (m) => {
+      const tool = m.tool_name.split("__").at(-1) || m.tool_name;
+      const why = m.decision_reason ? `: ${m.decision_reason}` : ` ${DENIAL_TEXT[m.decision_reason_type ?? ""] ?? ""}`.trimEnd();
+      return `${tool} was blocked${why}`;
+    },
+    informational: (m) => m.prevent_continuation || m.level === "warning" || m.level === "suggestion" ? m.content : undefined,
+    mirror_error: (m) => {
+      logger.warn({ error: m.error }, "claudeProvider: transcript mirror batch dropped");
+      return;
+    }
+  };
+});
+
 // ../../packages/core/src/agents/deep-map.ts
 function deepMapStrings2(value2, fn) {
   if (typeof value2 === "string")
@@ -10237,12 +10371,13 @@ async function* claudeProvider(opts) {
         yield { type: "tool_use_summary", summary: m.summary };
         continue;
       }
-      if (message.type === "system") {
-        const m = message;
-        if (m.subtype === "init") {
-          yield { type: "session", sessionId: m.session_id };
+      if (message.type === "system" || message.type === "rate_limit_event") {
+        if (message.type === "system" && message.subtype === "init") {
+          yield { type: "session", sessionId: message.session_id };
         } else {
-          logger.debug({ subtype: m.subtype, msg: m }, "claudeProvider: system message (unhandled subtype)");
+          const status = claudeNoticeStatus(message);
+          if (status)
+            yield { type: "status", content: status };
         }
         continue;
       }
@@ -10353,6 +10488,7 @@ async function* claudeProvider(opts) {
 }
 var CLAUDE_DEFAULT_DISALLOWED_TOOLS, CLAUDE_NATIVE_AGENT_TOOLS, CLAUDE_IMAGE_MAX_BYTES, CLAUDE_IMAGE_MIME_TYPES, CLAUDE_ABORT_SIGKILL_DELAY_MS = 2500, claudeProcessExitListeners;
 var init_claude_provider = __esm(async () => {
+  init_claude_notices();
   init_claude_registry();
   init_vault_tool_policy();
   init_file_events();
@@ -11510,13 +11646,22 @@ var exports_codex_provider = {};
 __export(exports_codex_provider, {
   toCodexMcpServers: () => toCodexMcpServers,
   normalizeCodexTurnUsage: () => normalizeCodexTurnUsage,
-  codexProvider: () => codexProvider
+  codexProvider: () => codexProvider,
+  codexNoticeStatus: () => codexNoticeStatus
 });
 import { execFileSync as execFileSync6 } from "child_process";
 import { existsSync as existsSync20, readFileSync as readFileSync16, realpathSync as realpathSync5, statSync as statSync6 } from "fs";
 import { homedir as homedir6 } from "os";
 import { dirname as dirname14, isAbsolute as isAbsolute4, join as join20, relative as relative3, resolve as resolve14 } from "path";
 import { Codex } from "@openai/codex-sdk";
+function codexNoticeStatus(message) {
+  const firstLine = message.trim().split(`
+`)[0]?.trim() ?? "";
+  const sentence = /^.*?[.!?](?=\s|$)/.exec(firstLine)?.[0] ?? firstLine;
+  if (!sentence)
+    return "Codex notice";
+  return /^codex\b/i.test(sentence) ? sentence : `Codex: ${sentence}`;
+}
 function sameCodexUsage(usage, total) {
   return usage.input_tokens === total.inputTokens && usage.output_tokens === total.outputTokens && (usage.cached_input_tokens ?? 0) === total.cachedInputTokens && (usage.cache_write_input_tokens ?? 0) === total.cacheWriteInputTokens;
 }
@@ -11934,8 +12079,7 @@ async function* codexProvider(opts) {
       },
       hooks: vaultHook.hooks,
       model_catalog_json: codexModelCatalogPath,
-      mcp_servers: codexMcpServers,
-      ...opts.toolPolicy ? { sandbox_permissions: [] } : {}
+      mcp_servers: codexMcpServers
     }
   });
   const threadOptions = {
@@ -11956,7 +12100,7 @@ async function* codexProvider(opts) {
   let currentSessionId = opts.sessionId;
   let usageBaseline = currentSessionId ? readLatestCodexTokenTotals(currentSessionId) : undefined;
   let thread = currentSessionId ? codex.resumeThread(currentSessionId, threadOptions) : codex.startThread(threadOptions);
-  let prompt = promptForThread(opts, true);
+  let prompt = promptForThread(opts, !currentSessionId || !opts.systemPrompt || !codexThreadHasSystemPrompt(currentSessionId, opts.systemPrompt));
   let agentTextSoFar = "";
   let currentAgentMessageId;
   let finalText = "";
@@ -11984,6 +12128,8 @@ async function* codexProvider(opts) {
       trackedPids.pids = [];
       let heartbeatTriggered = false;
       let attemptCompleted = false;
+      let turnFailed = false;
+      let streamError;
       let heartbeatTimer = null;
       const scheduleHeartbeat = () => {
         if (heartbeatTimer !== null)
@@ -12112,7 +12258,8 @@ async function* codexProvider(opts) {
               } else if (item.type === "error") {
                 const message = String(item.message ?? "");
                 if (message !== CODEX_HOOK_TRUST_BYPASS_NOTICE) {
-                  yield { type: "error", content: message };
+                  logger.warn({ message }, "codexProvider: codex non-fatal error item");
+                  yield { type: "status", content: codexNoticeStatus(message) };
                 }
               }
               break;
@@ -12140,7 +12287,15 @@ async function* codexProvider(opts) {
                 yield* extractFileEvents(finalText, "result");
               break;
             }
+            case "error": {
+              const message = event.message || "Codex stream error";
+              logger.warn({ message }, "codexProvider: codex stream error event");
+              streamError = message;
+              yield { type: "status", content: codexNoticeStatus(message) };
+              break;
+            }
             case "turn.failed": {
+              turnFailed = true;
               stopReason = "error";
               yield {
                 type: "error",
@@ -12152,6 +12307,10 @@ async function* codexProvider(opts) {
               break;
           }
         }
+        if (!attemptCompleted && !turnFailed && streamError) {
+          stopReason = "error";
+          yield { type: "error", content: streamError };
+        }
       } catch (err) {
         if (abortSignal?.aborted)
           return;
@@ -25898,4 +26057,4 @@ export {
   createAgentHealthMcpServer
 };
 
-//# debugId=18366C463A8C391664756E2164756E21
+//# debugId=3960629E03CACCC364756E2164756E21