nolo-cli 0.74.0-alpha.1 → 0.74.0

package/{chunk-CJ23A7U4.js → chunk-PF6O3GR3.js}

@@ -8,7 +8,10 @@ import {
   readSseFrames,
   streamSseDataValues,
   throwIfChatCompletionStreamFailed
-} from "./chunk-HXAINXPQ.js";
+} from "./chunk-NFT2AOK5.js";
+import {
+  DEVIN_CONNECT_URL
+} from "./chunk-FMODTASJ.js";
 import {
   clipToolText,
   hasImageInRuntimeMessages,
@@ -16,12 +19,13 @@ import {
   resolveHistoricalToolContentCap,
   resolveToolOutputProfile,
   stripImagePartsFromMessages
-} from "./chunk-KIS76A2P.js";
+} from "./chunk-AX7RMXSH.js";
 import {
   downgradeUnparsableToolCalls,
   hasParsableObjectArguments,
+  repairTruncatedToolArguments,
   sanitizeForOutbound
-} from "./chunk-2QDDKFG5.js";
+} from "./chunk-CQ3WA2NE.js";
 import {
   createThinkParserState,
   createToolCallAccumulator,
@@ -39,7 +43,7 @@ import {
   requiresBareImageUrl,
   resolveToolGuidedSections,
   toBareImageUrlMessages
-} from "./chunk-ZLPA7K55.js";
+} from "./chunk-ETLZZQJE.js";
 import {
   convertMessagesToResponsesInput,
   extractReasoningFromResponseOutput,
@@ -50,15 +54,6 @@ import {
   toOpenAiCompatibleMessages,
   toResponsesTools
 } from "./chunk-PUOC4YRO.js";
-import {
-  getAntigravityUserAgent,
-  readAntigravityProjectId,
-  resolveAntigravityCloudCodeBaseUrl
-} from "./chunk-PGSKWZCB.js";
-import {
-  buildProviderAuthHeaders,
-  buildProviderExecutionPlan
-} from "./chunk-CMH2SYHX.js";
 import {
   BRIDGE_STREAM_MAX_CHARS,
   DEFAULT_READ_DIALOG_MAX_RESPONSE_CHARS,
@@ -72,7 +67,16 @@ import {
   parseNoloWorkspaceToolArguments,
   readTextStreamUpToChars,
   resolveNoloDialogInput
-} from "./chunk-V3ZKNK5D.js";
+} from "./chunk-ZVN6I33J.js";
+import {
+  getAntigravityUserAgent,
+  readAntigravityProjectId,
+  resolveAntigravityCloudCodeBaseUrl
+} from "./chunk-LHDV2QUI.js";
+import {
+  buildProviderAuthHeaders,
+  buildProviderExecutionPlan
+} from "./chunk-TMPLPCVX.js";
 import {
   buildDialogFallbackTitleFromUserInput
 } from "./chunk-2MBTWINN.js";
@@ -86,7 +90,7 @@ import {
   resolveEmptyAssistantFallbackMessage,
   resolveEmptyAssistantOutcome,
   resolveTruncatedReasoningTailLog
-} from "./chunk-DSRXPQWA.js";
+} from "./chunk-7QVPPOEC.js";
 import {
   COMPACTION_SUMMARY_SCHEMA_VERSION,
   COMPACTION_SUMMARY_SYSTEM_PROMPT,
@@ -13966,9 +13970,17 @@ ${reasoningTailLog}
           try {
             const rawPoisonArguments = toolCall.function?.arguments;
             if (typeof rawPoisonArguments === "string" && rawPoisonArguments.trim() !== "" && !hasParsableObjectArguments(rawPoisonArguments)) {
-              throw new Error(
-                `\u6A21\u578B\u751F\u6210\u7684 tool_call arguments \u4E0D\u662F\u5408\u6CD5 JSON\uFF08\u7591\u4F3C\u4E0A\u6E38\u6D41\u5F0F\u622A\u65AD\uFF0C\u539F\u59CB\u957F\u5EA6 ${rawPoisonArguments.length}\uFF09\u3002\u8BF7\u91CD\u65B0\u5B8C\u6574\u8C03\u7528 ${toolName}\uFF0C\u786E\u4FDD arguments \u662F\u95ED\u5408\u7684 JSON \u5BF9\u8C61\uFF1B\u82E5\u56E0\u53C2\u6570\u8FC7\u957F\u88AB\u622A\u65AD\uFF0C\u5148\u7CBE\u7B80\u53C2\u6570\uFF08\u4E0D\u8981\u5185\u5D4C diff/\u65E5\u5FD7\u7B49\u5927\u6BB5\u6587\u672C\uFF0C\u6539\u4F20\u8DEF\u5F84\u8BA9\u5BF9\u65B9\u81EA\u884C\u8BFB\u53D6\uFF09\u518D\u91CD\u8BD5\u3002`
-              );
+              const repairedArguments = repairTruncatedToolArguments(rawPoisonArguments);
+              if (repairedArguments) {
+                console.log(
+                  `[tool-args-repair] ${toolName}: \u8865\u5168\u88AB\u622A\u65AD\u7684 arguments\uFF08${rawPoisonArguments.length} \u2192 ${repairedArguments.length} \u5B57\u7B26\uFF0C\u5185\u5BB9\u96F6\u635F\u5931\uFF09`
+                );
+                toolCall.function.arguments = repairedArguments;
+              } else {
+                throw new Error(
+                  `\u6A21\u578B\u751F\u6210\u7684 tool_call arguments \u4E0D\u662F\u5408\u6CD5 JSON\uFF08\u7591\u4F3C\u4E0A\u6E38\u6D41\u5F0F\u622A\u65AD\uFF0C\u539F\u59CB\u957F\u5EA6 ${rawPoisonArguments.length}\uFF09\u3002\u8BF7\u91CD\u65B0\u5B8C\u6574\u8C03\u7528 ${toolName}\uFF0C\u786E\u4FDD arguments \u662F\u95ED\u5408\u7684 JSON \u5BF9\u8C61\uFF1B\u82E5\u56E0\u53C2\u6570\u8FC7\u957F\u88AB\u622A\u65AD\uFF0C\u5148\u7CBE\u7B80\u53C2\u6570\uFF08\u4E0D\u8981\u5185\u5D4C diff/\u65E5\u5FD7\u7B49\u5927\u6BB5\u6587\u672C\uFF0C\u6539\u4F20\u8DEF\u5F84\u8BA9\u5BF9\u65B9\u81EA\u884C\u8BFB\u53D6\uFF09\u518D\u91CD\u8BD5\u3002`
+                );
+              }
             }
             const writeTool = toolName === "writeFile" || toolName === "editFile";
             if (writeTool && input.onActionGate && input.fileWriteGateEnabled !== false) {
@@ -15565,7 +15577,6 @@ var DEFAULT_LOCAL_TOOLS = /* @__PURE__ */ new Set([
   "taskWait",
   "taskLogs",
   "taskStop",
-  "tasks",
   // Scheduling tools: forking/observing sub-agents is a declared capability
   // of capable agents, and the blast radius is strictly narrower than
   // execShell (already default-enabled). Requiring an env allowlist for these
@@ -16201,6 +16212,24 @@ var ProcessTaskEventLog = class {
 };
 
 // packages/agent-runtime/processRegistry.ts
+function toProcessTaskView(record) {
+  const capsule = record.resultCapsule;
+  return {
+    taskId: record.taskId,
+    pid: record.pid,
+    pgid: record.pgid,
+    command: record.command,
+    label: record.label,
+    startedAt: record.startedAt,
+    status: record.status,
+    ...record.exitCode !== void 0 ? { exitCode: record.exitCode } : {},
+    persist: record.persist,
+    promoted: record.promoted,
+    transient: record.transient,
+    ...capsule?.durationMs !== void 0 ? { durationMs: capsule.durationMs } : {},
+    ...capsule?.spill ? { outputRef: capsule.spill.displayPath } : {}
+  };
+}
 var taskIdCounter = 0;
 function mintTaskId(pid) {
   taskIdCounter += 1;
@@ -16256,8 +16285,9 @@ var ProcessRegistry = class {
       startedAt: Date.now(),
       status: "running",
       persist: proc.persist ?? false,
-      promoted: false,
-      transient: proc.transient ?? false
+      promoted: proc.promoted ?? false,
+      transient: proc.transient ?? false,
+      owner: proc.owner ?? null
     };
     this.processes.set(proc.pid, record);
     this.byTaskId.set(record.taskId, proc.pid);
@@ -16352,7 +16382,8 @@ var ProcessRegistry = class {
         pid,
         label: item.label,
         command: item.command,
-        status: "stopped"
+        status: "stopped",
+        promoted: item.promoted
       });
       return true;
     }
@@ -16381,15 +16412,17 @@ var ProcessRegistry = class {
           pid: item.pid,
           label: item.label,
           command: item.command,
-          status: "stopped"
+          status: "stopped",
+          promoted: item.promoted
         });
       }
     }
   }
