@mrrlin-dev/mcp 0.4.139 → 0.4.142

package/dist/bin.cjs

@@ -43704,7 +43704,8 @@ var CodexServerManager = class {
       thread: {
         start: (params) => rpcClient.request("thread/start", params),
         resume: (params) => rpcClient.request("thread/resume", params),
-        read: (params) => rpcClient.request("thread/read", params)
+        read: (params) => rpcClient.request("thread/read", params),
+        loadedList: (params) => rpcClient.request("thread/loaded/list", params)
       },
       turn: {
         start: (params) => rpcClient.request("turn/start", params),
@@ -43771,6 +43772,28 @@ function addTurnTokenUsage(total, turn) {
     outputTokens: add2(total.outputTokens, turn.outputTokens)
   };
 }
+var CONTEXT_WINDOW_TOKENS = 2e5;
+function extractContextWindow(method, params) {
+  if (method !== TOKEN_USAGE_NOTIFICATION_METHOD)
+    return null;
+  if (params === null || typeof params !== "object")
+    return null;
+  const usage = params.tokenUsage;
+  if (usage === null || typeof usage !== "object")
+    return null;
+  const window = readCount(usage, "modelContextWindow");
+  return window !== null && window > 0 ? window : null;
+}
+function isNearContextLimit(usage, contextWindow) {
+  if (!usage)
+    return false;
+  const contextTokens = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
+  if (contextTokens <= 0)
+    return false;
+  const window = contextWindow && contextWindow > 0 ? contextWindow : CONTEXT_WINDOW_TOKENS;
+  const remainingTokens = window - contextTokens;
+  return remainingTokens / window < 0.03 || remainingTokens < 4e3;
+}
 
 // ../../packages/agent-client/dist/providers/codex/event-mapper.js
 var CodexBridgeEventMapper = class {
@@ -43937,7 +43960,8 @@ var CodexBridgeEventMapper = class {
     const usage = extractTurnTokenUsage(TOKEN_USAGE_NOTIFICATION_METHOD, notification.params);
     if (!usage)
       return [];
-    return [{ type: "token_usage", usage }];
+    const contextWindow = extractContextWindow(TOKEN_USAGE_NOTIFICATION_METHOD, notification.params);
+    return [contextWindow === null ? { type: "token_usage", usage } : { type: "token_usage", usage, contextWindow }];
   }
   /** Bare `error` notifications carry model-stream failures ({ error: { message }, willRetry }).
    * Retryable ones (willRetry=true) are transport noise — codex is still driving the turn — so
@@ -44339,12 +44363,57 @@ var CodexProviderAdapter = class {
 function createCodexAgentHandle(client) {
   return new CodexAgentHandle(client);
 }
+var MRRLIN_MCP_SERVER = "mrrlin";
+function codexThreadConfig(env) {
+  if (!env)
+    return null;
+  const config2 = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (!ENV_NAME.test(key))
+      continue;
+    config2[`mcp_servers.${MRRLIN_MCP_SERVER}.env.${key}`] = value ?? "";
+  }
+  return Object.keys(config2).length > 0 ? config2 : null;
+}
+var ENV_NAME = /^[A-Z_][A-Z0-9_]*$/;
+var loadedThreadConfig = /* @__PURE__ */ new WeakMap();
+function threadConfigsOf(client) {
+  let configs = loadedThreadConfig.get(client);
+  if (!configs) {
+    configs = /* @__PURE__ */ new Map();
+    loadedThreadConfig.set(client, configs);
+  }
+  return configs;
+}
+function configSignature(config2) {
+  return JSON.stringify(Object.entries(config2 ?? {}).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+}
+var resumeQueues = /* @__PURE__ */ new WeakMap();
+function serializePerThread(client, threadId, work) {
+  let queues = resumeQueues.get(client);
+  if (!queues) {
+    queues = /* @__PURE__ */ new Map();
+    resumeQueues.set(client, queues);
+  }
+  const previous = queues.get(threadId) ?? Promise.resolve();
+  const run3 = previous.then(work, work);
+  const settled = run3.then(() => {
+  }, () => {
+  });
+  queues.set(threadId, settled);
+  void settled.then(() => {
+    if (queues.get(threadId) === settled)
+      queues.delete(threadId);
+  });
+  return run3;
+}
 var CodexAgentHandle = class {
   client;
   constructor(client) {
     this.client = client;
   }
   async startThread(params) {
+    const config2 = codexThreadConfig(params.env);
     const started = await this.client.thread.start({
       model: params.model ?? null,
       cwd: params.cwd ?? null,
@@ -44353,21 +44422,59 @@ var CodexAgentHandle = class {
       baseInstructions: params.baseInstructions ?? null,
       developerInstructions: params.developerInstructions ?? null,
       ephemeral: params.ephemeral ?? null,
-      mcpConfig: params.mcpConfig ?? null
+      mcpConfig: params.mcpConfig ?? null,
+      config: config2
     });
+    threadConfigsOf(this.client).set(started.thread.id, configSignature(config2));
     return { threadId: started.thread.id };
   }
-  async resumeThread(threadId, params) {
+  resumeThread(threadId, params) {
+    return serializePerThread(this.client, threadId, () => this.resumeNow(threadId, params));
+  }
+  async resumeNow(threadId, params) {
+    const config2 = codexThreadConfig(params.env);
+    const signature = configSignature(config2);
+    const configs = threadConfigsOf(this.client);
+    const loadedWith = configs.get(threadId);
+    if (loadedWith !== void 0 && loadedWith !== signature) {
+      configs.delete(threadId);
+      throw new Error("codex: thread binding changed; start a fresh thread");
+    }
+    if (loadedWith === void 0 && await this.isLoaded(threadId)) {
+      throw new Error("codex: thread is loaded with an unknown binding; start a fresh thread");
+    }
     const resumed = await this.client.thread.resume({
       threadId,
       model: params.model ?? null,
       cwd: params.cwd ?? null,
       approvalPolicy: params.approvalPolicy ?? null,
       sandbox: params.sandbox ?? null,
-      mcpConfig: params.mcpConfig ?? null
+      mcpConfig: params.mcpConfig ?? null,
+      config: config2
     });
+    configs.set(resumed.thread.id, signature);
     return { threadId: resumed.thread.id };
   }
+  /** Whether this app-server currently holds the thread. A query that fails counts as loaded, so
+   * the caller gets a fresh thread rather than a possibly stale one. A client without the query
+   * (a wrapper or test double; the app-server client always has it) can only hold the threads this
+   * adapter recorded, so for it an unrecorded thread is not loaded. */
+  async isLoaded(threadId) {
+    if (!this.client.thread.loadedList)
+      return false;
+    try {
+      let cursor = null;
+      do {
+        const page = await this.client.thread.loadedList(cursor ? { cursor } : {});
+        if (page.data?.includes(threadId))
+          return true;
+        cursor = page.nextCursor ?? null;
+      } while (cursor);
+      return false;
+    } catch {
+      return true;
+    }
+  }
   async startTurn(threadId, input, effort) {
     const accepted = await this.client.turn.start({ threadId, input, ...effort ? { effort } : {} });
     return { turnId: accepted?.turn?.id };
@@ -59211,22 +59318,22 @@ function isBridgeRunWorktree(worktreePath, checkout, worktreeRoot) {
     return false;
   }
 }
-var short = (sha) => (sha ?? "").slice(0, 7);
 function localLandingNote(outcome, ctx) {
   const { taskId, title, defaultBranch: d, detail } = ctx;
+  const prefix = `${taskId} (${title})`;
   const bodies = {
-    applied: `${taskId} (${title}) is now in your project's ${d} branch (was ${short(ctx.previousSha)}, now ${short(ctx.headSha)}). If the app is running, restart it to pick up the change.`,
-    already_applied: `${taskId} is already in your ${d} branch.`,
-    uncommitted_changes: `${taskId} is finished and tested, but it could not be placed into your ${d} branch because the project folder has unsaved (uncommitted) changes. Commit or stash them, then ask the Director to apply ${taskId} again.`,
-    would_overwrite_files: `${taskId} is finished and tested, but it could not be placed into your ${d} branch because files in the project folder would be overwritten: ${detail}. Move them aside, then ask the Director to apply ${taskId} again.`,
-    default_branch_moved: `${taskId} is finished and tested, but your ${d} branch received new commits while it was being built. Ask the Director to apply ${taskId} again; it will be merged with the newest version and re-tested first.`,
-    conflict: `${taskId} could not be merged with the newest ${d}: conflicts in ${detail}. Ask the Director to create a follow-up task that reconciles ${taskId} with the current ${d}.`,
-    build_failed: `${taskId} merged with the newest ${d}, but the build or tests failed afterwards (${detail}). Ask the Director to create a follow-up task to fix it.`,
-    ff_failed: `${taskId} could not be placed into your ${d} branch: git refused the update (${detail}). Ask the Director to apply ${taskId} again.`,
-    run_reclaimed: `${taskId} is finished, but it was not placed into your ${d} branch automatically because another Mrrlin bridge took over run ${ctx.runId}. Ask the Director to apply ${taskId} again.`,
-    landing_partial: `${taskId} was only partly placed into your ${d} branch, and Mrrlin could not undo it cleanly (${detail}). Your work is not lost, but please do not change the project folder yet: ask the Director to help you check it.`,
-    run_branch_changed: `${taskId} was not placed into your ${d} branch: its branch mrrlin/run-${ctx.runId} got new commits after the task was finished and checked, so nothing was changed. Ask the Director to restart the run if those commits belong in it.`,
-    delivery_ref_mismatch: `${taskId} was not placed into your ${d} branch: the run's recorded result (${detail}) does not belong to this project and run ${ctx.runId}, so nothing was changed. Ask the Director to look into run ${ctx.runId}.`
+    applied: `${prefix} \u2014 Applied and merged to ${d}. Restart your dev server if running to pick up changes.`,
+    already_applied: `${prefix} \u2014 Already applied to ${d}. No changes needed.`,
+    uncommitted_changes: `${prefix} \u2014 Can't apply: you have uncommitted changes in your project folder. Commit or stash them, then ask the Director to apply ${taskId} again.`,
+    would_overwrite_files: `${prefix} \u2014 Can't apply: local files (${detail}) would be overwritten. Move them aside, then ask the Director to apply ${taskId} again.`,
+    default_branch_moved: `${prefix} \u2014 Can't apply: ${d} received new commits while building. Ask the Director to apply ${taskId} again; it will be merged with the newest version and re-tested first.`,
+    conflict: `${prefix} \u2014 Merge conflicts in ${detail}. Ask the Director to create a follow-up task that reconciles ${taskId} with ${d}.`,
+    build_failed: `${prefix} \u2014 Merged with ${d}, but the build or tests failed (${detail}). Ask the Director to create a follow-up task to fix it.`,
+    ff_failed: `${prefix} \u2014 Could not update ${d} branch: git refused the update (${detail}). Ask the Director to apply ${taskId} again.`,
+    run_reclaimed: `${prefix} \u2014 Run ${ctx.runId} was taken over by another bridge instance. Ask the Director to apply ${taskId} again.`,
+    landing_partial: `${prefix} \u2014 Partially applied (${detail}). Your work is saved. Please do not change the project folder yet: ask the Director to inspect.`,
+    run_branch_changed: `${prefix} \u2014 Not applied: run branch mrrlin/run-${ctx.runId} received new commits. Ask the Director to restart the run if those commits belong in it.`,
+    delivery_ref_mismatch: `${prefix} \u2014 Delivery ref mismatch (${detail}). Nothing was changed. Ask the Director to look into run ${ctx.runId}.`
   };
   return { id: `II-local-apply-${ctx.runId}-${outcome}`, body: bodies[outcome] };
 }
@@ -63710,7 +63817,7 @@ Do NOT derail the current task - if the operator has an in-flight question, answ
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.4.139";
+var PKG_VERSION = "0.4.142";
 
 // src/bridge-allowed-origins.ts
 var DEFAULT_DIRECTOR_BRIDGE_ALLOWED_ORIGINS = [
@@ -67799,6 +67906,7 @@ async function driveTurn(deps, codex, projectSlug, runId, leaseId, threadId, inp
   let touch = () => {
   };
   let turnUsage = null;
+  let turnContextWindow = null;
   const promptBytes = Buffer.byteLength(inputText, "utf8");
   const turnStartedAt = Date.now();
   let lastActivityAt = turnStartedAt;
@@ -67830,6 +67938,7 @@ async function driveTurn(deps, codex, projectSlug, runId, leaseId, threadId, inp
       pending.push(persist(event));
       if (event.type === "token_usage") {
         turnUsage = event.usage;
+        turnContextWindow = event.contextWindow ?? turnContextWindow;
       } else if (event.type === "rate_limits") {
         const signal = detectExhaustedProviderLimit(event.snapshot, Date.now());
         if (signal) {
@@ -67891,7 +68000,7 @@ async function driveTurn(deps, codex, projectSlug, runId, leaseId, threadId, inp
       clearInterval(touchTimer);
       unsub();
     }
-    const telemetry = { promptBytes, usage: turnUsage };
+    const telemetry = { promptBytes, usage: turnUsage, contextWindow: turnContextWindow };
     return turnError ? { ok: false, error: turnError, interruptFailed, telemetry } : { ok: true, telemetry };
   });
 }
@@ -68154,14 +68263,6 @@ async function driveRun(deps, projectSlug, runId) {
     runTelemetry.usage = addTurnTokenUsage(runTelemetry.usage, outcome.telemetry.usage);
     return outcome;
   };
-  const isContextBudgetExhausted = (usage) => {
-    if (!usage) return false;
-    const contextTokens = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
-    if (contextTokens <= 0) return false;
-    const maxTokens = 2e5;
-    const remainingTokens = maxTokens - contextTokens;
-    return remainingTokens / maxTokens < 0.03 || remainingTokens < 4e3;
-  };
   const effortDecision = deriveEffort({
     impact: task.impact,
     type: task.type,
@@ -68505,7 +68606,7 @@ Continue executing task ${task.id}. Make the next concrete increment of progress
       await failRun(deps, projectSlug, task, runId, leaseId, outcome.error);
       return;
     }
-    if (isContextBudgetExhausted(outcome.telemetry.usage)) {
+    if (isNearContextLimit(outcome.telemetry.usage, outcome.telemetry.contextWindow)) {
       console.warn(
         JSON.stringify({
           event: "context_budget_gate_triggered",
@@ -78719,18 +78820,9 @@ function createBridgeMessageHandler(deps) {
               return;
             }
             if (event.type === "token_usage") {
-              const usage = event.usage;
+              const { usage, contextWindow } = event;
               turnTokenUsage = addTurnTokenUsage(turnTokenUsage, usage);
-              if (turnTokenUsage) {
-                const totalTokens = (turnTokenUsage.inputTokens ?? 0) + (turnTokenUsage.outputTokens ?? 0);
-                if (totalTokens > 0) {
-                  const maxTokens = 2e5;
-                  const remainingTokens = maxTokens - totalTokens;
-                  if (remainingTokens / maxTokens < 0.03 || remainingTokens < 4e3) {
-                    contextBudgetGateTriggered = true;
-                  }
-                }
-              }
+              if (isNearContextLimit(usage, contextWindow)) contextBudgetGateTriggered = true;
               return;
             }
             if (event.type === "turn_completed" || event.type === "rate_limits") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrlin-dev/mcp",
-  "version": "0.4.139",
+  "version": "0.4.142",
   "type": "module",
   "bin": {
     "mrrlin-mcp": "dist/bin.cjs"