@opencode-cockpit/subagents 0.7.0

package/dist/core/adapt/v2.js

@@ -0,0 +1,379 @@
+/**
+ * OpenCode 2's events and state, as changes.
+ *
+ * OpenCode 2 names what happened: `session.reasoning.delta`, `session.tool.called`,
+ * `session.execution.succeeded`. Its interface context hands them over as
+ * `{ name, details: { data } }` (`ctx.data.listen`). Thinking and text are keyed by the assistant
+ * message and their ordinal in it; a tool call by its id; what the session was told arrives as an
+ * inbox item. Shapes measured on 2.0.15 (test/fixtures/v2.jsonl).
+ */
+
+import { summaryOf, tokenTotal } from "./v1.js";
+const obj = value => value && typeof value === "object" ? value : {};
+const str = value => typeof value === "string" ? value : undefined;
+
+/** A tool's result as text: v2 returns content parts. */
+const contentText = content => Array.isArray(content) ? content.map(part => str(obj(part).text) ?? "").filter(Boolean).join("\n") : str(content) ?? "";
+export function createV2Translator(unknown = () => {}) {
+  const sessionInfo = (info, at) => {
+    const id = str(info.sessionID) ?? str(info.id);
+    if (!id) return [];
+    return [{
+      type: "session",
+      id,
+      ...(str(info.parentID) ? {
+        parentID: str(info.parentID)
+      } : {}),
+      ...(str(info.agent) ? {
+        agent: str(info.agent)
+      } : {}),
+      ...(str(info.title) ? {
+        title: str(info.title)
+      } : {}),
+      ...(str(obj(info.model).id) ? {
+        model: str(obj(info.model).id)
+      } : {}),
+      at: Number(obj(info.time).created) || at
+    }];
+  };
+  const statusChange = (id, value, at) => {
+    const status = str(value) ?? str(obj(value).type);
+    if (status === "busy" || status === "running" || status === "retry") return [{
+      type: "status",
+      id,
+      status: "busy",
+      at
+    }];
+    if (status === "idle") return [{
+      type: "status",
+      id,
+      status: "idle",
+      at
+    }];
+    return [];
+  };
+
+  /** `subagent` calls launched with `background: true`, until their child session is named. */
+  const background = new Set();
+  return {
+    event(raw, at = Date.now()) {
+      const event = obj(raw);
+      const name = str(event.name) ?? str(event.type);
+      /** The interface's events carry `details.data`; the agent side's carry `data`. */
+      const details = obj(event.details);
+      const data = obj("data" in details ? details.data : event.data);
+      const id = str(data.sessionID);
+      if (!name) return [];
+      const key = () => `${str(data.assistantMessageID) ?? "?"}:${String(data.ordinal ?? 0)}`;
+      switch (name) {
+        case "session.created":
+        case "session.renamed":
+          return sessionInfo(data, at);
+        case "session.execution.started":
+          return id ? [{
+            type: "status",
+            id,
+            status: "busy",
+            at
+          }] : [];
+        case "session.execution.succeeded":
+          return id ? [{
+            type: "status",
+            id,
+            status: "idle",
+            at
+          }] : [];
+        case "session.execution.failed":
+        case "session.execution.interrupted":
+          {
+            if (!id) return [];
+            const error = str(data.message) ?? str(obj(data.error).message) ?? (name.endsWith("interrupted") ? "interrupted" : "failed");
+            return [{
+              type: "status",
+              id,
+              status: "failed",
+              error,
+              at
+            }];
+          }
+        case "session.inbox.enqueued":
+          {
+            const item = obj(data.item);
+            const text = str(obj(item.payload).text);
+            return id && text && item.type === "user" ? [{
+              type: "prompt",
+              id,
+              key: str(data.inboxID) ?? `${at}`,
+              text,
+              at
+            }] : [];
+          }
+        case "session.reasoning.started":
+          return id ? [{
+            type: "thinking",
+            id,
+            key: `r:${key()}`,
+            text: "",
+            at
+          }] : [];
+        case "session.reasoning.delta":
+          return id && str(data.delta) ? [{
+            type: "thinking",
+            id,
+            key: `r:${key()}`,
+            delta: str(data.delta),
+            at
+          }] : [];
+        case "session.reasoning.ended":
+          return id ? [{
+            type: "thinking",
+            id,
+            key: `r:${key()}`,
+            ...(str(data.text) !== undefined ? {
+              text: str(data.text)
+            } : {}),
+            done: true,
+            at
+          }] : [];
+        case "session.text.started":
+          return id ? [{
+            type: "reply",
+            id,
+            key: `t:${key()}`,
+            text: "",
+            at
+          }] : [];
+        case "session.text.delta":
+          return id && str(data.delta) ? [{
+            type: "reply",
+            id,
+            key: `t:${key()}`,
+            delta: str(data.delta),
+            at
+          }] : [];
+        case "session.text.ended":
+          return id ? [{
+            type: "reply",
+            id,
+            key: `t:${key()}`,
+            ...(str(data.text) !== undefined ? {
+              text: str(data.text)
+            } : {}),
+            done: true,
+            at
+          }] : [];
+        case "session.tool.input.started":
+          return id && str(data.id) ? [{
+            type: "tool",
+            id,
+            call: str(data.id),
+            ...(str(data.name) ? {
+              name: str(data.name)
+            } : {}),
+            state: "pending",
+            at
+          }] : [];
+        case "session.step.ended":
+          return id ? [{
+            type: "step",
+            id,
+            at
+          }] : [];
+        case "session.tool.called":
+          if (obj(data.input).background === true && str(data.id)) background.add(str(data.id));
+          return id && str(data.id) ? [{
+            type: "tool",
+            id,
+            call: str(data.id),
+            state: "running",
+            input: obj(data.input),
+            started: at,
+            at
+          }] : [];
+        case "session.tool.progress":
+          {
+            const metadata = obj(data.metadata);
+            const output = str(metadata.output);
+            const out = [];
+            if (id && str(data.id) && output !== undefined) out.push({
+              type: "tool",
+              id,
+              call: str(data.id),
+              output,
+              at
+            });
+            /** A background subagent's call names its child as it starts. */
+            const child = str(metadata.sessionID);
+            if (id && child && background.has(str(data.id) ?? "")) out.push({
+              type: "session",
+              id: child,
+              parentID: id,
+              background: true,
+              at
+            });
+            return out;
+          }
+        case "session.tool.success":
+          return id && str(data.id) ? [{
+            type: "tool",
+            id,
+            call: str(data.id),
+            state: "completed",
+            output: contentText(data.content),
+            ...(summaryOf(undefined, obj(data.metadata)) ? {
+              summary: summaryOf(undefined, obj(data.metadata))
+            } : {}),
+            at
+          }] : [];
+        case "session.tool.failed":
+          {
+            const error = str(obj(data.error).message) ?? str(data.error) ?? contentText(data.content) ?? "failed";
+            return id && str(data.id) ? [{
+              type: "tool",
+              id,
+              call: str(data.id),
+              state: "failed",
+              error,
+              at
+            }] : [];
+          }
+        /** The input streaming in; `session.tool.called` carries it whole. */
+        case "session.tool.input.delta":
+        case "session.tool.input.ended":
+          return [];
+        case "session.usage.updated":
+          return id ? [{
+            type: "usage",
+            id,
+            tokens: tokenTotal(obj(data.tokens)),
+            cost: Number(data.cost) || 0,
+            at
+          }] : [];
+        case "session.status":
+          return id ? statusChange(id, data.status, at) : [];
+        default:
+          // Deltas of kinds we do not draw, bookkeeping, and everything not about a session.
+          if (/^(session\.(inbox|step|instructions|compaction|revert|usage|permissions|model|agent|moved|synthetic|shell|skill|metadata|message|forked|retry|diff)|shell\.|skill\.|catalog\.|mcp\.|lsp\.|file\.|vcs\.|project\.|pty\.)/.test(name)) return [];
+          unknown("event", {
+            name
+          });
+          return [];
+      }
+    },
+    history(id, messages, at = Date.now()) {
+      const out = [];
+      /** A message's tokens are its own; the session's total is their sum (live events send the total). */
+      let tokens = 0;
+      let cost = 0;
+      let counted = false;
+      for (const raw of messages) {
+        const message = obj(raw);
+        const when = Number(obj(message.time).created) || at;
+        const mid = str(message.id) ?? `${when}`;
+        if (message.type === "user" && str(message.text)) {
+          out.push({
+            type: "prompt",
+            id,
+            key: mid,
+            text: str(message.text),
+            at: when
+          });
+          continue;
+        }
+        if (message.type !== "assistant") continue;
+        out.push({
+          type: "step",
+          id,
+          at: when
+        });
+        if (str(obj(message.model).id)) out.push({
+          type: "session",
+          id,
+          model: str(obj(message.model).id),
+          at: when
+        });
+        const content = Array.isArray(message.content) ? message.content : [];
+        /** Live events number thinking and text blocks separately; the keys must match across a reload. */
+        let thought = 0;
+        let wrote = 0;
+        for (const partRaw of content) {
+          const part = obj(partRaw);
+          const time = obj(part.time);
+          const partAt = Number(time.created) || when;
+          if (part.type === "reasoning") {
+            out.push({
+              type: "thinking",
+              id,
+              key: `r:${mid}:${thought++}`,
+              text: str(part.text) ?? "",
+              done: true,
+              at: partAt
+            });
+          } else if (part.type === "text") {
+            out.push({
+              type: "reply",
+              id,
+              key: `t:${mid}:${wrote++}`,
+              text: str(part.text) ?? "",
+              done: true,
+              at: partAt
+            });
+          } else if (part.type === "tool" && str(part.id)) {
+            const state = obj(part.state);
+            const status = str(state.status);
+            const ended = status === "completed" ? "completed" : status === "failed" || status === "error" ? "failed" : undefined;
+            out.push({
+              type: "tool",
+              id,
+              call: str(part.id),
+              ...(str(part.name) ? {
+                name: str(part.name)
+              } : {}),
+              state: "running",
+              input: obj(state.input),
+              started: Number(time.ran) || partAt,
+              at: partAt
+            });
+            /** A second change carries the ending, so the call keeps when it started and when it ended. */
+            if (ended) {
+              out.push({
+                type: "tool",
+                id,
+                call: str(part.id),
+                state: ended,
+                output: contentText(state.content),
+                ...(str(obj(state.error).message) ? {
+                  error: str(obj(state.error).message)
+                } : {}),
+                ...(summaryOf(str(part.name), obj(state.metadata)) ? {
+                  summary: summaryOf(str(part.name), obj(state.metadata))
+                } : {}),
+                ended: Number(time.completed) || partAt,
+                at: Number(time.completed) || partAt
+              });
+            }
+          }
+        }
+        if (Object.keys(obj(message.tokens)).length > 0) {
+          tokens += tokenTotal(obj(message.tokens));
+          cost += Number(message.cost) || 0;
+          counted = true;
+        }
+      }
+      if (counted) out.push({
+        type: "usage",
+        id,
+        tokens,
+        cost,
+        at
+      });
+      return out;
+    },
+    session(info, at = Date.now()) {
+      return sessionInfo(obj(info), at);
+    },
+    status(id, status, at = Date.now()) {
+      return statusChange(id, status, at);
+    }
+  };
+}

