@alook/app 0.1.50 → 0.1.51

package/dist/daemon/index.js

@@ -32556,14 +32556,16 @@ class OpenCodeServiceLane {
       if (!this.identity || this.identity.generation !== generation || this.isProcessClosed(this.identity.process)) {
         if (/EADDRINUSE|address already in use/i.test(this.stderrBuffer))
           throw new OpenCodePortBindError("OpenCode service port bind raced");
-        throw new Error("OpenCode service exited before readiness");
+        const process2 = this.identity?.process;
+        const detail = scrubDriverErrorMessage(this.stderrBuffer.replaceAll(this.password, "[redacted]"), "no native stderr");
+        throw new Error(`OpenCode service exited before readiness (code=${process2?.exitCode ?? "unknown"}, signal=${process2?.signalCode ?? "none"}): ${detail}`);
       }
       try {
         const healthTimeoutMs = Math.max(1, Math.min(1000, deadline - Date.now(), this.options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS));
-        const { response, body } = await this.fetchJsonWithTimeout("/global/health", { method: "GET" }, "health", healthTimeoutMs);
+        const { response, body } = await this.fetchJsonWithTimeout(this.healthPath, { method: "GET" }, "health", healthTimeoutMs);
         if (response.ok) {
           const health = record5(body);
-          if (health?.healthy !== true) {
+          if (!this.acceptsHealth(health)) {
             throw new OpenCodeIncompatibleError("Installed OpenCode service did not report healthy status");
           }
           await this.verifyOpenApi();
@@ -32580,12 +32582,27 @@ class OpenCodeServiceLane {
     throw new Error("OpenCode service readiness timed out");
   }
   async verifyOpenApi() {
-    const { response, body } = await this.fetchJsonWithTimeout("/doc", { method: "GET" }, "OpenAPI");
+    const { response, body } = await this.fetchJsonWithTimeout(this.openApiPath, { method: "GET" }, "OpenAPI");
     if (!response.ok)
       throw new OpenCodeIncompatibleError("Installed OpenCode service does not expose its OpenAPI document");
     const document = record5(body);
     const paths = record5(document?.paths);
-    const required2 = [
+    const required2 = this.requiredApiPaths;
+    if (!paths || required2.some((path10) => !record5(paths[path10]))) {
+      throw new OpenCodeIncompatibleError("Installed OpenCode service is missing required session capabilities");
+    }
+  }
+  get healthPath() {
+    return "/global/health";
+  }
+  get openApiPath() {
+    return "/doc";
+  }
+  acceptsHealth(health) {
+    return health?.healthy === true;
+  }
+  get requiredApiPaths() {
+    return [
       "/api/session",
       "/api/session/active",
       "/api/session/{sessionID}/prompt",
@@ -32597,12 +32614,12 @@ class OpenCodeServiceLane {
       "/api/session/{sessionID}/permission/{requestID}/reply",
       "/api/event"
     ];
-    if (!paths || required2.some((path10) => !record5(paths[path10]))) {
-      throw new OpenCodeIncompatibleError("Installed OpenCode service is missing required v2 session capabilities");
-    }
+  }
+  get selectedModel() {
+    return parseModelRef(resolveLaunchFieldsOrDefault(this.ctx.config.runtimeConfig).model);
   }
   async openSession(resumeId) {
-    const model = parseModelRef(resolveLaunchFieldsOrDefault(this.ctx.config.runtimeConfig).model);
+    const model = this.selectedModel;
     if (resumeId) {
       const { response: response2, body: body2 } = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(resumeId)}`, { method: "GET" }, "session resume");
       if (response2.status === 404) {
@@ -32945,7 +32962,7 @@ class OpenCodeServiceLane {
   async handleLiveEvent(value) {
     const event = record5(value);
     const data = record5(event?.data);
-    if (event?.type !== "permission.v2.asked" || data?.sessionID !== this.sessionId)
+    if (event?.type !== this.permissionEventType || data?.sessionID !== this.sessionId)
       return;
     if (typeof data.id !== "string" || !/^per/.test(data.id)) {
       throw new OpenCodeProtocolError("OpenCode emitted a malformed permission request");
@@ -32968,13 +32985,19 @@ class OpenCodeServiceLane {
       }
     }
   }
+  get permissionEventType() {
+    return "permission.v2.asked";
+  }
+  get permissionReply() {
+    return { reply: "once" };
+  }
   async replyPermission(requestId) {
     if (this.handledPermissions.has(requestId))
       return;
     const existing = this.permissionFlights.get(requestId);
     if (existing)
       return existing;
-    const flight = this.requestNoContent(`/api/session/${encodeURIComponent(this.sessionId)}/permission/${encodeURIComponent(requestId)}/reply`, "POST", { reply: "once" }, "permission reply").catch((error62) => {
+    const flight = this.requestNoContent(`/api/session/${encodeURIComponent(this.sessionId)}/permission/${encodeURIComponent(requestId)}/reply`, "POST", this.permissionReply, "permission reply").catch((error62) => {
       if (!(error62 instanceof OpenCodeHttpError) || error62.status !== 404)
         throw error62;
     }).then(() => {
@@ -33351,6 +33374,28 @@ async function legacyOpenCodeApiEnvironment(environment, model) {
   return credential?.type === "api" && typeof credential.key === "string" && credential.key.trim() ? { [name]: credential.key } : {};
 }
 
+// agent-driver/dist/adapters/opencode/compatibility.js
+var OPEN_CODE_V1 = {
+  major: 1,
+  modelArgs: ["models", "--pure"],
+  serviceArgs: ["serve", "--pure"],
+  sessionListArgs: (maxCount) => ["session", "list", "--format", "json", "--max-count", String(maxCount), "--pure"]
+};
+var OPEN_CODE_V2 = {
+  major: 2,
+  modelArgs: ["models", "--standalone"],
+  serviceArgs: ["serve"],
+  sessionListArgs: (maxCount) => ["api", "--standalone", "GET", `/api/session?parentID=null&order=desc&limit=${maxCount}`]
+};
+function resolveOpenCodeCompatibility(version3) {
+  const match = version3?.trim().match(/^(?:opencode\s+)?v?(\d+)\.\d+\.\d+(?:[-+][\w.-]+)?$/i);
+  if (match?.[1] === "1")
+    return OPEN_CODE_V1;
+  if (match?.[1] === "2")
+    return OPEN_CODE_V2;
+  throw new Error("Installed OpenCode CLI version is unrecognized or has an unsupported major version");
+}
+
 // agent-driver/dist/adapters/opencode/recent-context.js
 var OPENCODE_DISCOVERY_TIMEOUT_MS = 15000;
 var OPENCODE_DISCOVERY_OUTPUT_MAX_BYTES = 4 * 1024 * 1024;
@@ -33384,6 +33429,7 @@ async function discoverOpenCodeRecentContext(request, dependencies = {}) {
   const collector = new RecentContextCollector(request, "unavailable");
   if (collector.satisfied)
     return collector.result();
+  const compatibility = dependencies.compatibility ?? OPEN_CODE_V1;
   const startedAt = Date.now();
   const timeoutMs = dependencies.timeoutMs ?? OPENCODE_DISCOVERY_TIMEOUT_MS;
   let remainingOutputBytes = dependencies.outputMaxBytes ?? OPENCODE_DISCOVERY_OUTPUT_MAX_BYTES;
@@ -33392,7 +33438,7 @@ async function discoverOpenCodeRecentContext(request, dependencies = {}) {
     const remainingTimeoutMs = timeoutMs - (Date.now() - startedAt);
     if (remainingTimeoutMs <= 0)
       throw new Error("OpenCode discovery timed out");
-    const spec = resolveSpawnSpec("opencode", ["session", "list", "--format", "json", "--max-count", String(maxCount), "--pure"], request.command);
+    const spec = resolveSpawnSpec("opencode", [...compatibility.sessionListArgs(maxCount)], request.command);
     const commandOutput = await collectCommandOutput(spec.command, spec.args, spec.shell, dependencies, remainingTimeoutMs, remainingOutputBytes);
     remainingOutputBytes -= commandOutput.outputBytes;
     let parsed;
@@ -33401,14 +33447,17 @@ async function discoverOpenCodeRecentContext(request, dependencies = {}) {
     } catch {
       throw new Error("OpenCode session listing returned invalid JSON");
     }
+    if (compatibility.major === 2)
+      parsed = asRecord(parsed)?.data;
     if (!Array.isArray(parsed))
       throw new Error("OpenCode session listing returned an invalid response");
     for (const value of parsed) {
       const session2 = asRecord(value);
       if (!session2)
         continue;
-      const modifiedAt = session2.updated ?? session2.updatedAt;
-      collector.add({ projectPath: session2.directory, modifiedAt });
+      const modifiedAt = compatibility.major === 2 ? asRecord(session2.time)?.updated : session2.updated ?? session2.updatedAt;
+      const projectPath = compatibility.major === 2 ? asRecord(session2.location)?.directory : session2.directory;
+      collector.add({ projectPath, modifiedAt });
     }
     if (collector.satisfied || parsed.length < maxCount)
       break;
@@ -33420,6 +33469,419 @@ async function discoverOpenCodeRecentContext(request, dependencies = {}) {
   return collector.result();
 }
 
+// agent-driver/dist/adapters/opencode/v2-service-lane.js
+class OpenCodeV2ServiceLane extends OpenCodeServiceLane {
+  root = null;
+  v2AdmissionTail = Promise.resolve();
+  v2EvaluationTimer;
+  v2Evaluating = false;
+  projectedMessages = new Set;
+  liveTools = new Map;
+  settledTools = new Set;
+  usage = new SettledUsageProjector;
+  get healthPath() {
+    return "/api/info";
+  }
+  get openApiPath() {
+    return "/openapi.json";
+  }
+  acceptsHealth(health) {
+    if (typeof health?.version !== "string" || !Number.isInteger(health.pid) || Number(health.pid) < 1)
+      return false;
+    try {
+      return resolveOpenCodeCompatibility(health.version).major === 2;
+    } catch {
+      return false;
+    }
+  }
+  get requiredApiPaths() {
+    return [
+      "/api/session",
+      "/api/session/active",
+      "/api/session/{sessionID}",
+      "/api/session/{sessionID}/prompt",
+      "/api/session/{sessionID}/inbox",
+      "/api/session/{sessionID}/message",
+      "/api/session/{sessionID}/message/{messageID}",
+      "/api/session/{sessionID}/interrupt",
+      "/api/session/{sessionID}/model",
+      "/api/session/{sessionID}/permission",
+      "/api/session/{sessionID}/permission/{requestID}/reply",
+      "/api/event"
+    ];
+  }
+  get selectedModel() {
+    const model = super.selectedModel;
+    if (typeof model?.id !== "string")
+      return model;
+    const hash2 = model.id.lastIndexOf("#");
+    return hash2 > 0 && hash2 < model.id.length - 1 ? { ...model, id: model.id.slice(0, hash2), variant: model.id.slice(hash2 + 1) } : model;
+  }
+  get permissionEventType() {
+    return "permission.asked";
+  }
+  get permissionReply() {
+    return { decision: "once" };
+  }
+  protocolFailure(message2, cause) {
+    super.protocolFailure(cause === undefined ? message2 : `${message2}: ${scrubDriverErrorMessage(cause)}`);
+  }
+  async primeHistory() {}
+  startStreams() {
+    const identity = this.identity;
+    this.liveTask = this.runLiveStream(identity).catch((error62) => {
+      if (!this.stopping)
+        this.protocolFailure("OpenCode CLI v2 live stream failed", error62);
+    });
+  }
+  async recoverPendingPermissions() {
+    await super.recoverPendingPermissions();
+    const root = this.root;
+    if (root)
+      for (const message2 of await this.messagesAfter(root))
+        this.projectTools(message2);
+    this.schedule();
+  }
+  async handleLiveEvent(value) {
+    await super.handleLiveEvent(value);
+    const event = record5(value);
+    const data = record5(event?.data);
+    if (data?.sessionID !== this.sessionId || !this.root)
+      return;
+    switch (event?.type) {
+      case "session.step.started":
+        this.events.emit("runtime_event", {
+          kind: "internal_progress",
+          source: "opencode.service",
+          itemType: "step_started"
+        });
+        break;
+      case "session.tool.input.started": {
+        const key = this.toolKey(data.assistantMessageID, data.id);
+        if (key && typeof data.name === "string" && !this.liveTools.has(key) && !this.settledTools.has(key)) {
+          this.liveTools.set(key, { name: data.name, called: false });
+        }
+        break;
+      }
+      case "session.tool.called":
+        this.projectTool(data);
+        break;
+      case "session.tool.success":
+      case "session.tool.failed": {
+        this.finishTool(this.toolKey(data.assistantMessageID, data.id));
+        break;
+      }
+      case "session.compaction.started":
+        this.events.emit("runtime_event", { kind: "compaction_started" });
+        break;
+      case "session.compaction.failed":
+      case "session.compaction.ended":
+        this.events.emit("runtime_event", { kind: "compaction_finished" });
+        break;
+      default:
+        break;
+    }
+    this.schedule();
+  }
+  async send(input2) {
+    if (!this.ready || this.stopping || !this.sessionId || !this.identityMatches())
+      return { ok: false, reason: "closed" };
+    if (input2.mode === "idle") {
+      if (this.root)
+        return { ok: false, reason: "runtime_busy" };
+      return this.beginRoot(input2);
+    }
+    const root = this.root;
+    if (!root)
+      return { ok: false, reason: "not_ready" };
+    return this.admit(input2.text, "steer", this.newMessageId(), root);
+  }
+  async beginRoot(input2) {
+    const page = await this.messagePage(undefined, 1);
+    if (this.stopping || !this.identityMatches())
+      return { ok: false, reason: "closed" };
+    const receipt = input2.terminalOwner?.startsWith("msg_") ? input2.terminalOwner : this.newMessageId();
+    const root = {
+      receipt,
+      baseline: typeof page.data[0]?.id === "string" ? page.data[0].id : null,
+      inputs: new Set,
+      generation: 0,
+      pending: 0
+    };
+    this.root = root;
+    return this.admit(input2.text, "queue", receipt, root);
+  }
+  admit(text2, delivery, id3, root) {
+    root.generation += 1;
+    root.pending += 1;
+    const run = this.v2AdmissionTail.then(async () => {
+      await this.waitForLiveStream();
+      if (this.root !== root || this.stopping || !this.identityMatches())
+        return { ok: false, reason: "closed" };
+      const { response, body } = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(this.sessionId)}/prompt`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: id3, text: text2, delivery, resume: true }) }, "prompt admission");
+      if (!response.ok)
+        throw new OpenCodeHttpError(response.status, "prompt admission");
+      const input2 = record5(record5(body)?.data);
+      if (input2?.id !== id3 || input2.sessionID !== this.sessionId || input2.type !== "user" || input2.delivery !== delivery) {
+        throw new OpenCodeProtocolError("OpenCode CLI v2 returned an invalid prompt receipt");
+      }
+      if (this.root !== root || this.stopping || !this.identityMatches())
+        return { ok: false, reason: "closed" };
+      root.inputs.add(id3);
+      return { ok: true, acceptedAs: delivery === "steer" ? "steer" : "prompt", receipt: id3 };
+    }).catch((error62) => {
+      if (this.root === root && !this.stopping)
+        this.protocolFailure("OpenCode CLI v2 prompt admission failed", error62);
+      throw error62;
+    }).finally(() => {
+      root.pending -= 1;
+      this.schedule();
+    });
+    this.v2AdmissionTail = run.then(() => {}, () => {});
+    return run;
+  }
+  async messagePage(cursor, limit = 100) {
+    const query = new URLSearchParams({ limit: String(limit), ...cursor ? { cursor } : { order: "desc" } });
+    const { response, body } = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(this.sessionId)}/message?${query}`, { method: "GET" }, "message recovery");
+    if (!response.ok)
+      throw new OpenCodeHttpError(response.status, "message recovery");
+    const page = record5(body);
+    const cursors = record5(page?.cursor);
+    if (!Array.isArray(page?.data) || !cursors || page.data.some((item) => typeof record5(item)?.id !== "string")) {
+      throw new OpenCodeProtocolError("OpenCode CLI v2 returned an invalid message page");
+    }
+    if (cursors.next !== undefined && cursors.next !== null && typeof cursors.next !== "string")
+      throw new OpenCodeProtocolError("OpenCode CLI v2 returned an invalid message cursor");
+    return { data: page.data, next: typeof cursors.next === "string" ? cursors.next : undefined };
+  }
+  async messagesAfter(root) {
+    const messages = [];
+    const cursors = new Set;
+    let cursor;
+    for (;; ) {
+      const page = await this.messagePage(cursor);
+      if (this.root !== root || this.stopping)
+        return [];
+      for (const message2 of page.data) {
+        if (message2.id === root.baseline)
+          return messages.reverse();
+        messages.push(message2);
+      }
+      if (!page.next) {
+        if (root.baseline !== null)
+          throw new OpenCodeProtocolError("OpenCode CLI v2 message recovery lost its root boundary");
+        return messages.reverse();
+      }
+      if (cursors.has(page.next))
+        throw new OpenCodeProtocolError("OpenCode CLI v2 message cursor did not advance");
+      cursors.add(page.next);
+      cursor = page.next;
+    }
+  }
+  schedule() {
+    if (!this.root || this.stopping || this.v2EvaluationTimer || this.v2Evaluating)
+      return;
+    this.v2EvaluationTimer = setTimeout(() => {
+      this.v2EvaluationTimer = undefined;
+      this.evaluate();
+    }, this.options.activePollMs ?? 100);
+    this.v2EvaluationTimer.unref?.();
+  }
+  async isActive() {
+    const { response, body } = await this.fetchJsonWithTimeout("/api/session/active", { method: "GET" }, "active session query");
+    if (!response.ok)
+      throw new OpenCodeHttpError(response.status, "active session query");
+    const active = record5(record5(body)?.data);
+    if (!active)
+      throw new OpenCodeProtocolError("OpenCode CLI v2 returned invalid active session data");
+    return active[this.sessionId] !== undefined;
+  }
+  async evaluate() {
+    const root = this.root;
+    const identity = this.identity;
+    if (!root || !identity || this.stopping || root.pending > 0 || root.inputs.size === 0 || this.v2Evaluating)
+      return;
+    this.v2Evaluating = true;
+    const generation = root.generation;
+    const current = () => this.root === root && root.generation === generation && root.pending === 0 && this.isIdentity(identity);
+    try {
+      if (await this.isActive())
+        return;
+      if (!current())
+        return;
+      const messages = await this.messagesAfter(root);
+      if (!current())
+        return;
+      let lastInput = -1;
+      const delivered = new Set;
+      for (const [index2, message2] of messages.entries()) {
+        if (message2.type === "user" && typeof message2.id === "string" && root.inputs.has(message2.id)) {
+          delivered.add(message2.id);
+          lastInput = index2;
+        }
+      }
+      const idle = messages.slice(lastInput + 1).reverse().find((message2) => message2.type === "idle");
+      if (delivered.size !== root.inputs.size) {
+        const { response, body } = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(this.sessionId)}/inbox`, { method: "GET" }, "pending input recovery");
+        if (!response.ok)
+          throw new OpenCodeHttpError(response.status, "pending input recovery");
+        const pending = record5(body)?.data;
+        if (!Array.isArray(pending))
+          throw new OpenCodeProtocolError("OpenCode CLI v2 returned invalid inbox data");
+        if (!current())
+          return;
+        const retained = new Set(pending.map((item) => record5(item)?.id));
+        for (const id3 of root.inputs) {
+          if (delivered.has(id3) || retained.has(id3))
+            continue;
+          const recovered = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(this.sessionId)}/message/${encodeURIComponent(id3)}`, { method: "GET" }, "accepted input recovery");
+          if (!current())
+            return;
+          if (recovered.response.status === 404)
+            throw new OpenCodeProtocolError("OpenCode CLI v2 lost an accepted input from both inbox and messages");
+          if (!recovered.response.ok)
+            throw new OpenCodeHttpError(recovered.response.status, "accepted input recovery");
+          const message2 = record5(record5(recovered.body)?.data);
+          if (message2?.id !== id3 || message2.type !== "user")
+            throw new OpenCodeProtocolError("OpenCode CLI v2 returned an invalid recovered input");
+        }
+        return;
+      }
+      for (const message2 of messages) {
+        this.projectTools(message2);
+        this.projectMessage(message2);
+      }
+      if (!idle || await this.isActive() || !current())
+        return;
+      if (!["succeeded", "failed", "interrupted"].includes(String(idle.outcome))) {
+        throw new OpenCodeProtocolError("OpenCode CLI v2 returned an invalid idle outcome");
+      }
+      this.root = null;
+      if (idle.outcome === "failed") {
+        const error62 = record5(idle.error);
+        this.events.emit("runtime_event", {
+          kind: "error",
+          code: "opencode.turn_failed",
+          message: typeof error62?.message === "string" ? error62.message : "OpenCode CLI v2 execution failed"
+        });
+      }
+      this.events.emit("runtime_event", {
+        kind: "turn_end",
+        sessionId: this.sessionId,
+        turnOwner: root.receipt
+      });
+    } catch (error62) {
+      if (!current() || this.stopping)
+        return;
+      if (error62 instanceof OpenCodeProtocolError || error62 instanceof OpenCodeHttpError && error62.status < 500) {
+        this.protocolFailure("OpenCode CLI v2 durable message recovery failed", error62);
+      } else
+        this.diagnostic("warning", "OpenCode CLI v2 message recovery temporarily unavailable; keeping the root active");
+    } finally {
+      this.v2Evaluating = false;
+      this.schedule();
+    }
+  }
+  toolKey(messageId, id3) {
+    return typeof messageId === "string" && typeof id3 === "string" ? `${messageId}:${id3}` : undefined;
+  }
+  projectTool(data) {
+    const key = this.toolKey(data.assistantMessageID, data.id);
+    if (!key || this.settledTools.has(key))
+      return;
+    const tool = this.liveTools.get(key) ?? { name: typeof data.name === "string" ? data.name : "OpenCode tool", called: false };
+    if (tool.called)
+      return;
+    tool.called = true;
+    this.liveTools.set(key, tool);
+    this.events.emit("runtime_event", { kind: "tool_call", callId: key, name: tool.name, input: data.input });
+  }
+  finishTool(key) {
+    if (!key || this.settledTools.has(key))
+      return;
+    const tool = this.liveTools.get(key);
+    if (!tool?.called)
+      return;
+    this.liveTools.delete(key);
+    this.settledTools.add(key);
+    this.events.emit("runtime_event", { kind: "tool_output", callId: key, name: tool.name });
+  }
+  projectTools(message2) {
+    if (message2.type !== "assistant" || !Array.isArray(message2.content) || !this.root || this.stopping)
+      return;
+    for (const value of message2.content) {
+      const tool = record5(value);
+      const state = record5(tool?.state);
+      if (tool?.type !== "tool" || !["running", "completed", "error"].includes(String(state?.status)))
+        continue;
+      this.projectTool({ assistantMessageID: message2.id, id: tool.id, name: tool.name, input: state?.input });
+      if (state?.status !== "running")
+        this.finishTool(this.toolKey(message2.id, tool.id));
+    }
+  }
+  projectMessage(message2) {
+    if (message2.type !== "assistant" || typeof message2.id !== "string" || this.projectedMessages.has(message2.id))
+      return;
+    const time3 = record5(message2.time);
+    if (time3?.completed === undefined)
+      return;
+    this.projectedMessages.add(message2.id);
+    if (Array.isArray(message2.content))
+      for (const value of message2.content) {
+        const content = record5(value);
+        if (typeof content?.text !== "string" || !content.text)
+          continue;
+        if (content.type === "text")
+          this.events.emit("runtime_event", { kind: "assistant_message_completed", text: content.text });
+        if (content.type === "reasoning")
+          this.events.emit("runtime_event", { kind: "assistant_reasoning_completed", text: content.text });
+      }
+    const tokens = record5(message2.tokens);
+    if (!tokens || !this.sessionId)
+      return;
+    const cache = record5(tokens.cache);
+    const identity = { runtime: "opencode", backendSessionId: this.sessionId, providerRecordId: message2.id };
+    const usage = this.usage.project({
+      ...identity,
+      source: "opencode.v2",
+      input: tokens.input,
+      output: tokens.output,
+      reasoning: tokens.reasoning,
+      cacheRead: cache?.read,
+      cacheWrite: cache?.write,
+      inputIncludesCache: false,
+      outputIncludesReasoning: false
+    });
+    if (usage)
+      this.events.emit("runtime_event", usage);
+    this.usage.release(identity);
+  }
+  async interrupt(_input) {
+    const root = this.root;
+    if (!root || !this.ready || this.stopping || !this.identityMatches())
+      return false;
+    root.generation += 1;
+    root.pending += 1;
+    try {
+      await this.requestNoContent(`/api/session/${encodeURIComponent(this.sessionId)}/interrupt?resume=false`, "POST", undefined, "session interrupt");
+      return true;
+    } catch (error62) {
+      if (!this.stopping)
+        this.stop({ reason: "interrupt_timeout", forceAfterMs: 0 });
+      throw error62;
+    } finally {
+      root.pending -= 1;
+      this.schedule();
+    }
+  }
+  stop(input2 = {}) {
+    this.root = null;
+    if (this.v2EvaluationTimer)
+      clearTimeout(this.v2EvaluationTimer);
+    return super.stop(input2);
+  }
+}
+
 // agent-driver/dist/adapters/opencode/index.js
 function createOpenCodeMessageId() {
   return `msg_${randomBytes4(16).toString("hex")}`;
@@ -33427,6 +33889,7 @@ function createOpenCodeMessageId() {
 
 class OpenCodeDriver {
   outputProbe;
+  versionProbe;
   id = "opencode";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
   execution = {
@@ -33435,17 +33898,29 @@ class OpenCodeDriver {
     wakeStart: "immediate",
     terminalOwnership: "transport_request"
   };
-  constructor(outputProbe = probeCommandOutput) {
+  constructor(outputProbe = probeCommandOutput, versionProbe = probeCliRuntime) {
     this.outputProbe = outputProbe;
+    this.versionProbe = versionProbe;
   }
   discoverRecentContext(request) {
-    return discoverOpenCodeRecentContext(request);
+    if (request.recentProjectsTopK === 0)
+      return discoverOpenCodeRecentContext(request);
+    const result = this.versionProbe("opencode", {}, request.command);
+    if (result.status !== "healthy")
+      throw new Error("Installed OpenCode CLI could not report its version");
+    return discoverOpenCodeRecentContext(request, { compatibility: resolveOpenCodeCompatibility(result.version) });
   }
   probe(command) {
-    const result = probeCliRuntime("opencode", {}, command);
+    const result = this.versionProbe("opencode", {}, command);
     if (result.status !== "healthy")
       return result;
-    const spec = resolveSpawnSpec("opencode", ["models", "--pure"], command);
+    let compatibility;
+    try {
+      compatibility = resolveOpenCodeCompatibility(result.version);
+    } catch {
+      return { ...result, status: "unhealthy", lastError: "unsupported_opencode_cli_version" };
+    }
+    const spec = resolveSpawnSpec("opencode", [...compatibility.modelArgs], command);
     const output2 = this.outputProbe(spec.command, spec.args);
     return {
       ...result,
@@ -33456,20 +33931,29 @@ class OpenCodeDriver {
     return createOpenCodeMessageId();
   }
   async openLane(ctx, options) {
-    return new OpenCodeServiceLane(this, ctx, {
+    const command = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig).command;
+    const result = this.versionProbe("opencode", {}, command);
+    if (result.status !== "healthy")
+      throw new Error("Installed OpenCode CLI could not report its version");
+    const compatibility = resolveOpenCodeCompatibility(result.version);
+    const factory = {
+      spawnService: (launch, port, password) => this.spawnService(launch, port, password, compatibility)
+    };
+    const Lane = compatibility.major === 1 ? OpenCodeServiceLane : OpenCodeV2ServiceLane;
+    return new Lane(factory, ctx, {
       onRawStdoutLine: options?.onRawStdoutLine
     });
   }
-  async spawnService(ctx, port, password) {
+  async spawnService(ctx, port, password, compatibility = OPEN_CODE_V1) {
     const { spawnEnv } = await prepareCliTransport(ctx, {
-      OPENCODE_SERVER_PASSWORD: password
+      OPENCODE_SERVER_PASSWORD: password,
+      ...compatibility.major === 2 ? { OPENCODE_PASSWORD: password } : {}
     });
     const fields2 = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
     Object.assign(spawnEnv, await legacyOpenCodeApiEnvironment(spawnEnv, fields2.model));
     const override = fields2.command;
     const args = [
-      "serve",
-      "--pure",
+      ...compatibility.serviceArgs,
       "--hostname",
       "127.0.0.1",
       "--port",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alook/app",
-  "version": "0.1.50",
+  "version": "0.1.51",
   "description": "Run Alook locally — one command, no clone needed",
   "license": "Apache-2.0",
   "homepage": "https://github.com/alookai/alook#readme",