-  markExited(pid, exitCode) {
+  markExited(pid, exitCode, resultCapsule) {
     const item = this.processes.get(pid);
     if (item && item.status === "running") {
       item.exitCode = exitCode;
+      if (resultCapsule) item.resultCapsule = resultCapsule;
       item.status = exitCode === 0 ? "exited" : "failed";
       this.eventLog.append({
         taskId: item.taskId,
@@ -16403,7 +16436,9 @@ var ProcessRegistry = class {
         label: item.label,
         command: item.command,
         status: item.status,
-        exitCode
+        exitCode,
+        promoted: item.promoted,
+        ...item.resultCapsule ? { resultCapsule: item.resultCapsule } : {}
       });
     }
   }
@@ -16444,9 +16479,84 @@ function getProcessRegistry() {
   return registry;
 }
 
+// packages/agent-runtime/processOwnership.ts
+var asNonEmptyString = (value) => {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+};
+function readProcessOwner(runtimeContext) {
+  if (!runtimeContext || typeof runtimeContext !== "object") return null;
+  const dialogId = asNonEmptyString(runtimeContext.dialogId) ?? asNonEmptyString(runtimeContext.parentThreadId);
+  if (!dialogId) return null;
+  const turnId = asNonEmptyString(runtimeContext.turnId);
+  const ownerId = asNonEmptyString(runtimeContext.ownerId);
+  return {
+    dialogId,
+    ...turnId ? { turnId } : {},
+    ...ownerId ? { ownerId } : {}
+  };
+}
+
 // packages/agent-runtime/workspaceShell.ts
 import { resolve as resolve3 } from "node:path";
 import { spawn as spawnChildProcess2 } from "node:child_process";
+
+// packages/agent-runtime/processTaskResult.ts
+var PROCESS_RESULT_CAPSULE_TAIL_CHARS = 4e3;
+var PROCESS_RESULT_CAPSULE_SPILL_THRESHOLD_CHARS = 2e4;
+function tailText(value, maxChars) {
+  if (value.length <= maxChars) return { text: value, truncated: false };
+  return { text: value.slice(-maxChars), truncated: true };
+}
+function formatCapsuleStream(name, value) {
+  return value.trim() ? `${name}:
+${value.replace(/\n+$/, "")}` : "";
+}
+function buildProcessTaskResultCapsule(args2) {
+  const tailChars = args2.tailChars ?? PROCESS_RESULT_CAPSULE_TAIL_CHARS;
+  const spillThresholdChars = args2.spillThresholdChars ?? PROCESS_RESULT_CAPSULE_SPILL_THRESHOLD_CHARS;
+  const stdout = typeof args2.stdout === "string" ? args2.stdout : "";
+  const stderr = typeof args2.stderr === "string" ? args2.stderr : "";
+  const exitCode = args2.exitCode;
+  const captureError = args2.captureError?.trim() || void 0;
+  const durationMs = typeof args2.startedAt === "number" && Number.isFinite(args2.startedAt) ? Math.max(0, (args2.endedAt ?? Date.now()) - args2.startedAt) : void 0;
+  const stdoutTail = tailText(stdout, tailChars);
+  const stderrTail = tailText(stderr, tailChars);
+  const inlineSize = stdout.length + stderr.length;
+  const inlineTruncated = stdoutTail.truncated || stderrTail.truncated;
+  const shouldSpill = inlineTruncated || inlineSize > spillThresholdChars;
+  let spill;
+  if (shouldSpill) {
+    try {
+      const result4 = spillToolOutput({
+        content: [
+          formatCapsuleStream("stdout", stdout),
+          formatCapsuleStream("stderr", stderr)
+        ].filter(Boolean).join("\n\n"),
+        toolName: "execShell",
+        ...args2.workspaceRoot !== void 0 ? { workspaceRoot: args2.workspaceRoot } : {}
+      });
+      spill = {
+        displayPath: result4.displayPath,
+        totalChars: result4.totalChars,
+        totalLines: result4.totalLines
+      };
+    } catch {
+    }
+  }
+  return {
+    stdout: stdoutTail.text,
+    stderr: stderrTail.text,
+    exitCode,
+    ...durationMs !== void 0 ? { durationMs } : {},
+    ...captureError ? { captureError } : {},
+    truncated: inlineTruncated || Boolean(captureError),
+    ...spill ? { spill } : {}
+  };
+}
+
+// packages/agent-runtime/workspaceShell.ts
 var EXEC_SHELL_TIMEOUT_ENV = "NOLO_EXEC_SHELL_TIMEOUT_MS";
 var EXEC_SHELL_DETACH_ENV = "NOLO_EXEC_SHELL_DETACH_MS";
 var DEFAULT_EXEC_SHELL_DETACH_MS = 12e4;
@@ -16826,6 +16936,15 @@ ${stderr.trim()}`, "exitCode: 127"].filter(Boolean).join("\n\n"),
     )
   };
 }
+function stdoutPromiseResult(promise3) {
+  return promise3.then(
+    (value) => ({ value }),
+    (error) => ({
+      value: "",
+      error: error instanceof Error ? error.message : String(error)
+    })
+  );
+}
 async function runWorkspaceCommand(args2) {
   const timeoutMs = asOptionalPositiveFiniteNumber(args2.timeoutMs);
   const detached = process.platform !== "win32";
@@ -16857,8 +16976,10 @@ async function runWorkspaceCommand(args2) {
       // Foreground grace-period envelope: not a user-visible background task
       // until promote() flips the marker on timeout detach (see
       // listBackground). Keeps the status line / /procs / /stop semantics
-      // identical to pre-Phase-0.
-      transient: true
+      // identical to pre-Phase-0. Ownership rides along so the promoted record
+      // stays attributable without any terminal-time inference.
+      transient: true,
+      owner: args2.owner ?? null
     });
   }
   const exitPromise = waitForNodeProcessExit(proc);
@@ -16882,8 +17003,8 @@ async function runWorkspaceCommand(args2) {
     process.removeListener("SIGINT", cleanupChildOnHostSignal);
   };
   exitPromise.then(detachSignalCleanup, detachSignalCleanup);
-  const stdoutPromise = readNodeStream(proc.stdout);
-  const stderrPromise = readNodeStream(proc.stderr);
+  const stdoutCapture = stdoutPromiseResult(readNodeStream(proc.stdout));
+  const stderrCapture = stdoutPromiseResult(readNodeStream(proc.stderr));
   const killChild = (signal) => {
     if (detached && typeof proc.pid === "number") {
       try {
@@ -16971,11 +17092,41 @@ async function runWorkspaceCommand(args2) {
     const pid = typeof proc.pid === "number" ? proc.pid : 0;
     const pgid = pid;
     const promoted = registry2.promote(pid);
-    const envelope = promoted ?? registry2.add({ pid, pgid, command: args2.command.join(" "), label });
+    const envelope = promoted ?? registry2.add({
+      pid,
+      pgid,
+      command: args2.command.join(" "),
+      label,
+      promoted: true,
+      owner: args2.owner ?? null
+    });
     const taskId = envelope.taskId;
     proc.on("close", (code) => {
       detachSignalCleanup();
-      registry2.markExited(pid, code ?? 1);
+      const exitCode2 = code ?? 1;
+      void (async () => {
+        const [stdoutResult, stderrResult] = await Promise.all([
+          stdoutCapture,
+          stderrCapture
+        ]);
+        const stdout2 = stdoutResult.value;
+        const stderr2 = stderrResult.value;
+        let capsule;
+        try {
+          capsule = buildProcessTaskResultCapsule({
+            stdout: stdout2,
+            stderr: stderr2,
+            exitCode: exitCode2,
+            // Duration is measured from the registry envelope's startedAt
+            // (spawn moment), not from the detach moment.
+            startedAt: registry2.get(pid)?.startedAt,
+            workspaceRoot: args2.workspaceRoot,
+            captureError: [stdoutResult.error, stderrResult.error].filter(Boolean).join("; ")
+          });
+        } catch {
+        }
+        registry2.markExited(pid, exitCode2, capsule);
+      })();
     });
     const immediate = effectiveDetachMs === 0;
     const reason = immediate ? `command looks long-running; moved to background immediately (pid=${pid}, label=${label})` : `command detached to background after ${effectiveDetachMs}ms (pid=${pid}, label=${label})`;
@@ -16999,10 +17150,13 @@ Use listProcesses to inspect or stop it.`,
       })
     };
   }