package/dist/core/model/changes.js

@@ -0,0 +1,17 @@
+/**
+ * What a subagent did, in one vocabulary for both OpenCodes.
+ *
+ * OpenCode 1 says it as `message.part.updated` / `message.part.delta` / `session.status`; OpenCode 2
+ * as `session.tool.called` / `session.reasoning.delta` / `session.execution.started`. The two
+ * adapters in `tui/data/` translate each into these changes, and everything after them — the model,
+ * the rows — is written once. Shapes measured from real runs (test/fixtures, docs/opencode/agents.md).
+ *
+ * `id` is always the session the change is about; a subagent *is* a session with a parent.
+ */
+
+/** OpenCode 2 starts every subagent's task with this line; the task is what follows it. */
+export const SUBAGENT_PREAMBLE = "You are a subagent spawned by another session.";
+export function taskText(text) {
+  const trimmed = text.startsWith(SUBAGENT_PREAMBLE) ? text.slice(SUBAGENT_PREAMBLE.length) : text;
+  return trimmed.trim();
+}

package/dist/core/model/model.js

@@ -0,0 +1,301 @@
+/**
+ * Subagents, built from changes. Pure: no OpenCode, no terminal — a test feeds it the changes a real
+ * run produced and checks what came out.
+ *
+ * Every session is kept, the conversation you are in included: a subagent is only "a subagent" in
+ * relation to the session it hangs under, and `subagentsOf` walks that from whichever conversation is
+ * on screen.
+ */
+
+import { taskText } from "./changes.js";
+export const emptyModel = () => ({
+  sessions: new Map()
+});
+function session(model, id, at) {
+  let found = model.sessions.get(id);
+  if (!found) {
+    found = {
+      id,
+      agent: "agent",
+      title: "",
+      status: "starting",
+      since: at,
+      started: at,
+      entries: [],
+      tokens: 0,
+      cost: 0,
+      denied: [],
+      steps: 0,
+      seen: at
+    };
+    model.sessions.set(id, found);
+  }
+  return found;
+}
+const findText = (s, kind, key) => s.entries.find(entry => entry.kind === kind && entry.key === key);
+const findTool = (s, call) => s.entries.find(entry => entry.kind === "tool" && entry.call === call);
+function applyStatus(s, change) {
+  if (change.status === "busy") {
+    s.status = "running";
+    delete s.ended;
+    delete s.error;
+  } else if (change.status === "waiting") {
+    s.status = "waiting";
+  } else if (change.status === "failed") {
+    s.status = "failed";
+    s.ended = change.at;
+    if (change.error) s.error = change.error;
+    settle(s, change.at);
+  } else if (s.status !== "failed") {
+    /** Idle before it ever worked is a session that has not started, not one that finished. */
+    s.status = s.status === "starting" && s.entries.length === 0 ? "starting" : "done";
+    s.ended = change.at;
+    settle(s, change.at);
+  }
+}
+
+/**
+ * A run that ended has no call still running: one left so was cut off (a stop, an abort) and never
+ * told us — without this its spinner turned forever, and the sidebar said it was still at it.
+ */
+function settle(s, at) {
+  for (const entry of s.entries) {
+    if (entry.kind === "tool" && (entry.state === "running" || entry.state === "pending")) {
+      entry.state = "failed";
+      entry.error ??= "stopped";
+      entry.ended = at;
+    }
+    if ((entry.kind === "thinking" || entry.kind === "reply") && !entry.done) entry.done = true;
+  }
+}
+
+/** Applies one change in place. Unknown sessions are created, so order never loses anything. */
+export function apply(model, change) {
+  const s = session(model, change.id, change.at);
+  if (change.at > s.seen) s.seen = change.at;
+  switch (change.type) {
+    case "session":
+      if (change.parentID) s.parentID = change.parentID;
+      if (change.agent) s.agent = change.agent;
+      if (change.title) s.title = change.title;
+      if (change.model) s.model = change.model;
+      if (change.background) s.background = true;
+      if (change.denied) s.denied = change.denied;
+      /** A session's own creation time beats when we first heard of it. */
+      if (change.at < s.started) s.started = change.at;
+      return;
+    case "step":
+      s.steps++;
+      return;
+    case "status":
+      {
+        const before = s.status;
+        applyStatus(s, change);
+        if (s.status !== before) s.since = change.at;
+        return;
+      }
+    case "prompt":
+      {
+        if (s.entries.some(entry => entry.kind === "prompt" && entry.key === change.key)) return;
+        const first = !s.entries.some(entry => entry.kind === "prompt");
+        const text = first ? taskText(change.text) : change.text.trim();
+        if (first) s.task = text;
+        s.entries.push({
+          kind: "prompt",
+          key: change.key,
+          text,
+          at: change.at,
+          first
+        });
+        return;
+      }
+    case "thinking":
+    case "reply":
+      {
+        let entry = findText(s, change.type, change.key);
+        if (!entry) {
+          const created = {
+            kind: change.type,
+            key: change.key,
+            text: "",
+            done: false,
+            at: change.at
+          };
+          s.entries.push(created);
+          entry = created;
+        }
+        if (change.text !== undefined) entry.text = change.text;else if (change.delta) entry.text += change.delta;
+        if (change.done) entry.done = true;
+        if (s.status === "starting") s.status = "running";
+        return;
+      }
+    case "tool":
+      {
+        let entry = findTool(s, change.call);
+        if (!entry) {
+          entry = {
+            kind: "tool",
+            call: change.call,
+            name: change.name ?? "tool",
+            state: "pending",
+            input: {},
+            output: "",
+            at: change.started ?? change.at
+          };
+          s.entries.push(entry);
+        }
+        if (change.started !== undefined) entry.at = change.started;
+        if (change.summary) entry.summary = change.summary;
+        if (change.name) entry.name = change.name;
+        if (change.state) entry.state = change.state;
+        if (change.input && Object.keys(change.input).length > 0) entry.input = change.input;
+        if (change.output !== undefined) entry.output = change.output;
+        if (change.error) entry.error = change.error;
+        if (change.state === "completed" || change.state === "failed") entry.ended = change.ended ?? change.at;
+        if (s.status === "starting") s.status = "running";
+        return;
+      }
+    case "usage":
+      if (change.tokens !== undefined) s.tokens = change.tokens;
+      if (change.cost !== undefined) s.cost = change.cost;
+      return;
+  }
+}
+export function applyAll(model, changes) {
+  for (const change of changes) apply(model, change);
+  return model;
+}
+
+// ---------------------------------------------------------------------------------------------------
+// What the views ask
+
+/** The subagents under `root`, depth first, oldest first at each level. */
+export function subagentsOf(model, root) {
+  const children = new Map();
+  for (const s of model.sessions.values()) {
+    if (!s.parentID) continue;
+    const list = children.get(s.parentID) ?? [];
+    list.push(s);
+    children.set(s.parentID, list);
+  }
+  const out = [];
+  const seen = new Set();
+  const walk = (parent, depth) => {
+    const list = (children.get(parent) ?? []).sort((a, b) => a.started - b.started);
+    for (const s of list) {
+      if (seen.has(s.id)) continue; // a cycle in parentage would otherwise never end
+      seen.add(s.id);
+      out.push({
+        session: s,
+        depth
+      });
+      walk(s.id, depth + 1);
+    }
+  };
+  walk(root, 0);
+  return out;
+}
+
+/** The conversation a session belongs to: up its parents to the one with none. */
+export function rootOf(model, id) {
+  let at = id;
+  for (let hop = 0; hop < 16; hop++) {
+    const parent = model.sessions.get(at)?.parentID;
+    if (!parent) return at;
+    at = parent;
+  }
+  return at;
+}
+const base = path => path.split("/").filter(Boolean).slice(-2).join("/");
+
+/** What a tool call is *about*, in a few words: the file, the pattern, the command. */
+export function toolTarget(name, input) {
+  const str = key => typeof input[key] === "string" ? input[key] : undefined;
+  const path = str("filePath") ?? str("path") ?? str("file");
+  switch (name) {
+    case "read":
+    case "write":
+    case "edit":
+    case "patch":
+    case "list":
+    case "ls":
+      return path ? base(path) : "";
+    case "grep":
+      return [str("pattern") ? `"${str("pattern")}"` : "", str("include") ?? (path ? base(path) : "")].filter(Boolean).join(" ");
+    case "glob":
+      return str("pattern") ?? "";
+    case "bash":
+    case "shell":
+      return (str("command") ?? "").replace(/\s+/g, " ").trim();
+    case "task":
+    case "subagent":
+      return str("description") ?? "";
+    case "webfetch":
+      return str("url") ?? "";
+    default:
+      {
+        const first = Object.values(input).find(value => typeof value === "string");
+        return first ? first.replace(/\s+/g, " ") : "";
+      }
+  }
+}
+/** What a subagent is doing right now — the line under its name in the sidebar. */
+export function activityOf(s) {
+  if (s.status === "failed") return {
+    kind: "failed",
+    text: s.error ?? "failed",
+    since: s.ended ?? s.started
+  };
+  if (s.status === "waiting") return {
+    kind: "waiting",
+    text: "waiting for permission",
+    since: s.since
+  };
+  const tools = s.entries.filter(entry => entry.kind === "tool");
+  if (s.status === "done") {
+    return {
+      kind: "done",
+      text: `${tools.length} tool${tools.length === 1 ? "" : "s"}`,
+      since: s.ended ?? s.started
+    };
+  }
+  const last = s.entries.at(-1);
+  const running = tools.filter(tool => tool.state === "running" || tool.state === "pending").at(-1);
+  if (running) return {
+    kind: "tool",
+    tool: running.name,
+    text: toolTarget(running.name, running.input),
+    since: running.at
+  };
+  if (last?.kind === "thinking" && !last.done) return {
+    kind: "thinking",
+    text: "thinking",
+    since: last.at
+  };
+  if (last?.kind === "reply" && !last.done) return {
+    kind: "writing",
+    text: "writing its answer",
+    since: last.at
+  };
+  if (s.status === "starting") return {
+    kind: "starting",
+    text: "starting",
+    since: s.started
+  };
+  return {
+    kind: "thinking",
+    text: "thinking",
+    since: last?.at ?? s.started
+  };
+}
+
+/** Counts for the block's heading. */
+export function countsOf(nodes) {
+  const of = test => nodes.filter(node => test(node.session)).length;
+  return {
+    total: nodes.length,
+    running: of(s => s.status === "running" || s.status === "starting" || s.status === "waiting"),
+    done: of(s => s.status === "done"),
+    failed: of(s => s.status === "failed")
+  };
+}