nolo-cli 0.76.0-alpha.1 → 0.76.0

package/{chunk-ZY4K4CZR.js → chunk-VW3YGKWR.js}

@@ -8,7 +8,10 @@ import {
   readSseFrames,
   streamSseDataValues,
   throwIfChatCompletionStreamFailed
-} from "./chunk-QC5LGHYP.js";
+} from "./chunk-EXWOCYCR.js";
+import {
+  DEVIN_CONNECT_URL
+} from "./chunk-FMODTASJ.js";
 import {
   clipToolText,
   hasImageInRuntimeMessages,
@@ -16,7 +19,7 @@ import {
   resolveHistoricalToolContentCap,
   resolveToolOutputProfile,
   stripImagePartsFromMessages
-} from "./chunk-KIS76A2P.js";
+} from "./chunk-WSOMSDQB.js";
 import {
   downgradeUnparsableToolCalls,
   hasParsableObjectArguments,
@@ -40,7 +43,7 @@ import {
   requiresBareImageUrl,
   resolveToolGuidedSections,
   toBareImageUrlMessages
-} from "./chunk-ZLPA7K55.js";
+} from "./chunk-Q4KVAB6L.js";
 import {
   convertMessagesToResponsesInput,
   extractReasoningFromResponseOutput,
@@ -51,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,
@@ -73,7 +67,16 @@ import {
   parseNoloWorkspaceToolArguments,
   readTextStreamUpToChars,
   resolveNoloDialogInput
-} from "./chunk-V3ZKNK5D.js";
+} from "./chunk-OKCTLCKS.js";
+import {
+  getAntigravityUserAgent,
+  readAntigravityProjectId,
+  resolveAntigravityCloudCodeBaseUrl
+} from "./chunk-DS3SQTDT.js";
+import {
+  buildProviderAuthHeaders,
+  buildProviderExecutionPlan
+} from "./chunk-X77EN2BJ.js";
 import {
   buildDialogFallbackTitleFromUserInput
 } from "./chunk-2MBTWINN.js";
@@ -87,7 +90,7 @@ import {
   resolveEmptyAssistantFallbackMessage,
   resolveEmptyAssistantOutcome,
   resolveTruncatedReasoningTailLog
-} from "./chunk-DSRXPQWA.js";
+} from "./chunk-OCL2YCAU.js";
 import {
   COMPACTION_SUMMARY_SCHEMA_VERSION,
   COMPACTION_SUMMARY_SYSTEM_PROMPT,
@@ -106,7 +109,7 @@ import {
   resolveCompressionTriggerRatio,
   truncateToolOutputForContext,
   withProviderCallTimingFields
-} from "./chunk-E36HZARC.js";
+} from "./chunk-KT6LENVP.js";
 import {
   estimateTokenCount
 } from "./chunk-PSCNXBYA.js";
@@ -130,27 +133,25 @@ import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
 import {
+  asTrimmedNonEmptyStringArray,
   dialogMessageKey,
   dialogMessageRange
-} from "./chunk-NHRQCXIQ.js";
+} from "./chunk-VMFTFOWF.js";
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";
-import {
-  asTrimmedNonEmptyStringArray
-} from "./chunk-I42VC5KR.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
 import {
   asOptionalPositiveFiniteNumber
 } from "./chunk-U6VC4MU4.js";
-import {
-  isRecord
-} from "./chunk-KUG52IAP.js";
 import {
   normalizeServerOrigin
 } from "./chunk-CF7PE763.js";
@@ -15568,13 +15569,13 @@ var DEFAULT_LOCAL_TOOLS = /* @__PURE__ */ new Set([
   "execShell",
   "launchProcess",
   "listProcesses",
-  // ProcessTask follow-up tools (Phase 1). Same tier as listProcesses: they
-  // observe/stop tasks the agent itself already spawned, so their blast radius
-  // is strictly narrower than launchProcess (which is default-enabled).
+  // ProcessTask follow-up tools. Same tier as listProcesses: they observe/stop
+  // tasks the agent itself already spawned, so their blast radius is strictly
+  // narrower than launchProcess (which is default-enabled). Model-facing
+  // follow-ups are taskWait/taskStop only — lifecycle history (taskLogs) stays
+  // runtime-internal.
   "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
@@ -16210,6 +16211,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;
@@ -16265,7 +16284,7 @@ var ProcessRegistry = class {
       startedAt: Date.now(),
       status: "running",
       persist: proc.persist ?? false,
-      promoted: false,
+      promoted: proc.promoted ?? false,
       transient: proc.transient ?? false,
       owner: proc.owner ?? null
     };
@@ -16362,7 +16381,8 @@ var ProcessRegistry = class {
         pid,
         label: item.label,
         command: item.command,
-        status: "stopped"
+        status: "stopped",
+        promoted: item.promoted
       });
       return true;
     }
