lody 0.103.0 → 0.104.0

package/dist/devin-acp.js

@@ -0,0 +1,1152 @@
+import { createInterface } from "node:readline";
+import { randomUUID } from "node:crypto";
+import "node:fs";
+import { c as isLodySubagentOutput, S as SessionUsageAccumulator, e as supportsLodySubagentEvents, d as LODY_SUBAGENT_EVENT_METHOD, L as LODY_EXTENSION_METHODS } from "./chunks/subagent-events-BJ9JwZva.js";
+import { spawn } from "node:child_process";
+const FIELDS = [
+  "sidekickToolCallMeta",
+  "sidekickToolCallIdPrefix",
+  "subagentContextMeta",
+  "subagentStartedMeta",
+  "subagentCompletedMeta",
+  "subagentSupportClientCapability",
+  "rootAgentId",
+  "sidekickAgentId",
+  "toolNameMeta",
+  "inferenceToolNameMeta",
+  "compactionNotificationMethod",
+  "compactionSessionIdField",
+  "compactionStatusField",
+  "compactionSummaryField",
+  "compactionStartedStatus",
+  "compactionCompletedStatus",
+  "compactionFailedStatus",
+  "compactionManualCommand",
+  "elicitationAllowOtherMeta",
+  "usageInputTokensMeta",
+  "usageOutputTokensMeta",
+  "usageCachedReadTokensMeta",
+  "usageCachedWriteTokensMeta",
+  "usageTotalCreditCostMeta",
+  "usageTotalAcuCostMeta",
+  "usageResponseDimensionsMeta"
+];
+function loadPrivateWireContract() {
+  const raw = JSON.parse('{\n  "officialRuntime": {\n    "package": "devin",\n    "version": "3000.11.3",\n    "minimumSupportedVersion": "3000.11.1"\n  },\n  "privateWireContract": {\n    "sidekickToolCallMeta": "cognition.ai/sidekick",\n    "sidekickToolCallIdPrefix": "sk::",\n    "subagentContextMeta": "cognition.ai/subagent_context",\n    "subagentStartedMeta": "cognition.ai/subagent_started",\n    "subagentCompletedMeta": "cognition.ai/subagent_completed",\n    "subagentSupportClientCapability": "cognition.ai/subagentSupport",\n    "rootAgentId": "root",\n    "sidekickAgentId": "sidekick",\n    "toolNameMeta": "cognition.ai/toolName",\n    "inferenceToolNameMeta": "cognition.ai/inferenceToolName",\n    "compactionNotificationMethod": "_cognition.ai/compaction",\n    "compactionSessionIdField": "sessionId",\n    "compactionStatusField": "status",\n    "compactionSummaryField": "summary",\n    "compactionStartedStatus": "started",\n    "compactionCompletedStatus": "completed",\n    "compactionFailedStatus": "failed",\n    "compactionManualCommand": "/compact",\n    "elicitationAllowOtherMeta": "cognition.ai/allowOther",\n    "usageInputTokensMeta": "cognition.ai/inputTokens",\n    "usageOutputTokensMeta": "cognition.ai/outputTokens",\n    "usageCachedReadTokensMeta": "cognition.ai/cachedReadTokens",\n    "usageCachedWriteTokensMeta": "cognition.ai/cachedWriteTokens",\n    "usageTotalCreditCostMeta": "cognition.ai/totalCreditCost",\n    "usageTotalAcuCostMeta": "cognition.ai/totalAcuCost",\n    "usageResponseDimensionsMeta": "cognition.ai/responseDimensions"\n  }\n}\n');
+  const section = raw["privateWireContract"];
+  if (typeof section !== "object" || section === null || Array.isArray(section)) {
+    throw new Error("runtime-manifest.json: privateWireContract must be an object");
+  }
+  const contract = {};
+  for (const field of FIELDS) {
+    const value = section[field];
+    if (typeof value !== "string" || !value) {
+      throw new Error(`runtime-manifest.json: privateWireContract.${field} must be a non-empty string`);
+    }
+    contract[field] = value;
+  }
+  return contract;
+}
+const privateWireContract = loadPrivateWireContract();
+const ALLOW_OTHER_META = privateWireContract.elicitationAllowOtherMeta;
+function isRecord$3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clientSupportsLodyElicitation(capabilities) {
+  if (!isRecord$3(capabilities))
+    return false;
+  const meta = capabilities["_meta"];
+  if (!isRecord$3(meta))
+    return false;
+  const lody = meta["lody"];
+  if (!isRecord$3(lody))
+    return false;
+  const elicitation = lody["elicitation"];
+  return isRecord$3(elicitation) && elicitation["version"] === 1;
+}
+function extractOptions(entries) {
+  if (!Array.isArray(entries))
+    return [];
+  const options = [];
+  for (const entry of entries) {
+    if (typeof entry === "string") {
+      options.push({ label: entry });
+      continue;
+    }
+    if (!isRecord$3(entry))
+      continue;
+    const value = entry["const"];
+    const title = entry["title"];
+    const description = entry["description"];
+    const label = typeof value === "string" ? value : typeof title === "string" ? title : void 0;
+    if (label === void 0)
+      continue;
+    const option = { label };
+    const detail = typeof value === "string" ? typeof title === "string" ? title : typeof description === "string" ? description : void 0 : typeof description === "string" ? description : void 0;
+    if (detail !== void 0)
+      option.description = detail;
+    options.push(option);
+  }
+  return options;
+}
+function questionShape(property) {
+  if (property["type"] === "array") {
+    const items = isRecord$3(property["items"]) ? property["items"] : {};
+    return {
+      multiSelect: true,
+      options: extractOptions(items["anyOf"] ?? items["oneOf"] ?? items["enum"])
+    };
+  }
+  return {
+    multiSelect: false,
+    options: extractOptions(property["oneOf"] ?? property["anyOf"] ?? property["enum"])
+  };
+}
+function hasOptions(property) {
+  if (property["type"] === "array") {
+    const items = isRecord$3(property["items"]) ? property["items"] : {};
+    return Array.isArray(items["anyOf"]) || Array.isArray(items["oneOf"]) || Array.isArray(items["enum"]);
+  }
+  return Array.isArray(property["oneOf"]) || Array.isArray(property["anyOf"]) || Array.isArray(property["enum"]);
+}
+function freeKey(base, properties) {
+  let key = `${base}__other`;
+  for (let i = 2; key in properties; i += 1)
+    key = `${base}__other_${i}`;
+  return key;
+}
+function rewriteElicitationParams(params) {
+  const meta = isRecord$3(params["_meta"]) ? params["_meta"] : void 0;
+  if (meta?.[ALLOW_OTHER_META] !== true)
+    return void 0;
+  const schema = isRecord$3(params["requestedSchema"]) ? params["requestedSchema"] : void 0;
+  const properties = schema && isRecord$3(schema["properties"]) ? schema["properties"] : void 0;
+  const questions = [];
+  const customFields = /* @__PURE__ */ new Map();
+  const rewrittenProperties = {};
+  if (properties) {
+    for (const [fieldId, raw] of Object.entries(properties)) {
+      rewrittenProperties[fieldId] = raw;
+      if (!isRecord$3(raw))
+        continue;
+      const { options, multiSelect } = questionShape(raw);
+      questions.push({
+        id: fieldId,
+        question: typeof raw["description"] === "string" ? raw["description"] : "",
+        header: typeof raw["title"] === "string" ? raw["title"] : "",
+        options,
+        multiSelect,
+        allowCustomAnswer: true
+      });
+      if (!hasOptions(raw))
+        continue;
+      const customKey = freeKey(fieldId, {
+        ...properties,
+        ...rewrittenProperties
+      });
+      rewrittenProperties[customKey] = {
+        type: "string",
+        title: "Other",
+        description: multiSelect ? "Type your own answer instead of choosing options above." : "Type your own answer instead of choosing an option above.",
+        _meta: {
+          lody: {
+            elicitation: {
+              version: 1,
+              customAnswerFor: fieldId,
+              secret: false
+            }
+          }
+        }
+      };
+      customFields.set(customKey, { target: fieldId, multiSelect });
+    }
+  }
+  const lody = isRecord$3(meta["lody"]) ? meta["lody"] : {};
+  const elicitation = {
+    ...isRecord$3(lody["elicitation"]) ? lody["elicitation"] : {},
+    version: 1,
+    questions
+  };
+  return {
+    params: {
+      ...params,
+      ...schema ? { requestedSchema: { ...schema, properties: rewrittenProperties } } : {},
+      _meta: { ...meta, lody: { ...lody, elicitation } }
+    },
+    customFields
+  };
+}
+function foldElicitationResponse(result, customFields) {
+  if (customFields.size === 0 || !isRecord$3(result))
+    return void 0;
+  if (result["action"] !== "accept" || !isRecord$3(result["content"]))
+    return void 0;
+  const content = result["content"];
+  let changed = false;
+  const folded = { ...content };
+  for (const [key, field] of customFields) {
+    if (!(key in folded))
+      continue;
+    const value = folded[key];
+    delete folded[key];
+    changed = true;
+    if (typeof value === "string" && value.trim()) {
+      folded[field.target] = field.multiSelect ? [value] : value;
+    } else if (Array.isArray(value) && value.length > 0) {
+      folded[field.target] = value;
+    }
+  }
+  if (!changed)
+    return void 0;
+  return { ...result, content: folded };
+}
+const CONTEXT_META = privateWireContract.subagentContextMeta;
+const SIDEKICK_META = privateWireContract.sidekickToolCallMeta;
+const STARTED_META = privateWireContract.subagentStartedMeta;
+const COMPLETED_META = privateWireContract.subagentCompletedMeta;
+const SIDEKICK_ID_PREFIX = privateWireContract.sidekickToolCallIdPrefix;
+const ROOT_ACTIVITY = /* @__PURE__ */ new Set([
+  "agent_message_chunk",
+  "agent_thought_chunk",
+  "tool_call",
+  "tool_call_update",
+  "plan"
+]);
+const TERMINAL_TOOL_STATUS = /* @__PURE__ */ new Set(["completed", "failed"]);
+const TOOL_DISPLAY_FIELDS = ["title", "kind", "rawInput", "locations"];
+const MAX_BUFFERED_CHILD_UPDATES = 64;
+function isRecord$2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function agentContext$1(update) {
+  const meta = update["_meta"];
+  if (!isRecord$2(meta))
+    return void 0;
+  const ctx = meta[CONTEXT_META];
+  if (!isRecord$2(ctx))
+    return void 0;
+  const id = ctx["parentAgentId"];
+  return typeof id === "string" ? id : void 0;
+}
+function rememberToolDisplay(run, toolCallId, update) {
+  const entry = run.toolDisplay.get(toolCallId) ?? {};
+  for (const field of TOOL_DISPLAY_FIELDS) {
+    if (update[field] !== void 0)
+      entry[field] = update[field];
+  }
+  run.toolDisplay.set(toolCallId, entry);
+}
+function usageProgress(update) {
+  const progress = {};
+  if (typeof update["used"] === "number")
+    progress.contextTokens = update["used"];
+  if (typeof update["size"] === "number")
+    progress.contextWindowTokens = update["size"];
+  return progress;
+}
+class DevinSubagentEvents {
+  sessionId;
+  runs = /* @__PURE__ */ new Map();
+  sidekickRun;
+  buffered = /* @__PURE__ */ new Map();
+  overflowed = /* @__PURE__ */ new Set();
+  /** toolCallIds owned by any closed sidekick run; late updates are dropped. */
+  closedSkToolIds = /* @__PURE__ */ new Set();
+  /** latest sidekick usage seen before a run exists. */
+  stashedProgress;
+  /** root activity arrived while sidekick tools were still in flight. */
+  rootResumed = false;
+  newId;
+  now;
+  constructor(sessionId, { newId, now } = {}) {
+    this.sessionId = sessionId;
+    this.newId = newId ?? (() => crypto.randomUUID());
+    this.now = now ?? (() => Math.floor(Date.now() / 1e3));
+  }
+  emit(run, payload) {
+    return {
+      kind: "event",
+      event: {
+        version: 1,
+        sessionId: this.sessionId,
+        runId: run.runId,
+        ...payload
+      }
+    };
+  }
+  createSubagentRun(agentId, started, ctx) {
+    let parentRunId = null;
+    if (ctx && ctx !== privateWireContract.rootAgentId) {
+      if (ctx === privateWireContract.sidekickAgentId) {
+        parentRunId = this.sidekickRun?.live ? this.sidekickRun.runId : null;
+      } else {
+        const parent = this.runs.get(ctx);
+        parentRunId = parent?.live ? parent.runId : null;
+      }
+    }
+    const description = typeof started["title"] === "string" ? started["title"] : typeof started["task"] === "string" ? started["task"] : void 0;
+    const snapshot = {
+      state: "running",
+      parentRunId,
+      ...typeof started["profile"] === "string" ? { name: started["profile"] } : {},
+      ...description !== void 0 ? { description } : {},
+      ...typeof started["model"] === "string" ? { modelId: started["model"] } : {},
+      startedAtEpochSeconds: this.now(),
+      support: {
+        stream: ["text", "thought", "tool", "plan"],
+        progress: true,
+        outputRead: "none",
+        cancel: false
+      }
+    };
+    const run = {
+      runId: this.newId(),
+      agentId,
+      live: true,
+      snapshot,
+      toolIds: /* @__PURE__ */ new Set(),
+      inFlight: /* @__PURE__ */ new Set(),
+      mirrors: /* @__PURE__ */ new Set(),
+      toolDisplay: /* @__PURE__ */ new Map()
+    };
+    this.runs.set(agentId, run);
+    return run;
+  }
+  /**
+   * Open a new sidekick run. Returned outputs go to the client in order:
+   * the snapshot first, then any stashed progress observed before the run.
+   */
+  openSidekickRun() {
+    const out = [];
+    const run = {
+      runId: this.newId(),
+      agentId: privateWireContract.sidekickAgentId,
+      live: true,
+      snapshot: {
+        state: "running",
+        parentRunId: null,
+        name: "Sidekick",
+        startedAtEpochSeconds: this.now(),
+        support: {
+          stream: ["tool"],
+          progress: true,
+          outputRead: "none",
+          cancel: false
+        }
+      },
+      toolIds: /* @__PURE__ */ new Set(),
+      inFlight: /* @__PURE__ */ new Set(),
+      mirrors: /* @__PURE__ */ new Set(),
+      toolDisplay: /* @__PURE__ */ new Map()
+    };
+    this.sidekickRun = run;
+    out.push(this.emit(run, { type: "snapshot", snapshot: run.snapshot }));
+    if (this.stashedProgress !== void 0) {
+      const progress = this.stashedProgress;
+      this.stashedProgress = void 0;
+      out.push(this.emit(run, { type: "progress", progress }));
+    }
+    return { run, out };
+  }
+  closeSidekickSnapshot(run, patch) {
+    run.live = false;
+    for (const id of run.toolIds)
+      this.closedSkToolIds.add(id);
+    this.rootResumed = false;
+    run.snapshot = {
+      ...run.snapshot,
+      endedAtEpochSeconds: this.now(),
+      ...patch
+    };
+    return this.emit(run, { type: "snapshot", snapshot: run.snapshot });
+  }
+  mirrorRootUpdate(run, update, toolCallId) {
+    return {
+      ...update,
+      toolCallId: mirrorToolCallId(run.runId, toolCallId),
+      _meta: {
+        ...isRecord$2(update["_meta"]) ? update["_meta"] : {},
+        lody: { subagentRunId: run.runId, subagentToolCallId: toolCallId }
+      }
+    };
+  }
+  /**
+   * Classify one runtime `session/update` for this session.
+   * Returns run events and root-bound updates in order; drops consumed rows.
+   */
+  handleSessionUpdate(update) {
+    const out = [];
+    const meta = isRecord$2(update["_meta"]) ? update["_meta"] : void 0;
+    const ctx = agentContext$1(update);
+    const sessionUpdate = update["sessionUpdate"];
+    const completedMeta = meta?.[COMPLETED_META];
+    const startedMeta = meta?.[STARTED_META];
+    if ((sessionUpdate === "tool_call" || sessionUpdate === "tool_call_update") && (completedMeta !== void 0 || startedMeta !== void 0)) {
+      if (completedMeta !== void 0) {
+        if (!isRecord$2(completedMeta) || typeof completedMeta["agentId"] !== "string") {
+          out.push({ kind: "root", update });
+          return out;
+        }
+        const run2 = this.runs.get(completedMeta["agentId"]);
+        if (run2?.live) {
+          const failed = completedMeta["success"] === false;
+          const patch = {
+            state: failed ? "failed" : "completed",
+            endedAtEpochSeconds: this.now(),
+            ...typeof completedMeta["summary"] === "string" ? { summary: completedMeta["summary"] } : {},
+            ...failed && typeof completedMeta["summary"] === "string" ? {
+              reason: {
+                code: "error",
+                message: completedMeta["summary"]
+              }
+            } : {}
+          };
+          run2.live = false;
+          run2.snapshot = { ...run2.snapshot, ...patch };
+          out.push(this.emit(run2, { type: "snapshot", snapshot: run2.snapshot }));
+        }
+        return out;
+      }
+      if (!isRecord$2(startedMeta) || typeof startedMeta["agentId"] !== "string") {
+        out.push({ kind: "root", update });
+        return out;
+      }
+      const agentId = startedMeta["agentId"];
+      const existing = this.runs.get(agentId);
+      if (existing?.live)
+        return out;
+      const run = this.createSubagentRun(agentId, startedMeta, ctx);
+      out.push(this.emit(run, { type: "snapshot", snapshot: run.snapshot }));
+      if (this.overflowed.delete(agentId)) {
+        run.snapshot = { ...run.snapshot, outputIncomplete: true };
+        out.push(this.emit(run, { type: "snapshot", snapshot: run.snapshot }));
+      }
+      const buffered = this.buffered.get(agentId);
+      if (buffered) {
+        this.buffered.delete(agentId);
+        for (const u of buffered)
+          out.push(...this.childUpdate(run, u));
+      }
+      return out;
+    }
+    if (typeof ctx === "string" && ctx !== privateWireContract.rootAgentId && ctx !== privateWireContract.sidekickAgentId) {
+      const run = this.runs.get(ctx);
+      if (run?.live) {
+        out.push(...this.childUpdate(run, update));
+      } else if (!run) {
+        const buf = this.buffered.get(ctx) ?? [];
+        if (buf.length >= MAX_BUFFERED_CHILD_UPDATES) {
+          this.overflowed.add(ctx);
+        } else {
+          buf.push(update);
+          this.buffered.set(ctx, buf);
+        }
+      }
+      return out;
+    }
+    const toolCallId = typeof update["toolCallId"] === "string" ? update["toolCallId"] : void 0;
+    const isSidekick = ctx === privateWireContract.sidekickAgentId || (sessionUpdate === "tool_call" || sessionUpdate === "tool_call_update") && (meta?.[SIDEKICK_META] === true || toolCallId !== void 0 && toolCallId.startsWith(SIDEKICK_ID_PREFIX));
+    if (isSidekick) {
+      if (toolCallId && this.closedSkToolIds.has(toolCallId)) {
+        return out;
+      }
+      if (sessionUpdate === "usage_update" && !this.sidekickRun?.live) {
+        this.stashedProgress = usageProgress(update);
+        return out;
+      }
+      let run = this.sidekickRun;
+      if (!run?.live) {
+        const opened = this.openSidekickRun();
+        run = opened.run;
+        out.push(...opened.out);
+      }
+      if (sessionUpdate === "usage_update") {
+        out.push(this.emit(run, { type: "progress", progress: usageProgress(update) }));
+        return out;
+      }
+      if (sessionUpdate === "tool_call" && toolCallId) {
+        run.toolIds.add(toolCallId);
+        run.inFlight.add(toolCallId);
+      } else if (sessionUpdate === "tool_call_update" && toolCallId && TERMINAL_TOOL_STATUS.has(String(update["status"]))) {
+        run.inFlight.delete(toolCallId);
+        if (toolCallId)
+          run.toolIds.add(toolCallId);
+      }
+      if ((sessionUpdate === "tool_call" || sessionUpdate === "tool_call_update") && toolCallId) {
+        rememberToolDisplay(run, toolCallId, update);
+      }
+      if (isLodySubagentOutput(update)) {
+        out.push(this.emit(run, { type: "output", update }));
+        if (toolCallId && run.mirrors.has(toolCallId)) {
+          out.push({
+            kind: "root",
+            update: this.mirrorRootUpdate(run, update, toolCallId)
+          });
+        }
+      }
+      if (this.rootResumed && run.inFlight.size === 0) {
+        out.push(this.closeSidekickSnapshot(run, { state: "completed" }));
+      }
+      return out;
+    }
+    if (this.sidekickRun?.live && ROOT_ACTIVITY.has(String(sessionUpdate))) {
+      if (this.sidekickRun.inFlight.size === 0) {
+        out.push(this.closeSidekickSnapshot(this.sidekickRun, { state: "completed" }));
+      } else {
+        this.rootResumed = true;
+      }
+    }
+    out.push({ kind: "root", update });
+    return out;
+  }
+  childUpdate(run, update) {
+    const out = [];
+    if (update["sessionUpdate"] === "usage_update") {
+      out.push(this.emit(run, { type: "progress", progress: usageProgress(update) }));
+      return out;
+    }
+    if ((update["sessionUpdate"] === "tool_call" || update["sessionUpdate"] === "tool_call_update") && typeof update["toolCallId"] === "string") {
+      rememberToolDisplay(run, update["toolCallId"], update);
+    }
+    if (isLodySubagentOutput(update)) {
+      const toolCallId = "toolCallId" in update && typeof update["toolCallId"] === "string" ? update["toolCallId"] : void 0;
+      if (toolCallId)
+        run.toolIds.add(toolCallId);
+      out.push(this.emit(run, { type: "output", update }));
+      if (toolCallId && run.mirrors.has(toolCallId)) {
+        out.push({
+          kind: "root",
+          update: this.mirrorRootUpdate(run, update, toolCallId)
+        });
+      }
+      return out;
+    }
+    if (update["sessionUpdate"] === "agent_message_chunk" || update["sessionUpdate"] === "agent_thought_chunk") {
+      if (run.snapshot.outputIncomplete !== true) {
+        run.snapshot = { ...run.snapshot, outputIncomplete: true };
+        out.push(this.emit(run, { type: "snapshot", snapshot: run.snapshot }));
+      }
+      return out;
+    }
+    return out;
+  }
+  /**
+   * Runtime `session/request_permission` for this session. Returns the
+   * rewritten params when the toolCallId belongs to a live run, else null.
+   */
+  rewritePermissionParams(params) {
+    if (!isRecord$2(params))
+      return null;
+    const toolCall = params["toolCall"];
+    if (!isRecord$2(toolCall) || typeof toolCall["toolCallId"] !== "string")
+      return null;
+    const id = toolCall["toolCallId"];
+    const events = [];
+    let run;
+    for (const r of this.runs.values()) {
+      if (r.live && r.toolIds.has(id)) {
+        run = r;
+        break;
+      }
+    }
+    if (!run && this.sidekickRun?.live && this.sidekickRun.toolIds.has(id)) {
+      run = this.sidekickRun;
+    }
+    if (!run && id.startsWith(SIDEKICK_ID_PREFIX)) {
+      if (this.sidekickRun?.live) {
+        run = this.sidekickRun;
+      } else {
+        const opened = this.openSidekickRun();
+        events.push(...opened.out);
+        run = opened.run;
+      }
+      run.toolIds.add(id);
+    }
+    if (!run)
+      return null;
+    run.mirrors.add(id);
+    const known = run.toolDisplay.get(id) ?? {};
+    return {
+      events,
+      params: {
+        ...params,
+        toolCall: {
+          ...known,
+          ...toolCall,
+          toolCallId: mirrorToolCallId(run.runId, id)
+        },
+        _meta: {
+          ...isRecord$2(params["_meta"]) ? params["_meta"] : {},
+          lody: { subagentRunId: run.runId, subagentToolCallId: id }
+        }
+      }
+    };
+  }
+  /**
+   * Client `session/prompt` response arrived. Close any live sidekick run
+   * before the response; subagent runs are unaffected (may be background).
+   */
+  handlePromptDone(stopReason, isError) {
+    this.stashedProgress = void 0;
+    const run = this.sidekickRun;
+    if (!run?.live)
+      return [];
+    let patch;
+    if (isError) {
+      patch = {
+        state: "unknown",
+        outputIncomplete: true,
+        reason: { code: "error" }
+      };
+    } else if (stopReason === "cancelled") {
+      patch = { state: "cancelled", reason: { code: "cancelled" } };
+    } else {
+      patch = { state: "completed" };
+    }
+    return [this.closeSidekickSnapshot(run, patch)];
+  }
+}
+function mirrorToolCallId(runId, toolCallId) {
+  return `subagent:${encodeURIComponent(runId)}:${encodeURIComponent(toolCallId)}`;
+}
+const MODEL_OPTION_ID = "model";
+const FALLBACK_MODEL_ID = "devin";
+const SIDEKICK_MODEL_ID = "sidekick";
+const MAX_RECENT_SIGNATURES = 8;
+const PASSTHROUGH_META = [
+  privateWireContract.usageTotalCreditCostMeta,
+  privateWireContract.usageTotalAcuCostMeta,
+  privateWireContract.usageResponseDimensionsMeta
+];
+function isRecord$1(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function agentContext(meta) {
+  const ctx = meta?.[privateWireContract.subagentContextMeta];
+  if (!isRecord$1(ctx))
+    return void 0;
+  const id = ctx["parentAgentId"];
+  return typeof id === "string" ? id : void 0;
+}
+class DevinSessionUsage {
+  sessionId;
+  /** One accumulator per ACP session: each session is its own accounting
+   * lifetime, so each keeps a never-reused usageScopeId. Created lazily so
+   * sessions without countable usage never consume an injected id. */
+  accumulator;
+  modelId = FALLBACK_MODEL_ID;
+  operation = 0;
+  signatures = /* @__PURE__ */ new Set();
+  signatureOrder = [];
+  newId;
+  constructor(sessionId, newId = crypto.randomUUID.bind(crypto)) {
+    this.sessionId = sessionId;
+    this.newId = newId;
+  }
+  /** Track the ACP `model` config option from session responses and
+   * config_option_update notifications; usage rows accumulate under it. */
+  observeConfigOptions(options) {
+    if (!Array.isArray(options))
+      return;
+    for (const option of options) {
+      if (!isRecord$1(option) || option["id"] !== MODEL_OPTION_ID)
+        continue;
+      const value = option["currentValue"];
+      if (typeof value === "string" && value.length > 0)
+        this.modelId = value;
+    }
+  }
+  /**
+   * Translate one runtime `usage_update` into a Core SessionUsageUpdate, or
+   * return undefined when the row must not enter this session's accounting:
+   * child-run usage, a duplicate report of an already-counted request, or a
+   * row without the private token counters needed for disjoint buckets.
+   */
+  record(update) {
+    const meta = isRecord$1(update["_meta"]) ? update["_meta"] : void 0;
+    const ctx = agentContext(meta);
+    if (ctx !== void 0 && ctx !== privateWireContract.rootAgentId && ctx !== privateWireContract.sidekickAgentId) {
+      return void 0;
+    }
+    const input = num(meta?.[privateWireContract.usageInputTokensMeta]);
+    const output = num(meta?.[privateWireContract.usageOutputTokensMeta]);
+    if (input === void 0 || output === void 0)
+      return void 0;
+    const cachedRead = num(meta?.[privateWireContract.usageCachedReadTokensMeta]) ?? 0;
+    const cachedWrite = num(meta?.[privateWireContract.usageCachedWriteTokensMeta]);
+    const signature = JSON.stringify([
+      input,
+      output,
+      cachedRead,
+      cachedWrite ?? 0,
+      num(update["used"]) ?? null
+    ]);
+    if (this.signatures.has(signature))
+      return void 0;
+    this.signatures.add(signature);
+    this.signatureOrder.push(signature);
+    if (this.signatureOrder.length > MAX_RECENT_SIGNATURES) {
+      this.signatures.delete(this.signatureOrder.shift());
+    }
+    const row = {
+      // Devin's inputTokens includes cache reads AND cache writes (verified on
+      // gpt-6-luna: input = fresh + cachedRead + cachedWrite); Core buckets
+      // are disjoint, so subtract both. SWE-2 rows omit cachedWriteTokens.
+      inputTokens: Math.max(0, input - cachedRead - (cachedWrite ?? 0)),
+      outputTokens: output,
+      cacheReadInputTokens: cachedRead
+    };
+    if (cachedWrite !== void 0)
+      row.cacheCreationInputTokens = cachedWrite;
+    const modelId = ctx === privateWireContract.sidekickAgentId ? SIDEKICK_MODEL_ID : this.modelId;
+    this.accumulator ??= new SessionUsageAccumulator(this.newId());
+    const result = this.accumulator.update(this.sessionId, `devin-request-${++this.operation}`, { [modelId]: row });
+    if (result === void 0)
+      return void 0;
+    const size = num(update["size"]);
+    if (size !== void 0)
+      result.usage.contextWindow = size;
+    if (meta !== void 0) {
+      const passthrough = {};
+      for (const key of PASSTHROUGH_META) {
+        if (meta[key] !== void 0)
+          passthrough[key] = meta[key];
+      }
+      if (Object.keys(passthrough).length > 0) {
+        result._meta = { ...result._meta, ...passthrough };
+      }
+    }
+    return result;
+  }
+}
+const SUBAGENT_SUPPORT_META = privateWireContract.subagentSupportClientCapability;
+const SUBAGENT_EVENTS_CAPABILITY = { version: 1 };
+const COMPACTION_CAPABILITY = { version: 1 };
+const ELICITATION_CAPABILITY = { version: 1 };
+const USAGE_CAPABILITY = { version: 1 };
+const COMPACTION_ACTIVITY_META = {
+  lody: { activity: { version: 1, kind: "context_compaction" } }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRequest(message) {
+  return typeof message.method === "string" && message.id !== void 0 && message.id !== null;
+}
+function isResponse(message) {
+  return message.id !== void 0 && message.id !== null && message.method === void 0;
+}
+function hasCompactionSummary(summary) {
+  return typeof summary === "string" && summary.trim().length > 0;
+}
+function isManualCompactionPrompt(params) {
+  if (!isRecord(params) || !Array.isArray(params["prompt"]))
+    return false;
+  let text;
+  for (const block of params["prompt"]) {
+    if (!isRecord(block) || block["type"] !== "text" || typeof block["text"] !== "string") {
+      return false;
+    }
+    const value = block["text"].trim();
+    if (!value)
+      continue;
+    if (text !== void 0)
+      return false;
+    text = value;
+  }
+  const command = privateWireContract.compactionManualCommand;
+  return text === command || text?.startsWith(`${command} `) === true;
+}
+class DevinAcpProxy {
+  pending = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  usages = /* @__PURE__ */ new Map();
+  admitted = /* @__PURE__ */ new Set();
+  /** sessions inside a session/load replay window: updates pass through. */
+  replaying = /* @__PURE__ */ new Set();
+  /** sessions whose next compaction started event belongs to a manual /compact prompt. */
+  manualCompactionArmed = /* @__PURE__ */ new Set();
+  /** admitted sessions with a live native compaction. */
+  activeCompactions = /* @__PURE__ */ new Map();
+  negotiated = false;
+  /** client advertised _meta.lody.elicitation — translate private elicitation hints. */
+  lodyElicitation = false;
+  /** elicitation/create request id -> injected custom-answer companion fields. */
+  elicitationCustomFields = /* @__PURE__ */ new Map();
+  subagentOpts;
+  newId;
+  constructor(opts = {}) {
+    this.subagentOpts = opts;
+    this.newId = opts.newId ?? randomUUID;
+  }
+  handleClient(message) {
+    let msg = message;
+    if (!isRecord(msg))
+      return { toClient: [], toRuntime: [msg] };
+    if (isRequest(msg)) {
+      const sessionId = isRecord(msg.params) && typeof msg.params["sessionId"] === "string" ? msg.params["sessionId"] : void 0;
+      const manualCompaction = msg.method === "session/prompt" && sessionId !== void 0 && isManualCompactionPrompt(msg.params);
+      this.pending.set(msg.id, {
+        method: msg.method,
+        sessionId,
+        manualCompaction
+      });
+      if (msg.method === "initialize") {
+        const caps = isRecord(msg.params) ? msg.params["clientCapabilities"] : void 0;
+        this.negotiated = supportsLodySubagentEvents(caps);
+        this.lodyElicitation = clientSupportsLodyElicitation(caps);
+        if (this.negotiated && isRecord(msg.params)) {
+          msg = {
+            ...msg,
+            params: {
+              ...msg.params,
+              clientCapabilities: {
+                ...isRecord(caps) ? caps : {},
+                _meta: {
+                  ...isRecord(caps) && isRecord(caps["_meta"]) ? caps["_meta"] : {},
+                  [SUBAGENT_SUPPORT_META]: true
+                }
+              }
+            }
+          };
+        }
+      }
+      if (msg.method === "session/prompt" && sessionId) {
+        if (manualCompaction) {
+          this.manualCompactionArmed.add(sessionId);
+        } else {
+          this.manualCompactionArmed.delete(sessionId);
+        }
+      }
+      if ((msg.method === "session/load" || msg.method === "session/resume") && sessionId) {
+        this.replaying.add(sessionId);
+        this.manualCompactionArmed.delete(sessionId);
+      }
+    }
+    if (isResponse(msg)) {
+      const customFields = this.elicitationCustomFields.get(msg.id);
+      if (customFields) {
+        this.elicitationCustomFields.delete(msg.id);
+        const result = foldElicitationResponse(msg.result, customFields);
+        if (result !== void 0)
+          msg = { ...msg, result };
+      }
+    }
+    return { toClient: [], toRuntime: [msg] };
+  }
+  handleRuntime(message) {
+    const msg = message;
+    if (!isRecord(msg))
+      return { toClient: [msg], toRuntime: [] };
+    if (isResponse(msg)) {
+      const pending = this.pending.get(msg.id);
+      this.pending.delete(msg.id);
+      return this.handleRuntimeResponse(msg, pending);
+    }
+    if (isRequest(msg)) {
+      return this.handleRuntimeRequest(msg);
+    }
+    if (msg.method === "session/update" && isRecord(msg.params)) {
+      return this.handleSessionUpdate(msg);
+    }
+    if (msg.method === privateWireContract.compactionNotificationMethod) {
+      return this.handleCompactionNotification(msg);
+    }
+    return { toClient: [msg], toRuntime: [] };
+  }
+  handleRuntimeResponse(msg, pending) {
+    const toClient = [];
+    if (pending?.method === "initialize" && isRecord(msg.result)) {
+      const agentCaps = isRecord(msg.result["agentCapabilities"]) ? msg.result["agentCapabilities"] : {};
+      const meta = isRecord(agentCaps["_meta"]) ? agentCaps["_meta"] : {};
+      const lody = isRecord(meta["lody"]) ? meta["lody"] : {};
+      const result = {
+        ...msg.result,
+        agentCapabilities: {
+          ...agentCaps,
+          _meta: {
+            ...meta,
+            lody: {
+              ...lody,
+              subagentEvents: SUBAGENT_EVENTS_CAPABILITY,
+              compaction: COMPACTION_CAPABILITY,
+              elicitation: ELICITATION_CAPABILITY,
+              usage: USAGE_CAPABILITY
+            }
+          }
+        }
+      };
+      toClient.push({ ...msg, result });
+      return { toClient, toRuntime: [] };
+    }
+    if (pending?.manualCompaction && pending.sessionId && msg.error !== void 0) {
+      this.manualCompactionArmed.delete(pending.sessionId);
+    }
+    if (pending?.method === "session/new" || pending?.method === "session/fork") {
+      if (isRecord(msg.result) && typeof msg.result["sessionId"] === "string") {
+        this.admit(msg.result["sessionId"]);
+        this.usages.get(msg.result["sessionId"])?.observeConfigOptions(msg.result["configOptions"]);
+      }
+    } else if ((pending?.method === "session/load" || pending?.method === "session/resume") && pending.sessionId) {
+      this.replaying.delete(pending.sessionId);
+      if (msg.result !== void 0 && msg.error === void 0) {
+        this.admit(pending.sessionId);
+        if (isRecord(msg.result)) {
+          this.usages.get(pending.sessionId)?.observeConfigOptions(msg.result["configOptions"]);
+        }
+      }
+    } else if (pending?.method === "session/set_config_option" && pending.sessionId) {
+      if (isRecord(msg.result)) {
+        this.usages.get(pending.sessionId)?.observeConfigOptions(msg.result["configOptions"]);
+      }
+    } else if (pending?.method === "session/prompt" && pending.sessionId) {
+      const session = this.sessions.get(pending.sessionId);
+      if (session) {
+        const isError = msg.error !== void 0;
+        const stopReason = isRecord(msg.result) && typeof msg.result["stopReason"] === "string" ? msg.result["stopReason"] : void 0;
+        for (const o of session.handlePromptDone(stopReason, isError)) {
+          toClient.push(...this.render(session, o));
+        }
+      }
+    }
+    toClient.push(msg);
+    return { toClient, toRuntime: [] };
+  }
+  handleRuntimeRequest(msg) {
+    if (msg.method === "elicitation/create" && isRecord(msg.params) && this.lodyElicitation) {
+      const rewritten = rewriteElicitationParams(msg.params);
+      if (rewritten) {
+        if (rewritten.customFields.size > 0) {
+          this.elicitationCustomFields.set(msg.id, rewritten.customFields);
+        }
+        return {
+          toClient: [{ ...msg, params: rewritten.params }],
+          toRuntime: []
+        };
+      }
+    }
+    if (msg.method === "session/request_permission" && isRecord(msg.params)) {
+      const sessionId = typeof msg.params["sessionId"] === "string" ? msg.params["sessionId"] : void 0;
+      const session = sessionId ? this.sessions.get(sessionId) : void 0;
+      if (session && sessionId && this.admitted.has(sessionId) && !this.replaying.has(sessionId)) {
+        const rewritten = session.rewritePermissionParams(msg.params);
+        if (rewritten) {
+          const toClient = [];
+          for (const o of rewritten.events) {
+            toClient.push(...this.render(session, o));
+          }
+          toClient.push({ ...msg, params: rewritten.params });
+          return { toClient, toRuntime: [] };
+        }
+      }
+    }
+    return { toClient: [msg], toRuntime: [] };
+  }
+  handleSessionUpdate(msg) {
+    const params = msg.params;
+    const sessionId = typeof params["sessionId"] === "string" ? params["sessionId"] : void 0;
+    const update = params["update"];
+    const session = sessionId ? this.sessions.get(sessionId) : void 0;
+    const live = sessionId !== void 0 && this.admitted.has(sessionId) && !this.replaying.has(sessionId);
+    const usageOut = [];
+    if (live && sessionId && isRecord(update)) {
+      const tracker = this.usages.get(sessionId);
+      if (tracker && update["sessionUpdate"] === "config_option_update") {
+        tracker.observeConfigOptions(update["configOptions"]);
+      }
+      if (tracker && update["sessionUpdate"] === "usage_update") {
+        const translated = tracker.record(update);
+        if (translated !== void 0) {
+          usageOut.push({
+            jsonrpc: "2.0",
+            method: LODY_EXTENSION_METHODS.sessionUsageUpdate,
+            params: translated
+          });
+        }
+      }
+    }
+    if (!this.negotiated || !sessionId || !session || !live || !isRecord(update)) {
+      return { toClient: [msg, ...usageOut], toRuntime: [] };
+    }
+    const toClient = [];
+    for (const o of session.handleSessionUpdate(update)) {
+      toClient.push(...this.render(session, o));
+    }
+    toClient.push(...usageOut);
+    return { toClient, toRuntime: [] };
+  }
+  /**
+   * Devin's private `_cognition.ai/compaction` lifecycle, rendered as a Core
+   * context-compaction activity on a synthetic tool call. The native lifecycle
+   * owns completion independently of the `/compact` prompt response. Only
+   * admitted sessions outside a replay window produce activity; replay and
+   * malformed or unknown-status rows pass through untouched.
+   */
+  handleCompactionNotification(msg) {
+    const params = msg.params;
+    const sessionId = isRecord(params) && typeof params[privateWireContract.compactionSessionIdField] === "string" && params[privateWireContract.compactionSessionIdField] ? params[privateWireContract.compactionSessionIdField] : void 0;
+    const status = isRecord(params) ? params[privateWireContract.compactionStatusField] : void 0;
+    const known = status === privateWireContract.compactionStartedStatus || status === privateWireContract.compactionCompletedStatus || status === privateWireContract.compactionFailedStatus;
+    if (!sessionId || !known || !this.admitted.has(sessionId) || this.replaying.has(sessionId)) {
+      return { toClient: [msg], toRuntime: [] };
+    }
+    if (status === privateWireContract.compactionStartedStatus) {
+      if (this.activeCompactions.has(sessionId)) {
+        return { toClient: [], toRuntime: [] };
+      }
+      const toolCallId = `devin-compaction-${this.newId()}`;
+      const shown = this.manualCompactionArmed.delete(sessionId);
+      this.activeCompactions.set(sessionId, { toolCallId, shown });
+      if (!shown)
+        return { toClient: [], toRuntime: [] };
+      return {
+        toClient: [this.compactionStart(sessionId, toolCallId)],
+        toRuntime: []
+      };
+    }
+    const active = this.activeCompactions.get(sessionId);
+    this.activeCompactions.delete(sessionId);
+    if (!active) {
+      return { toClient: [], toRuntime: [] };
+    }
+    const manuallyArmed = this.manualCompactionArmed.delete(sessionId);
+    const summary = params[privateWireContract.compactionSummaryField];
+    const terminal = this.compactionTerminal(sessionId, active.toolCallId, status, summary);
+    if (active.shown) {
+      return { toClient: [terminal], toRuntime: [] };
+    }
+    if (!manuallyArmed && status === privateWireContract.compactionCompletedStatus && !hasCompactionSummary(summary)) {
+      return { toClient: [], toRuntime: [] };
+    }
+    return {
+      toClient: [this.compactionStart(sessionId, active.toolCallId), terminal],
+      toRuntime: []
+    };
+  }
+  compactionStart(sessionId, toolCallId) {
+    return {
+      jsonrpc: "2.0",
+      method: "session/update",
+      params: {
+        sessionId,
+        update: {
+          sessionUpdate: "tool_call",
+          toolCallId,
+          title: "Compact context",
+          kind: "other",
+          status: "in_progress",
+          _meta: { ...COMPACTION_ACTIVITY_META }
+        }
+      }
+    };
+  }
+  compactionTerminal(sessionId, toolCallId, status, summary) {
+    const update = {
+      sessionUpdate: "tool_call_update",
+      toolCallId,
+      status,
+      _meta: { ...COMPACTION_ACTIVITY_META }
+    };
+    if (status === privateWireContract.compactionCompletedStatus && hasCompactionSummary(summary)) {
+      update["content"] = [
+        { type: "content", content: { type: "text", text: summary } }
+      ];
+    }
+    return {
+      jsonrpc: "2.0",
+      method: "session/update",
+      params: { sessionId, update }
+    };
+  }
+  render(session, out) {
+    if (out.kind === "event") {
+      return [
+        {
+          jsonrpc: "2.0",
+          method: LODY_SUBAGENT_EVENT_METHOD,
+          params: out.event
+        }
+      ];
+    }
+    return [
+      {
+        jsonrpc: "2.0",
+        method: "session/update",
+        params: { sessionId: session.sessionId, update: out.update }
+      }
+    ];
+  }
+  admit(sessionId) {
+    if (!this.admitted.has(sessionId)) {
+      this.admitted.add(sessionId);
+      this.sessions.set(sessionId, new DevinSubagentEvents(sessionId, this.subagentOpts));
+      this.usages.set(sessionId, new DevinSessionUsage(sessionId, this.newId));
+    }
+  }
+  /** Method of the still-pending client request, for translation dispatch. */
+  pendingClientMethod(id) {
+    return this.pending.get(id)?.method;
+  }
+}
+function spawnDevinRuntime(devinPath2, { env = process.env, spawnImpl = spawn } = {}) {
+  return spawnImpl(devinPath2, ["acp"], {
+    env,
+    stdio: ["pipe", "pipe", "inherit"],
+    windowsHide: true
+  });
+}
+const devinPath = process.env.DEVIN_PATH;
+if (!devinPath) {
+  console.error("DEVIN_PATH must point to the official Devin runtime");
+  process.exit(1);
+}
+const child = spawnDevinRuntime(devinPath);
+const proxy = new DevinAcpProxy();
+if (!child.stdin || !child.stdout) {
+  console.error("Official Devin runtime stdio is not piped");
+  process.exit(1);
+}
+const childStdin = child.stdin;
+const childStdout = child.stdout;
+function exit(code) {
+  process.stdout.write("", () => process.exit(code));
+}
+function write(stream, message) {
+  stream.write(`${JSON.stringify(message)}
+`);
+}
+function dispatch(output) {
+  for (const message of output.toRuntime)
+    write(childStdin, message);
+  for (const message of output.toClient)
+    write(process.stdout, message);
+}
+createInterface({ input: process.stdin }).on("line", (line) => {
+  try {
+    dispatch(proxy.handleClient(JSON.parse(line)));
+  } catch (error) {
+    console.error(`Invalid ACP client message: ${error instanceof Error ? error.message : String(error)}`);
+  }
+});
+createInterface({ input: childStdout }).on("line", (line) => {
+  try {
+    dispatch(proxy.handleRuntime(JSON.parse(line)));
+  } catch (error) {
+    console.error(`Invalid Devin runtime message: ${error instanceof Error ? error.message : String(error)}`);
+  }
+});
+process.stdin.on("end", () => childStdin.end());
+child.on("error", (error) => {
+  console.error(`Failed to launch official Devin runtime: ${error.message}`);
+  exit(1);
+});
+child.on("close", (code, signal) => {
+  if (signal)
+    process.kill(process.pid, signal);
+  else
+    exit(code ?? 1);
+});
+//# sourceMappingURL=devin-acp.js.map