-  const [stdout, rawStderr] = await Promise.all([
-    stdoutPromise,
-    stderrPromise
+  const [stdoutCaptureResult, stderrCaptureResult] = await Promise.all([
+    stdoutCapture,
+    stderrCapture
   ]);
+  const stdout = stdoutCaptureResult.value;
+  const rawStderr = stderrCaptureResult.value;
+  const streamCaptureError = [stdoutCaptureResult.error, stderrCaptureResult.error].filter(Boolean).join("; ");
   const exitCode = aborted ? 130 : timedOut ? 124 : Number(raceWinner);
   if (typeof proc.pid === "number") {
     registry2.completeTransient(proc.pid, exitCode);
@@ -17378,7 +17532,11 @@ var execShellCapability = {
       commandPrefix: ctx.commandPrefix,
       abortSignal: ctx.abortSignal,
       detachMs: isImmediateDetachShellCommand({ command }) ? 0 : ctx.detachMs,
-      stdin: typeof normalized.input === "string" ? normalized.input : void 0
+      stdin: typeof normalized.input === "string" ? normalized.input : void 0,
+      // Ownership of the turn that invoked this command: an auto-detached
+      // command keeps its parent dialog so its terminal can resume that
+      // conversation (see processOwnership.ts). Absent ctx.owner = unowned.
+      owner: ctx.owner ?? null
     });
     return {
       content: result4.content,
@@ -17417,7 +17575,6 @@ var WORKSPACE_TOOL_NAMES = [
   "taskWait",
   "taskLogs",
   "taskStop",
-  "tasks",
   "openDesktopPreview"
 ];
 var SHELL_TOOL_NAMES = [
@@ -17426,8 +17583,7 @@ var SHELL_TOOL_NAMES = [
   "listProcesses",
   "taskWait",
   "taskLogs",
-  "taskStop",
-  "tasks"
+  "taskStop"
 ];
 var WORKSPACE_TOOL_NAME_SET = new Set(WORKSPACE_TOOL_NAMES);
 function buildWorkspacePathProperty() {
@@ -17739,19 +17895,6 @@ function buildTaskStopTool() {
     }
   };
 }
-function buildTasksTool() {
-  return {
-    type: "function",
-    function: {
-      name: "tasks",
-      description: "List background tasks you can still wait on, read logs from, or stop. Returns {count, tasks: {taskId, pid, label, status, startedAt, persist}[]}. Use it to recover a taskId you lost track of; foreground commands still running inside execShell are not listed.",
-      parameters: {
-        type: "object",
-        properties: {}
-      }
-    }
-  };
-}
 function buildWorkspaceToolDefinition(toolName) {
   if (toolName === "readFile") {
     return buildReadWorkspaceFileTool();
@@ -17773,7 +17916,6 @@ function buildWorkspaceToolDefinition(toolName) {
   if (toolName === "taskWait") return buildTaskWaitTool();
   if (toolName === "taskLogs") return buildTaskLogsTool();
   if (toolName === "taskStop") return buildTaskStopTool();
-  if (toolName === "tasks") return buildTasksTool();
   return null;
 }
 function filterDeclaredWorkspaceToolNames(args2) {
@@ -18790,7 +18932,10 @@ async function execShellTool(args2) {
       enableDestructiveShellGuard: args2.enableDestructiveShellGuard,
       confirmDestructiveAction: args2.confirmDestructiveAction,
       blockDestructiveWithoutConfirmation: args2.blockDestructiveWithoutConfirmation,
-      onInvoke: args2.onInvoke
+      onInvoke: args2.onInvoke,
+      // Ownership is captured here (launch time) from the host-injected turn
+      // context, never re-derived when the task later reaches a terminal state.
+      owner: readProcessOwner(args2.call.runtimeContext)
     }
   );
 }
@@ -18830,7 +18975,16 @@ async function launchProcessTool(args2) {
   }
   const pgid = detached ? pid : pid;
   const registry2 = getProcessRegistry();
-  const envelope = registry2.add({ pid, pgid, command, label, persist });
+  const envelope = registry2.add({
+    pid,
+    pgid,
+    command,
+    label,
+    persist,
+    // Launch-time ownership: the dialog/turn that asked for this background
+    // task. Terminal-time resume reads this record, never "current dialog".
+    owner: readProcessOwner(args2.call.runtimeContext)
+  });
   const cleanupChildOnHostSignal = (signal) => {
     try {
       if (detached) {
@@ -18870,7 +19024,7 @@ async function launchProcessTool(args2) {
   };
 }
 async function listProcessesTool(args2) {
-  const list = getProcessRegistry().list();
+  const list = getProcessRegistry().list().map(toProcessTaskView);
   return {
     content: JSON.stringify(list),
     metadata: {
@@ -19227,7 +19381,7 @@ function buildLoadSkillExecutor(args2) {
     const { resolveSkillByName } = await import("./skillDiscovery-CYUCJMAG.js");
     const resolved = resolveSkillByName(args2.cwd, name);
     if (!resolved) {
-      const { resolveCodingBuiltinSlug, buildCodingSkillContentBySlug } = await import("./codingSkills-E6KSDNSJ.js");
+      const { resolveCodingBuiltinSlug, buildCodingSkillContentBySlug } = await import("./codingSkills-7S6523WH.js");
       const builtinSlug = resolveCodingBuiltinSlug(name);
       if (builtinSlug) {
         const body = buildCodingSkillContentBySlug(builtinSlug);
@@ -20006,6 +20160,326 @@ async function fetchAntigravityCloudCodeCompletion(args2) {
   return normalized;
 }
 
+// packages/agent-runtime/devin/devinProvider.ts
+import { randomBytes, randomUUID as randomUUID2 } from "node:crypto";
+var CLIENT_NAME = "chisel";
+var CLIENT_VERSION = "2026.8.18";
+function writeVarint(fieldNum, value) {
+  const tag = fieldNum << 3 | 0;
+  const bytes = [];
+  let t = tag;
+  while (t >= 128) {
+    bytes.push(t & 127 | 128);
+    t >>>= 7;
+  }
+  bytes.push(t);
+  let v = value;
+  while (v >= 128) {
+    bytes.push(v & 127 | 128);
+    v >>>= 7;
+  }
+  bytes.push(v);
+  return Buffer.from(bytes);
+}
+function writeLengthDelimited(fieldNum, content) {
+  const tag = fieldNum << 3 | 2;
+  const tagBytes = [];
+  let t = tag;
+  while (t >= 128) {
+    tagBytes.push(t & 127 | 128);
+    t >>>= 7;
+  }
+  tagBytes.push(t);
+  const lenBytes = [];
+  let len = content.length;
+  while (len >= 128) {
+    lenBytes.push(len & 127 | 128);
+    len >>>= 7;
+  }
+  lenBytes.push(len);
+  return Buffer.concat([Buffer.from(tagBytes), Buffer.from(lenBytes), content]);
+}
+function writeStringField(fieldNum, str) {
+  return writeLengthDelimited(fieldNum, Buffer.from(str, "utf8"));
+}
+function writeMessageField(fieldNum, message) {
+  return writeLengthDelimited(fieldNum, message);
+}
+function generateFingerprint() {
+  return randomBytes(366).toString("hex");
+}
+function encodeDevinClientMetadata(token) {
+  return Buffer.concat([
+    writeStringField(1, CLIENT_NAME),
+    writeStringField(2, CLIENT_VERSION),
+    writeStringField(3, token),
+    writeStringField(4, "en"),
+    writeStringField(5, process.platform === "win32" ? "windows" : "linux"),
+    writeStringField(7, CLIENT_VERSION),
+    writeStringField(12, CLIENT_NAME),
+    writeStringField(31, generateFingerprint())
+  ]);
+}
+function encodeDevinChatMessage(msg) {
+  const source = msg.role === "assistant" ? 2 : 1;
+  return Buffer.concat([
+    writeStringField(1, randomUUID2()),
+    writeVarint(2, source),
+    writeStringField(3, msg.text)
+  ]);
+}
+function writeFixed64Field(fieldNum, val) {
+  const b = Buffer.alloc(8);
+  b.writeDoubleLE(val, 0);
+  const tag = fieldNum << 3 | 1;
+  const tagBytes = [];
+  let t = tag;
+  while (t >= 128) {
+    tagBytes.push(t & 127 | 128);
+    t >>>= 7;
+  }
+  tagBytes.push(t);
+  return Buffer.concat([Buffer.from(tagBytes), b]);
+}
+function buildCompletionConfig(params) {
+  const maxTokens = params?.maxTokens ?? 4096;
+  const temp = params?.temperature ?? 0.4;
+  const topP = params?.topP ?? 0.95;
+  return Buffer.concat([
+    writeVarint(1, 1),
+    writeVarint(2, maxTokens),
+    writeVarint(3, 128e3),
+    writeFixed64Field(5, temp),
+    writeVarint(7, 40),
+    writeFixed64Field(8, topP)
+  ]);
+}
+function buildGetChatMessageRequest(params) {
+  const { token, messages, model } = params;
+  const metadata = encodeDevinClientMetadata(token);
+  let systemPrompt = "";
+  const filteredMessages = [];
+  for (const m of messages) {
+    const text = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.filter((p) => p?.type === "text").map((p) => p.text).join("\n") : "";
+    if (m.role === "system") {
+      systemPrompt = systemPrompt ? `${systemPrompt}
+
+${text}` : text;
+    } else if (m.role === "user" || m.role === "assistant") {
+      filteredMessages.push({ role: m.role, text });
+    }
+  }
+  const coalesced = [];
+  for (const item of filteredMessages) {
+    const last = coalesced[coalesced.length - 1];
+    if (last && last.role === item.role) {
+      last.text = `${last.text}
+
+${item.text}`;
+    } else {
+      coalesced.push({ ...item });
+    }
+  }
+  const chatMessageBuffers = coalesced.map((m) => encodeDevinChatMessage(m));
+  const completionConfig = buildCompletionConfig();
+  const modelConfig = Buffer.concat([
+    writeStringField(1, randomUUID2()),
+    writeVarint(2, 1),
+    writeVarint(3, 4)
+  ]);
+  return Buffer.concat([
+    writeMessageField(1, metadata),
+    writeStringField(2, systemPrompt),
+    ...chatMessageBuffers.map((b) => writeMessageField(3, b)),
+    writeVarint(7, 5),
+    writeMessageField(8, completionConfig),
+    writeMessageField(15, modelConfig),
+    writeStringField(16, randomUUID2()),
+    writeVarint(20, 1),
+    writeStringField(21, model)
+  ]);
+}
+function buildDevinConnectFrame(payload, flags = 0) {
+  const header = Buffer.alloc(5);
+  header[0] = flags & 255;
+  header.writeUInt32BE(payload.length, 1);
+  return Buffer.concat([header, payload]);
+}
+function parseDevinConnectFrames(buffer3) {
+  const frames = [];
+  let offset = 0;
+  while (offset + 5 <= buffer3.length) {
+    const flags = buffer3[offset];
+    const length = buffer3.readUInt32BE(offset + 1);
+    if (offset + 5 + length > buffer3.length) {
+      break;
+    }
+    const payload = buffer3.subarray(offset + 5, offset + 5 + length);
+    frames.push({ flags, payload });
+    offset += 5 + length;
+  }
+  return {
+    frames,
+    remainder: buffer3.subarray(offset)
+  };
+}
+function parseDevinConnectTrailer(payload) {
+  const text = payload.toString("utf8").trim();
+  if (!text || text === "{}") return null;
+  try {
+    const parsed = JSON.parse(text);
+    if (!parsed.error) {
+      return new Error(`Devin Connect invalid terminal trailer: ${text}`);
+    }
+    const code = typeof parsed.error.code === "string" ? parsed.error.code : "unknown";
+    const message = typeof parsed.error.message === "string" ? parsed.error.message : "Unknown error";
+    return new Error(`Devin Connect upstream error ${code}: ${message}`);
+  } catch {
+    return new Error(`Devin Connect invalid terminal trailer: ${text}`);
+  }
+}
+function decodeDevinResponsePayload(payload) {
+  let offset = 0;
+  let content = "";
+  let reasoning = "";
+  let finishReason = null;
+  const events = [];
+  while (offset < payload.length) {
+    let tag = 0;
+    let shift = 0;
+    while (offset < payload.length) {
+      const b = payload[offset++];
+      tag |= (b & 127) << shift;
+      if (!(b & 128)) break;
+      shift += 7;
+    }
+    const fieldNum = tag >>> 3;
+    const wireType = tag & 7;
+    if (wireType === 0) {
+      let val = 0;
+      let s = 0;
+      while (offset < payload.length) {
+        const b = payload[offset++];
+        val |= (b & 127) << s;
+        if (!(b & 128)) break;
+        s += 7;
+      }
+      if (fieldNum === 5) {
+        finishReason = val === 2 ? "stop" : "length";
+      }
+    } else if (wireType === 2) {
+      let len = 0;
+      let s = 0;
+      while (offset < payload.length) {
+        const b = payload[offset++];
+        len |= (b & 127) << s;
+        if (!(b & 128)) break;
+        s += 7;
+      }
+      const valBytes = payload.subarray(offset, offset + len);
+      offset += len;
+      if (fieldNum === 3) {
+        const text = valBytes.toString("utf8");
+        content += text;
+        events.push({ type: "content", text });
+      } else if (fieldNum === 9) {
+        const text = valBytes.toString("utf8");
+        reasoning += text;
+        events.push({ type: "reasoning", text });
+      }
+    } else {
+      break;
+    }
+  }
+  return { content, reasoning, finishReason, events };
+}
+function createDevinProvider(options) {
+  const { token, model = "swe-2", fetchImpl = fetch } = options;
+  return {
+    model,
+    async complete(messages, opts) {
+      const selectedModel = model;
+      const requestPayload = buildGetChatMessageRequest({
+        token,
+        messages,
+        model: selectedModel
+      });
+      const frame = buildDevinConnectFrame(requestPayload);
+      const response = await fetchImpl(DEVIN_CONNECT_URL, {
+        method: "POST",
+        headers: {
+          "authorization": `Basic ${token}-${token}`,
+          "content-type": "application/connect+proto",
+          "connect-protocol-version": "1"
+        },
+        body: new Uint8Array(frame),
+        signal: opts?.signal
+      });
+      if (!response.ok) {
+        const errText = await response.text().catch(() => "");
+        throw new Error(
+          `Devin Connect upstream returned error ${response.status}: ${errText}`
+        );
+      }
+      if (!response.body) {
+        throw new Error("Devin Connect response body is null");
+      }
+      let text = "";
+      let reasoning = "";
+      let buffer3 = Buffer.alloc(0);
+      let sawTrailer = false;
+      const reader = response.body.getReader();
+      try {
+        while (true) {
+          const { done: done4, value } = await reader.read();
+          if (done4) break;
+          buffer3 = Buffer.concat([buffer3, Buffer.from(value)]);
+          const { frames, remainder } = parseDevinConnectFrames(buffer3);
+          buffer3 = Buffer.from(remainder);
+          for (const f of frames) {
+            if (sawTrailer) {
+              throw new Error("Devin Connect received a frame after the terminal trailer");
+            }
+            if (f.flags & 2) {
+              sawTrailer = true;
+              const trailerError = parseDevinConnectTrailer(f.payload);
+              if (trailerError) throw trailerError;
+              continue;
+            }
+            const delta = decodeDevinResponsePayload(f.payload);
+            text += delta.content;
+            reasoning += delta.reasoning;
+            for (const event of delta.events) {
+              if (event.type === "reasoning") {
+                opts?.onReasoningDelta?.(event.text);
+              } else {
+                opts?.onTextDelta?.(event.text);
+              }
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      if (buffer3.length > 0) {
+        throw new Error("Devin Connect upstream ended with an incomplete frame");
+      }
+      if (!sawTrailer) {
+        throw new Error("Devin Connect upstream ended before the terminal trailer");
+      }
+      if (!text && !reasoning) {
+        throw new Error("Devin Connect upstream completed without content");
+      }
+      return {
+        content: text,
+        model: selectedModel,
+        provider: "devin",
+        reasoning_content: reasoning || void 0
+      };
+    }
+  };
+}
+
 export {
   Option_exports,
   Duration_exports,
@@ -20015,6 +20489,7 @@ export {
   readActionGate,
   evaluateFileWritePolicy,
   summarizeToolArguments,
+  formatToolOverflowMarker,
   LOCAL_AGENT_CONFIG_MISSING_CODE,
   LOCAL_TURN_ABORTED_CODE,
   runLocalAgentTurn,
@@ -20057,5 +20532,6 @@ export {
   shouldUseGeminiNativeToolRoute,
   buildGeminiGenerateContentRequest,
   resolveAntigravityFinishReason,
-  fetchAntigravityCloudCodeCompletion
+  fetchAntigravityCloudCodeCompletion,
+  createDevinProvider
 };