@@ -16391,15 +16411,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,
@@ -16413,7 +16435,9 @@ var ProcessRegistry = class {
         label: item.label,
         command: item.command,
         status: item.status,
-        exitCode
+        exitCode,
+        promoted: item.promoted,
+        ...item.resultCapsule ? { resultCapsule: item.resultCapsule } : {}
       });
     }
   }
@@ -16476,6 +16500,62 @@ function readProcessOwner(runtimeContext) {
 // 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;
@@ -16855,6 +16935,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";
@@ -16913,8 +17002,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 {
@@ -17007,12 +17096,36 @@ async function runWorkspaceCommand(args2) {
       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})`;
@@ -17036,10 +17149,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);
@@ -17456,9 +17572,7 @@ var WORKSPACE_TOOL_NAMES = [
   "launchProcess",
   "listProcesses",
   "taskWait",
-  "taskLogs",
   "taskStop",
-  "tasks",
   "openDesktopPreview"
 ];
 var SHELL_TOOL_NAMES = [
@@ -17466,9 +17580,7 @@ var SHELL_TOOL_NAMES = [
   "launchProcess",
   "listProcesses",
   "taskWait",
-  "taskLogs",
-  "taskStop",
-  "tasks"
+  "taskStop"
 ];
 var WORKSPACE_TOOL_NAME_SET = new Set(WORKSPACE_TOOL_NAMES);
 function buildWorkspacePathProperty() {
@@ -17717,7 +17829,7 @@ function buildTaskWaitTool() {
     type: "function",
     function: {
       name: "taskWait",
-      description: 'Block until a background task (from launchProcess, or an execShell command that detached) reaches a terminal state, or until timeoutMs elapses. Returns {outcome, status, exitCode?, cursor, events}: outcome "terminal" with status exited|failed|stopped when it finished, outcome "timeout" with status "running" when it outlived the whole budget, outcome "not-found" for an unknown taskId, or outcome "evicted" when the event trail aged out (never wait again in that case). One call already waits the maximum budget and returns the moment the task ends, so a "timeout" means the task is genuinely longer than that \u2014 go do other work and come back, rather than re-waiting in a loop (each re-wait costs a full model round-trip). For a cheap liveness peek use taskLogs (non-blocking) or pass a small timeoutMs. `cursor` is the highest event seq covered by this response \u2014 pass it to taskLogs to read only newer events.',
+      description: 'Block until a background task (from launchProcess, or an execShell command that detached) reaches a terminal state, or until timeoutMs elapses. Returns {outcome, status, exitCode?, cursor, events}: outcome "terminal" with status exited|failed|stopped when it finished, outcome "timeout" with status "running" when it outlived the whole budget, outcome "not-found" for an unknown taskId, or outcome "evicted" when the event trail aged out (never wait again in that case). One call already waits the maximum budget and returns the moment the task ends, so a "timeout" means the task is genuinely longer than that \u2014 go do other work and come back, rather than re-waiting in a loop (each re-wait costs a full model round-trip). Pass a small timeoutMs for a cheap liveness peek instead of the full result. `cursor` is the highest event seq covered by this response.',
       parameters: {
         type: "object",
         properties: {
@@ -17736,30 +17848,6 @@ function buildTaskWaitTool() {
     }
   };
 }
-function buildTaskLogsTool() {
-  return {
-    type: "function",
-    function: {
-      name: "taskLogs",
-      description: "Read a background task's lifecycle events incrementally. Returns {outcome, status, cursor, events} where events are the started|promoted|exited|killed records with seq greater than the cursor you passed, and the returned `cursor` is the new high-water mark to pass next time (omit cursor to read from the beginning; repeating the same cursor is idempotent). Oversized output is spilled to a file and reported as `logRef`, which you can open with readFile.",
-      parameters: {
-        type: "object",
-        properties: {
-          taskId: {
-            type: "string",
-            minLength: 1,
-            description: "Task id returned by launchProcess or by a detached execShell result."
-          },
-          cursor: {
-            type: "number",
-            description: "Last event seq you already consumed; only events with a higher seq are returned. Defaults to 0 (all retained events)."
-          }
-        },
-        required: ["taskId"]
-      }
-    }
-  };
-}
 function buildTaskStopTool() {
   return {
     type: "function",
@@ -17780,19 +17868,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();
@@ -17812,9 +17887,7 @@ function buildWorkspaceToolDefinition(toolName) {
   if (toolName === "openDesktopPreview") return buildOpenDesktopPreviewTool();
   if (toolName === "listProcesses") return buildListProcessesTool();
   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) {
@@ -18923,7 +18996,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: {
@@ -19280,15 +19353,23 @@ 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 builtinSlug = resolveCodingBuiltinSlug(name);
-      if (builtinSlug) {
-        const body = buildCodingSkillContentBySlug(builtinSlug);
+      const { resolveBuiltinSkillByName } = await import("./builtinSkillRegistry-5SYVTS6Z.js");
+      const builtin = resolveBuiltinSkillByName(name);
+      if (builtin) {
         return {
           content: `Skill "${name}" loaded inline. Follow its instructions.
 
-${body}`,
-          metadata: { loadSkill: true, resolved: true, name, requestedName: name, builtin: true }
+${builtin.content}`,
+          // toolNames 进 metadata：回退面已扩到全注册表，其中授工具型 skill
+          // （search-* 等）的工具在本宿主未必接线，宿主可据此降级提示。
+          metadata: {
+            loadSkill: true,
+            resolved: true,
+            name,
+            requestedName: name,
+            builtin: true,
+            ...builtin.config.toolNames?.length ? { toolNames: [...builtin.config.toolNames] } : {}
+          }
         };
       }
       return {
@@ -20059,6 +20140,437 @@ 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 : msg.role === "tool" ? 4 : 1;
+  return Buffer.concat([
+    writeStringField(1, randomUUID2()),
+    writeVarint(2, source),
+    writeStringField(3, msg.text),
+    ...(msg.toolCalls ?? []).map(
+      (toolCall) => writeMessageField(
+        6,
+        Buffer.concat([
+          writeStringField(1, toolCall.id),
+          writeStringField(2, toolCall.function.name),
+          writeStringField(3, toolCall.function.arguments)
+        ])
+      )
+    ),
+    ...msg.toolCallId ? [writeStringField(7, msg.toolCallId)] : []
+  ]);
+}
+function encodeDevinToolDefinition(tool) {
+  const fn3 = tool.function ?? {};
+  const name = typeof fn3.name === "string" ? fn3.name : "";
+  const description = typeof fn3.description === "string" ? fn3.description : "";
+  const parameters = fn3.parameters ?? {};
+  return Buffer.concat([
+    writeStringField(1, name),
+    writeStringField(2, description.length > 6998 ? `${description.slice(0, 6995)}...` : description),
+    writeStringField(3, JSON.stringify(parameters))
+  ]);
+}
+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 ?? 128e3;
+  const maxNewlines = params?.maxNewlines ?? 400;
+  const temp = params?.temperature ?? 1;
+  const topP = params?.topP ?? 0.95;
+  return Buffer.concat([
+    writeVarint(1, 1),
+    writeVarint(2, maxTokens),
+    writeVarint(3, maxNewlines),
+    writeFixed64Field(5, temp),
+    writeVarint(7, 40),
+    writeFixed64Field(8, topP)
+  ]);
+}
+function buildGetChatMessageRequest(params) {
+  const { token, messages, model, tools = [], temperature } = 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" || m.role === "tool") {
+      filteredMessages.push({
+        role: m.role,
+        text,
+        ...m.tool_call_id ? { toolCallId: m.tool_call_id } : {},
+        ...m.tool_calls?.length ? { toolCalls: m.tool_calls } : {}
+      });
+    }
+  }
+  const coalesced = [];
+  for (const item of filteredMessages) {
+    const last = coalesced[coalesced.length - 1];
+    if (last && last.role === item.role && item.role !== "tool" && !last.toolCalls?.length && !item.toolCalls?.length) {
+      last.text = `${last.text}
+
+${item.text}`;
+    } else {
+      coalesced.push({ ...item });
+    }
+  }
+  const chatMessageBuffers = coalesced.map((m) => encodeDevinChatMessage(m));
+  const completionConfig = buildCompletionConfig({ temperature });
+  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),
+    ...tools.map((tool) => writeMessageField(10, encodeDevinToolDefinition(tool))),
+    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 === 10 ? "tool_calls" : val === 1 || val === 3 ? "length" : "stop";
+      }
+    } 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 if (fieldNum === 6) {
+        let nestedOffset = 0;
+        let id;
+        let name;
+        let argsDelta;
+        while (nestedOffset < valBytes.length) {
+          let nestedTag = 0;
+          let nestedShift = 0;
+          while (nestedOffset < valBytes.length) {
+            const b = valBytes[nestedOffset++];
+            nestedTag |= (b & 127) << nestedShift;
+            if (!(b & 128)) break;
+            nestedShift += 7;
+          }
+          const nestedField = nestedTag >>> 3;
+          const nestedWire = nestedTag & 7;
+          if (nestedWire !== 2) break;
+          let nestedLength = 0;
+          let lengthShift = 0;
+          while (nestedOffset < valBytes.length) {
+            const b = valBytes[nestedOffset++];
+            nestedLength |= (b & 127) << lengthShift;
+            if (!(b & 128)) break;
+            lengthShift += 7;
+          }
+          const nestedValue = valBytes.subarray(nestedOffset, nestedOffset + nestedLength);
+          nestedOffset += nestedLength;
+          const text = nestedValue.toString("utf8");
+          if (nestedField === 1) id = text;
+          else if (nestedField === 2) name = text;
+          else if (nestedField === 3) argsDelta = (argsDelta ?? "") + text;
+        }
+        if (id !== void 0 && name !== void 0) {
+          events.push({ type: "tool-call-start", id, name });
+        }
+        if (argsDelta !== void 0) {
+          events.push({ type: "tool-call-args", argsDelta, ...id ? { id } : {} });
+        }
+      }
+    } else {
+      break;
+    }
+  }
+  return { content, reasoning, finishReason, events };
+}
+function createDevinProvider(options) {
+  const { token, model = "swe-2", fetchImpl = fetch, tools = [], temperature } = options;
+  return {
+    model,
+    async complete(messages, opts) {
+      const selectedModel = model;
+      const requestPayload = buildGetChatMessageRequest({
+        token,
+        messages,
+        model: selectedModel,
+        tools,
+        temperature
+      });
+      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 finishReason = null;
+      const toolCallOrder = [];
+      const toolCallById = /* @__PURE__ */ new Map();
+      let currentToolCallId = null;
+      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;
+            if (delta.finishReason) finishReason = delta.finishReason;
+            for (const event of delta.events) {
+              if (event.type === "reasoning") {
+                opts?.onReasoningDelta?.(event.text);
+              } else if (event.type === "content") {
+                opts?.onTextDelta?.(event.text);
+              } else if (event.type === "tool-call-start") {
+                const existing = toolCallById.get(event.id);
+                if (existing) {
+                  existing.name = event.name;
+                } else {
+                  toolCallOrder.push(event.id);
+                  toolCallById.set(event.id, {
+                    id: event.id,
+                    name: event.name,
+                    argumentsText: ""
+                  });
+                }
+                currentToolCallId = event.id;
+              } else {
+                const targetId = event.id ?? currentToolCallId;
+                const target = targetId ? toolCallById.get(targetId) : void 0;
+                if (target) target.argumentsText += event.argsDelta;
+              }
+            }
+          }
+        }
+      } 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");
+      }
+      const toolCalls = toolCallOrder.map((id) => {
+        const call = toolCallById.get(id);
+        return {
+          id: call.id,
+          type: "function",
+          function: {
+            name: call.name,
+            arguments: call.argumentsText || "{}"
+          }
+        };
+      });
+      if (!text && !reasoning && toolCalls.length === 0) {
+        throw new Error("Devin Connect upstream completed without content or tool calls");
+      }
+      return {
+        content: text,
+        model: selectedModel,
+        provider: "devin",
+        ...reasoning ? { reasoning_content: reasoning } : {},
+        ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {},
+        // The upstream finish event wins whenever it is present. A tool call
+        // cut off by the length limit has to stay "length" instead of being
+        // relabelled "tool_calls", so probes/telemetry and any downstream
+        // consumer of the final finish_reason no longer see a truncated turn
+        // mislabelled as a normal one. localLoop keeps its own truncation
+        // gates and excludes tool-bearing turns from them.
+        finish_reason: finishReason ?? (toolCalls.length > 0 ? "tool_calls" : "stop"),
+        stream_complete: true
+      };
+    }
+  };
+}
+
 export {
   Option_exports,
   Duration_exports,
@@ -20068,6 +20580,7 @@ export {
   readActionGate,
   evaluateFileWritePolicy,
   summarizeToolArguments,
+  formatToolOverflowMarker,
   LOCAL_AGENT_CONFIG_MISSING_CODE,
   LOCAL_TURN_ABORTED_CODE,
   runLocalAgentTurn,
@@ -20110,5 +20623,6 @@ export {
   shouldUseGeminiNativeToolRoute,
   buildGeminiGenerateContentRequest,
   resolveAntigravityFinishReason,
-  fetchAntigravityCloudCodeCompletion
+  fetchAntigravityCloudCodeCompletion,
+  createDevinProvider
 };