@pragma-sh/opencode-plugin 0.1.0-alpha.0

package/dist/index.mjs

@@ -0,0 +1,1277 @@
+// ../sdk/dist/index.js
+var PRAGMA_ENV_KEYS = {
+  gatewayUrl: "PRAGMA_GATEWAY_URL",
+  gatewayToken: "PRAGMA_GATEWAY_TOKEN",
+  tabId: "PRAGMA_TAB_ID",
+  worktreeId: "PRAGMA_WORKTREE_ID"
+};
+function readEnv(name, env) {
+  const globalProcess = globalThis.process;
+  return env?.[name] ?? globalProcess?.env?.[name];
+}
+function hasPragmaEnvironment(env) {
+  return Boolean(readEnv(PRAGMA_ENV_KEYS.gatewayUrl, env) && readEnv(PRAGMA_ENV_KEYS.gatewayToken, env) && readEnv(PRAGMA_ENV_KEYS.tabId, env) && readEnv(PRAGMA_ENV_KEYS.worktreeId, env));
+}
+var routes = {
+  health: "/v1/health",
+  version: "/v1/version",
+  rpc: (method) => `/v1/rpc/${encodeURIComponent(method)}`,
+  sessions: "/v1/sessions",
+  sessionEvents: (id) => `/v1/sessions/${encodeURIComponent(id)}/events`,
+  sessionInput: (id) => `/v1/sessions/${encodeURIComponent(id)}/input`,
+  sessionResize: (id) => `/v1/sessions/${encodeURIComponent(id)}/resize`,
+  session: (id) => `/v1/sessions/${encodeURIComponent(id)}`,
+  agentReports: "/v1/agents/reports",
+  agentMessages: "/v1/agents/messages",
+  agentAnswers: "/v1/agents/answers",
+  agentDecisions: "/v1/agents/decisions",
+  agentInputs: "/v1/agents/inputs",
+  agentInterrupts: "/v1/agents/interrupts",
+  agentCatalog: "/v1/agents/catalog",
+  agentEvents: "/v1/agents/events",
+  asset: (hash) => `/v1/assets/${encodeURIComponent(hash)}`,
+  theme: "/v1/theme",
+  scratchpads: "/v1/scratchpads",
+  agentsSeen: (tabId) => `/v1/tabs/${encodeURIComponent(tabId)}/agents/seen`,
+  subscription: (event) => `/v1/subscriptions/${encodeURIComponent(event)}`,
+  control: (method) => `/v1/control/${encodeURIComponent(method)}`,
+  pushTokens: "/v1/push/tokens",
+  pushTest: "/v1/push/test",
+  pushPresence: "/v1/push/presence"
+};
+
+class PragmaGatewayError extends Error {
+  code;
+  httpStatus;
+  details;
+  cause;
+  constructor(message, info) {
+    super(message, { cause: info.cause });
+    this.name = "PragmaGatewayError";
+    this.code = info.code;
+    this.httpStatus = info.httpStatus;
+    this.details = info.details;
+    this.cause = info.cause;
+  }
+}
+
+class PragmaTransportError extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "PragmaTransportError";
+    this.cause = cause;
+  }
+}
+async function* ndjsonStream(response, signal) {
+  if (!response.body) {
+    throw new PragmaTransportError("gateway response is not streamable");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let buffered = "";
+  const onAbort = () => {
+    reader.cancel();
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        return;
+      }
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffered += decoder.decode(value, { stream: true });
+      let newline = buffered.indexOf(`
+`);
+      while (newline >= 0) {
+        const line = buffered.slice(0, newline).trim();
+        buffered = buffered.slice(newline + 1);
+        if (line) {
+          yield JSON.parse(line);
+        }
+        newline = buffered.indexOf(`
+`);
+      }
+    }
+    buffered += decoder.decode();
+    if (buffered.trim()) {
+      yield JSON.parse(buffered);
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    await reader.cancel().catch(() => {
+      return;
+    });
+  }
+}
+
+class Transport {
+  baseUrl;
+  token;
+  fetch;
+  headers;
+  constructor(config = {}) {
+    const { baseUrl, token } = requireGatewayConfig(config);
+    this.baseUrl = baseUrl;
+    this.token = token;
+    this.fetch = requireFetch(config.fetch);
+    this.headers = config.headers ?? {};
+  }
+  async request(path, options = {}) {
+    const response = await this.raw(path, options);
+    if (response.status === 204 || response.status === 202) {
+      return;
+    }
+    return parseJson(response);
+  }
+  async raw(path, options = {}) {
+    const headers = {
+      ...this.headers,
+      ...options.headers,
+      authorization: `Bearer ${this.token}`
+    };
+    let body;
+    if (options.rawBody) {
+      body = options.rawBody;
+    } else if (options.body !== undefined) {
+      headers["content-type"] = headers["content-type"] ?? "application/json";
+      body = JSON.stringify(options.body);
+    }
+    let response;
+    try {
+      response = await this.fetch(urlFor(this.baseUrl, path), {
+        method: options.method ?? (body ? "POST" : "GET"),
+        headers,
+        body,
+        signal: options.signal
+      });
+    } catch (error) {
+      throw new PragmaTransportError("failed to reach Pragma gateway", error);
+    }
+    if (!response.ok) {
+      throw await gatewayError(response);
+    }
+    return response;
+  }
+}
+function requireGatewayConfig(config) {
+  const baseUrl = stripTrailingSlash(config.baseUrl ?? readEnv(PRAGMA_ENV_KEYS.gatewayUrl) ?? "");
+  const token = config.token ?? readEnv(PRAGMA_ENV_KEYS.gatewayToken) ?? "";
+  if (!baseUrl || !token) {
+    throw new PragmaTransportError("Pragma gateway baseUrl and token are required");
+  }
+  return { baseUrl, token };
+}
+function requireFetch(fetch) {
+  const resolved = fetch ?? globalThis.fetch?.bind(globalThis);
+  if (!resolved) {
+    throw new PragmaTransportError("global fetch is not available");
+  }
+  return resolved;
+}
+function urlFor(baseUrl, path) {
+  return `${stripTrailingSlash(baseUrl)}${path.startsWith("/") ? path : `/${path}`}`;
+}
+async function parseJson(response) {
+  try {
+    return await response.json();
+  } catch (error) {
+    throw new PragmaTransportError("gateway returned non-JSON response", error);
+  }
+}
+async function gatewayError(response) {
+  let body = {};
+  try {
+    body = await response.json();
+  } catch (error) {
+    throw new PragmaTransportError("gateway returned non-JSON error response", error);
+  }
+  return new PragmaGatewayError(body.message ?? `gateway returned ${response.status}`, {
+    code: body.code ?? "internal",
+    httpStatus: response.status,
+    details: body.details
+  });
+}
+function stripTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+
+class AgentsClient {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  report(payload, options = {}) {
+    return this.transport.request(routes.agentReports, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  reportMessage(payload, options = {}) {
+    return this.transport.request(routes.agentMessages, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  reportDecision(payload, options = {}) {
+    return this.transport.request(routes.agentDecisions, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  reportAnswer(payload, options = {}) {
+    return this.transport.request(routes.agentAnswers, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  reportInput(payload, options = {}) {
+    return this.transport.request(routes.agentInputs, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  reportInterrupt(payload, options = {}) {
+    return this.transport.request(routes.agentInterrupts, {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  reportStarted(options) {
+    return reportWithClient(this, options, "running", null);
+  }
+  reportStopped(options) {
+    return reportWithClient(this, options, "done", null);
+  }
+  reportAttention(options) {
+    return reportWithClient(this, options, "attention", options.kind ?? "question");
+  }
+  reportCleared(options) {
+    return reportWithClient(this, options, "cleared", null);
+  }
+  reportSessionName(options) {
+    return reportWithClient(this, options, null, null, options.name);
+  }
+  catalog(options = {}) {
+    return this.transport.request(routes.agentCatalog, {
+      method: "GET",
+      signal: options.signal
+    });
+  }
+  launch(payload, options = {}) {
+    return this.transport.request(routes.control("agentSessionLaunch"), {
+      method: "POST",
+      body: payload,
+      signal: options.signal
+    });
+  }
+  markAgentsSeen(payload, options = {}) {
+    return this.transport.request(routes.agentsSeen(payload.tabId), {
+      method: "POST",
+      body: {},
+      signal: options.signal
+    });
+  }
+  async connect(options) {
+    const { agent, tabId, worktreeId } = options;
+    const controller = new AbortController;
+    const onAbort = () => controller.abort();
+    options.signal?.addEventListener("abort", onAbort);
+    const readStream = this.readStream.bind(this);
+    async function* iterate() {
+      try {
+        for await (const event of readStream({ signal: controller.signal })) {
+          if (matchesAgentTab(event, agent, tabId)) {
+            yield event;
+          }
+        }
+      } finally {
+        options.signal?.removeEventListener("abort", onAbort);
+      }
+    }
+    const connection = {
+      [Symbol.asyncIterator]: iterate,
+      send: (text, sendOptions = {}) => this.reportInput({
+        agent,
+        worktreeId,
+        tabId,
+        text,
+        ...sendOptions.requestId ? { requestId: sendOptions.requestId } : {}
+      }, { signal: controller.signal }),
+      answer: (requestId, reply) => this.reportAnswer({
+        agent,
+        worktreeId,
+        tabId,
+        requestId,
+        dismissed: reply === null,
+        ...reply !== null ? { answer: reply } : {}
+      }, { signal: controller.signal }),
+      decide: (requestId, approved) => this.reportDecision({ agent, worktreeId, tabId, requestId, approved }, { signal: controller.signal }),
+      interrupt: (requestId) => this.reportInterrupt({
+        agent,
+        worktreeId,
+        tabId,
+        ...requestId ? { requestId } : {}
+      }, { signal: controller.signal }),
+      close: () => controller.abort()
+    };
+    if (options.prompt !== undefined) {
+      await connection.send(options.prompt);
+    }
+    return connection;
+  }
+  async* readStream(options = {}) {
+    const response = await this.transport.raw(routes.agentEvents, { signal: options.signal });
+    yield* ndjsonStream(response, options.signal);
+  }
+  async awaitDecision(params) {
+    const controller = new AbortController;
+    const onAbort = () => controller.abort();
+    params.signal?.addEventListener("abort", onAbort);
+    const timer = params.timeoutMs && params.timeoutMs > 0 ? setTimeout(() => controller.abort(), params.timeoutMs) : undefined;
+    try {
+      for await (const event of this.readStream({ signal: controller.signal })) {
+        if (event.type === "agentDecision" && event.decision.requestId === params.requestId && event.decision.agent === params.agent) {
+          return event.decision.approved;
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      params.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  async awaitAnswer(params) {
+    const controller = new AbortController;
+    const onAbort = () => controller.abort();
+    params.signal?.addEventListener("abort", onAbort);
+    const timer = params.timeoutMs && params.timeoutMs > 0 ? setTimeout(() => controller.abort(), params.timeoutMs) : undefined;
+    try {
+      for await (const event of this.readStream({ signal: controller.signal })) {
+        if (event.type === "agentAnswer" && event.answer.requestId === params.requestId && event.answer.agent === params.agent) {
+          return event.answer.dismissed ? null : event.answer.answer ?? "";
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      params.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+}
+function matchesAgentTab(event, agent, tabId) {
+  switch (event.type) {
+    case "agent":
+      return event.agent === agent && event.tabId === tabId;
+    case "agentMessage":
+      return event.message.agent === agent && event.message.tabId === tabId;
+    case "agentDecision":
+      return event.decision.agent === agent && event.decision.tabId === tabId;
+    case "agentAnswer":
+      return event.answer.agent === agent && event.answer.tabId === tabId;
+    case "agentInput":
+      return event.input.agent === agent && event.input.tabId === tabId;
+    case "agentInterrupt":
+      return event.interrupt.agent === agent && event.interrupt.tabId === tabId;
+  }
+}
+function reportStarted(options) {
+  return reportWithStatus(options, "running", null);
+}
+function reportStopped(options) {
+  return reportWithStatus(options, "done", null);
+}
+function reportAttention(options) {
+  return reportWithStatus(options, "attention", options.kind ?? "question");
+}
+function reportCleared(options) {
+  return reportWithStatus(options, "cleared", null);
+}
+function reportSessionName(options) {
+  return reportWithStatus(options, null, null, options.name);
+}
+async function reportMessage(options) {
+  if (!options.client && !hasPragmaEnvironment(options.env)) {
+    return;
+  }
+  const agents = options.client?.agents ?? new AgentsClient(new Transport({
+    baseUrl: readEnv(PRAGMA_ENV_KEYS.gatewayUrl, options.env),
+    token: readEnv(PRAGMA_ENV_KEYS.gatewayToken, options.env)
+  }));
+  await reportMessageWithClient(agents, options);
+}
+async function reportWithStatus(options, status, attentionKind, sessionName) {
+  if (!options.client && !hasPragmaEnvironment(options.env)) {
+    return;
+  }
+  const agents = options.client?.agents ?? new AgentsClient(new Transport({
+    baseUrl: readEnv(PRAGMA_ENV_KEYS.gatewayUrl, options.env),
+    token: readEnv(PRAGMA_ENV_KEYS.gatewayToken, options.env)
+  }));
+  await reportWithClient(agents, options, status, attentionKind, sessionName);
+}
+async function reportWithClient(agents, options, status, attentionKind, sessionName) {
+  const worktreeId = options.worktreeId ?? readEnv(PRAGMA_ENV_KEYS.worktreeId, options.env);
+  const tabId = readEnv(PRAGMA_ENV_KEYS.tabId, options.env);
+  if (!worktreeId || !tabId) {
+    return;
+  }
+  await agents.report(reportPayload(options, { worktreeId, tabId }, status, attentionKind, sessionName), { signal: options.signal });
+}
+function reportPayload(options, routing, status, attentionKind, sessionName) {
+  return {
+    agent: options.agent,
+    worktreeId: routing.worktreeId,
+    tabId: routing.tabId,
+    status,
+    attentionKind,
+    ...sessionName ? { sessionName } : {},
+    ...options.command ? { command: options.command } : {},
+    ...options.question ? { question: options.question } : {},
+    ...options.options && options.options.length > 0 ? { options: options.options } : {},
+    ...options.questions && options.questions.length > 0 ? { questions: options.questions } : {},
+    ...options.requestId ? { requestId: options.requestId } : {}
+  };
+}
+async function reportMessageWithClient(agents, options) {
+  const worktreeId = options.message.worktreeId ?? options.worktreeId ?? readEnv(PRAGMA_ENV_KEYS.worktreeId, options.env);
+  const tabId = options.message.tabId ?? readEnv(PRAGMA_ENV_KEYS.tabId, options.env);
+  if (!worktreeId || !tabId) {
+    return;
+  }
+  await agents.reportMessage({
+    ...options.message,
+    agent: options.message.agent ?? options.agent,
+    worktreeId,
+    tabId
+  }, { signal: options.signal });
+}
+
+// src/hooks.ts
+function messageTextKey(messageID, partID) {
+  return partID ? `${messageID}:${partID}` : messageID;
+}
+var CHAT_EVENT_TYPES = new Set(["message.updated", "message.part.updated", "message.part.delta"]);
+function sessionEventInfo(event) {
+  if (event.type !== "session.created" && event.type !== "session.updated") {
+    return null;
+  }
+  const properties = event.properties;
+  const info = isRecord(properties) && isRecord(properties.info) ? properties.info : null;
+  if (!info || typeof info.id !== "string") {
+    return null;
+  }
+  return {
+    id: info.id,
+    parentId: typeof info.parentID === "string" && info.parentID ? info.parentID : null,
+    title: sessionInfoTitle(info)
+  };
+}
+function sessionInfoTitle(info) {
+  const title = typeof info.title === "string" ? info.title.trim() : "";
+  return title || null;
+}
+var PRAGMA_ENV_KEYS2 = [
+  "PRAGMA_GATEWAY_URL",
+  "PRAGMA_GATEWAY_TOKEN",
+  "PRAGMA_DAEMON_SOCKET",
+  "PRAGMA_TAB_ID",
+  "PRAGMA_WORKTREE_ID"
+];
+function createPragmaOpencodeHooks(reporter) {
+  let busy = false;
+  let attention = false;
+  let attentionKind = "command";
+  let lastReported = null;
+  let reportQueue = Promise.resolve();
+  const messageRoles = new Map;
+  const partTypes = new Map;
+  const messageText = new Map;
+  const childSessions = new Map;
+  const activeChildSessions = new Set;
+  let pendingLegacyQuestion = null;
+  const EVENT_HANDLERS = {
+    "session.status": applySessionStatusEvent,
+    "session.idle": applySessionIdleEvent,
+    "session.error": applySessionErrorEvent,
+    "session.deleted": applySessionDeletedEvent,
+    "server.instance.disposed": () => "clear",
+    "permission.replied": applyPermissionRepliedEvent,
+    "question.replied": applyQuestionRepliedEvent,
+    "question.rejected": applyQuestionRepliedEvent,
+    "message.updated": applyMessageUpdatedEvent,
+    "message.part.updated": applyMessagePartEvent
+  };
+  const chatContentHandlers = {
+    "message.updated": async (event) => {
+      rememberMessageRole(event);
+    },
+    "message.part.delta": reportChatDelta,
+    "message.part.updated": reportUpdatedPart
+  };
+  let lastSessionName = null;
+  async function handleChildSessionEvent(event) {
+    if (!isChildSessionEvent(event)) {
+      return false;
+    }
+    const parentId = childSessions.get(sessionIdFromEvent(event) ?? "");
+    if (applyChildSessionEvent(event)) {
+      await reportSubagentActivity(parentId);
+      await sync();
+    }
+    return true;
+  }
+  async function handlePermissionEvent(event) {
+    if (event.type !== "permission.asked" && event.type !== "permission.updated") {
+      return false;
+    }
+    await raiseCommandApproval(event);
+    return true;
+  }
+  async function handleQuestionAskedEvent(event) {
+    if (event.type !== "question.asked") {
+      return false;
+    }
+    cancelPendingLegacyQuestion();
+    await raiseQuestionAttention(isRecord(event.properties) ? event.properties : {}, questionRequestId(event));
+    return true;
+  }
+  async function handleConsumingEvent(event) {
+    return await handleChildSessionEvent(event) || await handlePermissionEvent(event) || await handleQuestionAskedEvent(event);
+  }
+  async function reportChatAndApplyStatus(event) {
+    if (CHAT_EVENT_TYPES.has(event.type)) {
+      await reportChatContent(event);
+    }
+    const action = applyEvent(event);
+    if (action === "clear") {
+      await clear();
+    } else if (action === "sync") {
+      await sync();
+    }
+  }
+  return {
+    event: async ({ event }) => {
+      const runtimeEvent = event;
+      rememberSessionKind(runtimeEvent);
+      await maybeReportSessionName(runtimeEvent);
+      if (await handleConsumingEvent(runtimeEvent)) {
+        return;
+      }
+      await reportChatAndApplyStatus(runtimeEvent);
+    },
+    "chat.message": async (_input, output) => {
+      if (isChildSessionId(_input.sessionID)) {
+        return;
+      }
+      busy = true;
+      const text = textFromParts(output.parts) ?? textFromRecord(output.message);
+      await queueReport(() => reporter.message({
+        id: messageId("chat"),
+        role: "user",
+        ...text ? { text } : {},
+        subAgentsActive: 0,
+        ts: Date.now()
+      }));
+      await sync();
+    },
+    "command.execute.before": async (input) => {
+      if (isChildSessionId(input.sessionID)) {
+        return;
+      }
+      busy = true;
+      await queueReport(() => reporter.message(toolMessage("command", summaryFromRecord(input))));
+      await sync();
+    },
+    "tool.execute.before": async (input, output) => {
+      if (isChildSessionId(input.sessionID)) {
+        return;
+      }
+      const args = isRecord(output?.args) ? output.args : {};
+      if (input.tool === "question") {
+        scheduleLegacyQuestionAttention(args, typeof input.callID === "string" ? `opencode-question-${input.callID}` : undefined);
+        const parsed = parseQuestionArgs(args);
+        await queueReport(() => reporter.message(toolMessage("question", parsed?.[0]?.question ?? "Waiting for an answer")));
+        return;
+      }
+      busy = true;
+      await queueReport(() => reporter.message(toolMessage(input.tool, toolSummary(input.tool, args))));
+      await sync();
+    },
+    "permission.ask": async (input) => {
+      if (isRecord(input) && isChildSessionId(input.sessionID)) {
+        return;
+      }
+      await raiseCommandApproval(input);
+    },
+    "shell.env": async (_input, output) => {
+      for (const key of PRAGMA_ENV_KEYS2) {
+        const value = reporter.env[key];
+        if (value) {
+          output.env[key] = value;
+        }
+      }
+    },
+    dispose: async () => {
+      await clear();
+    }
+  };
+  function rememberSessionKind(event) {
+    const info = sessionEventInfo(event);
+    if (!info?.parentId) {
+      return;
+    }
+    childSessions.set(info.id, info.parentId);
+    if (event.type === "session.created") {
+      activeChildSessions.add(info.id);
+      busy = true;
+    }
+  }
+  async function maybeReportSessionName(event) {
+    const info = sessionEventInfo(event);
+    if (!info || childSessions.has(info.id)) {
+      return;
+    }
+    if (!info.title || info.title === lastSessionName) {
+      return;
+    }
+    lastSessionName = info.title;
+    await reporter.sessionName(info.title);
+  }
+  function applyChildSessionEvent(event) {
+    const sessionId = sessionIdFromEvent(event);
+    if (!sessionId) {
+      return false;
+    }
+    if (event.type === "session.created") {
+      activeChildSessions.add(sessionId);
+      busy = true;
+      return true;
+    }
+    if (event.type === "session.status") {
+      applyChildStatusEvent(sessionId, event);
+      return true;
+    }
+    if (event.type === "session.idle" || event.type === "session.error" || event.type === "session.deleted") {
+      activeChildSessions.delete(sessionId);
+      if (event.type === "session.deleted") {
+        childSessions.delete(sessionId);
+      }
+      return true;
+    }
+    return false;
+  }
+  function applyChildStatusEvent(sessionId, event) {
+    const properties = isRecord(event.properties) ? event.properties : undefined;
+    const status = properties?.status;
+    if (isRecord(status) && status.type === "idle") {
+      activeChildSessions.delete(sessionId);
+    } else {
+      activeChildSessions.add(sessionId);
+      busy = true;
+    }
+  }
+  function isChildSessionEvent(event) {
+    return isChildSessionId(sessionIdFromEvent(event));
+  }
+  function isChildSessionId(sessionId) {
+    return typeof sessionId === "string" && childSessions.has(sessionId);
+  }
+  async function clear() {
+    cancelPendingLegacyQuestion();
+    busy = false;
+    attention = false;
+    childSessions.clear();
+    activeChildSessions.clear();
+    if (lastReported === "cleared") {
+      return;
+    }
+    lastReported = "cleared";
+    await queueReport(() => reporter.cleared());
+  }
+  function currentReport() {
+    if (attention) {
+      return `attention:${attentionKind}`;
+    }
+    if (busy) {
+      return "started";
+    }
+    return "stopped";
+  }
+  async function sync() {
+    const next = currentReport();
+    if (next === lastReported) {
+      return;
+    }
+    if (next === "stopped" && lastReported !== "started") {
+      return;
+    }
+    lastReported = next;
+    if (next === "started") {
+      await queueReport(() => reporter.started());
+    } else if (next === "stopped") {
+      await queueReport(() => reporter.stopped());
+    } else {
+      await queueReport(() => reporter.attention(attentionKind));
+    }
+  }
+  function queueReport(send) {
+    const pending = reportQueue.then(send);
+    reportQueue = pending.catch(() => {
+      return;
+    });
+    return pending;
+  }
+  function applyEvent(event) {
+    const handler = EVENT_HANDLERS[event.type];
+    return handler ? handler(event) : "none";
+  }
+  function applySessionStatusEvent(event) {
+    applySessionStatus(event);
+    return "sync";
+  }
+  function applySessionIdleEvent(event) {
+    const sessionId = sessionIdFromEvent(event);
+    busy = hasActiveChildren(sessionId);
+    return "sync";
+  }
+  function applySessionErrorEvent(event) {
+    if (isAbortError(event)) {
+      return "clear";
+    }
+    busy = false;
+    attention = false;
+    removeChildren(sessionIdFromEvent(event));
+    return "sync";
+  }
+  function applySessionDeletedEvent(event) {
+    busy = false;
+    attention = false;
+    removeChildren(sessionIdFromEvent(event));
+    return "sync";
+  }
+  function hasActiveChildren(parentId) {
+    for (const childId of activeChildSessions) {
+      if (!parentId || childSessions.get(childId) === parentId) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function removeChildren(parentId) {
+    if (!parentId) {
+      return;
+    }
+    for (const [childId, childParentId] of childSessions) {
+      if (childParentId === parentId) {
+        childSessions.delete(childId);
+        activeChildSessions.delete(childId);
+      }
+    }
+  }
+  async function raiseCommandApproval(source) {
+    attention = true;
+    attentionKind = "command";
+    lastReported = "attention:command";
+    await queueReport(() => reporter.attentionCommand(commandFromPermission(source), permissionRequestId()));
+  }
+  async function raiseQuestionAttention(args, requestId) {
+    const parsed = parseQuestionArgs(args);
+    if (!parsed || parsed.length === 0) {
+      return;
+    }
+    attention = true;
+    attentionKind = "question";
+    lastReported = "attention:question";
+    const requestIdResolved = requestId ?? permissionRequestId();
+    await queueReport(() => {
+      if (parsed.length === 1 && parsed[0]) {
+        return reporter.attentionQuestion(parsed[0].question, parsed[0].options, requestIdResolved);
+      }
+      return reporter.attentionQuestions(parsed.map((item) => ({ question: item.question, options: item.options })), requestIdResolved);
+    });
+  }
+  function applyPermissionRepliedEvent() {
+    attention = false;
+    busy = true;
+    return "sync";
+  }
+  function applyQuestionRepliedEvent() {
+    cancelPendingLegacyQuestion();
+    attention = false;
+    busy = true;
+    return "sync";
+  }
+  function applyMessageUpdatedEvent(event) {
+    rememberMessageRole(event);
+    return "none";
+  }
+  function applyMessagePartEvent(event) {
+    return applyQuestionPart(event) ? "sync" : "none";
+  }
+  async function reportSubagentActivity(parentId) {
+    if (!parentId)
+      return;
+    let active = 0;
+    for (const childId of activeChildSessions) {
+      if (childSessions.get(childId) === parentId)
+        active += 1;
+    }
+    await queueReport(() => reporter.message({
+      id: `subagents:${parentId}`,
+      role: "system",
+      subAgentsActive: active,
+      ts: Date.now()
+    }));
+  }
+  async function reportChatContent(event) {
+    const handler = chatContentHandlers[event.type];
+    if (handler)
+      await handler(event);
+  }
+  async function reportUpdatedPart(event) {
+    const part = partFromEvent(event);
+    if (!part) {
+      return;
+    }
+    rememberPartType(part);
+    const details = assistantTextPart(part);
+    if (!details || messageRoles.get(details.messageID) === "user") {
+      return;
+    }
+    const key = messageTextKey(details.messageID, details.partID);
+    messageText.set(key, details.text);
+    await reportAssistantText(details.messageID, details.text, details.partType, details.partID);
+  }
+  function rememberPartType(part) {
+    const partID = typeof part.id === "string" ? part.id : undefined;
+    const partType = typeof part.type === "string" ? part.type : undefined;
+    if (partID && partType)
+      partTypes.set(partID, partType);
+  }
+  async function reportChatDelta(event) {
+    const delta = chatDelta(event, messageRoles);
+    if (!delta) {
+      return;
+    }
+    const key = messageTextKey(delta.messageID, delta.partID);
+    const text = `${messageText.get(key) ?? ""}${delta.text}`;
+    messageText.set(key, text);
+    await reportAssistantText(delta.messageID, text, delta.partID ? partTypes.get(delta.partID) : undefined, delta.partID);
+  }
+  async function reportAssistantText(messageID, text, partType, partID) {
+    const isReasoning = partType === "reasoning";
+    await queueReport(() => reporter.message({
+      id: isReasoning ? `reasoning:${messageID}:${partID ?? "part"}` : `assistant:${messageID}`,
+      role: isReasoning ? "system" : "assistant",
+      text,
+      subAgentsActive: 0,
+      ts: Date.now()
+    }));
+  }
+  function rememberMessageRole(event) {
+    const properties = event.properties;
+    const info = properties?.info;
+    if (!isRecord(info) || typeof info.id !== "string") {
+      return;
+    }
+    if (info.role === "user" || info.role === "assistant") {
+      messageRoles.set(info.id, info.role);
+    }
+  }
+  function isAbortError(event) {
+    const error = event.properties?.error;
+    return isRecord(error) && error.name === "MessageAbortedError";
+  }
+  function applySessionStatus(event) {
+    const status = event.properties?.status;
+    busy = !(isRecord(status) && status.type === "idle");
+  }
+  function applyQuestionPart(event) {
+    const part = partFromEvent(event);
+    if (!part || part.type !== "tool" || part.tool !== "question") {
+      return false;
+    }
+    applyQuestionPartState(part);
+    return true;
+  }
+  function partFromEvent(event) {
+    const properties = event.properties;
+    const part = isRecord(properties) && "part" in properties ? properties.part : undefined;
+    return isRecord(part) ? part : undefined;
+  }
+  function applyQuestionPartState(part) {
+    const state = isRecord(part.state) ? part.state : undefined;
+    if (questionPartFinished(state)) {
+      cancelPendingLegacyQuestion();
+      attention = false;
+      busy = true;
+      return;
+    }
+    const input = questionPartInput(state, part);
+    if (input) {
+      scheduleLegacyQuestionAttention(input, typeof part.callID === "string" ? `opencode-question-${part.callID}` : undefined);
+    }
+  }
+  function scheduleLegacyQuestionAttention(args, requestId) {
+    cancelPendingLegacyQuestion();
+    pendingLegacyQuestion = setTimeout(() => {
+      pendingLegacyQuestion = null;
+      raiseQuestionAttention(args, requestId).catch(() => {
+        return;
+      });
+    }, 50);
+  }
+  function cancelPendingLegacyQuestion() {
+    if (pendingLegacyQuestion !== null) {
+      clearTimeout(pendingLegacyQuestion);
+      pendingLegacyQuestion = null;
+    }
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function sessionIdFromEvent(event) {
+  if (!isRecord(event.properties)) {
+    return;
+  }
+  const properties = event.properties;
+  if (typeof properties.sessionID === "string") {
+    return properties.sessionID;
+  }
+  for (const key of ["info", "part", "permission"]) {
+    const nested = properties[key];
+    if (isRecord(nested) && typeof nested.sessionID === "string") {
+      return nested.sessionID;
+    }
+    if (key === "info" && isRecord(nested) && typeof nested.id === "string") {
+      return nested.id;
+    }
+  }
+  return;
+}
+function assistantTextPart(part) {
+  const partType = typeof part.type === "string" ? part.type : undefined;
+  if (partType !== "text" && partType !== "reasoning")
+    return;
+  const messageID = typeof part.messageID === "string" ? part.messageID : undefined;
+  const text = typeof part.text === "string" ? part.text.trim() : "";
+  if (!messageID || !text)
+    return;
+  return {
+    messageID,
+    partID: typeof part.id === "string" ? part.id : undefined,
+    partType,
+    text
+  };
+}
+function chatDelta(event, messageRoles) {
+  const properties = event.properties;
+  if (!isRecord(properties) || !isTextDelta(properties)) {
+    return;
+  }
+  const messageID = typeof properties.messageID === "string" ? properties.messageID : undefined;
+  if (!messageID || messageRoles.get(messageID) === "user") {
+    return;
+  }
+  return {
+    messageID,
+    partID: typeof properties.partID === "string" ? properties.partID : undefined,
+    text: properties.delta
+  };
+}
+function isTextDelta(properties) {
+  return (properties.field === undefined || properties.field === "text") && typeof properties.delta === "string" && properties.delta.length > 0;
+}
+function questionPartFinished(state) {
+  return state?.status === "completed" || state?.status === "error";
+}
+function questionPartInput(state, part) {
+  return isRecord(state?.input) ? state.input : isRecord(part.input) ? part.input : undefined;
+}
+function questionRequestId(event) {
+  const properties = event.properties;
+  return isRecord(properties) && typeof properties.id === "string" ? properties.id : undefined;
+}
+function permissionRequestId() {
+  return `opencode-${globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random()}`}`;
+}
+function commandFromPermission(source) {
+  const permission = unwrapPermission(source);
+  const metadata = isRecord(permission.metadata) ? permission.metadata : {};
+  const command = firstNestedString(permission, ["command", "cmd", "script", "shell"]);
+  if (command) {
+    return command;
+  }
+  const filePath = firstNestedString(permission, ["filePath", "filepath", "path", "file"]);
+  if (filePath) {
+    const verb = fileToolVerb(firstString(permission.type, permission.pattern, metadata.tool));
+    return verb ? `${verb} ${filePath}` : filePath;
+  }
+  return firstNestedString(permission, ["url", "uri"]) ?? firstString(permission.title, metadata.title, permission.description, metadata.description, permission.pattern, permission.type) ?? "Run a command";
+}
+function unwrapPermission(source) {
+  const outer = isRecord(source) ? source : {};
+  const inner = isRecord(outer.properties) ? outer.properties : outer;
+  return isRecord(inner.permission) ? inner.permission : inner;
+}
+function fileToolVerb(type) {
+  switch (type?.toLowerCase()) {
+    case "read":
+      return "Read";
+    case "write":
+      return "Write";
+    case "edit":
+    case "patch":
+      return "Edit";
+    default:
+      return;
+  }
+}
+function firstString(...candidates) {
+  for (const candidate of candidates) {
+    const value = stringValue(candidate);
+    if (value) {
+      return value;
+    }
+  }
+  return;
+}
+function firstNestedString(source, keys) {
+  return findNestedString(source, new Set(keys.map((key) => key.toLowerCase())), 4, new Set);
+}
+function findNestedString(value, keys, depth, seen) {
+  if (!isRecord(value) || depth < 0 || seen.has(value)) {
+    return;
+  }
+  seen.add(value);
+  for (const [key, candidate] of Object.entries(value)) {
+    if (keys.has(key.toLowerCase())) {
+      const match = stringValue(candidate);
+      if (match) {
+        return match;
+      }
+    }
+  }
+  for (const candidate of Object.values(value)) {
+    const match = findNestedString(candidate, keys, depth - 1, seen);
+    if (match) {
+      return match;
+    }
+  }
+  return;
+}
+function stringValue(value) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+    const joined = value.join(" ").trim();
+    return joined || undefined;
+  }
+  return;
+}
+function toolMessage(name, summary) {
+  const id = messageId(`tool:${name}`);
+  return {
+    id,
+    role: "tool",
+    toolCalls: [{ id, name, status: "running", ...summary ? { summary } : {} }],
+    subAgentsActive: /(?:task|agent)/i.test(name) ? 1 : 0,
+    ts: Date.now()
+  };
+}
+function messageId(prefix) {
+  return `${prefix}:${globalThis.crypto?.randomUUID?.() ?? `${Date.now()}:${Math.random()}`}`;
+}
+function summaryFromRecord(record) {
+  return textFromRecord(record) ?? compactJson(record);
+}
+function toolSummary(tool, args) {
+  return TOOL_SUMMARIES[tool.toLowerCase()]?.(args) ?? summaryFromRecord(args);
+}
+var TOOL_SUMMARIES = {
+  bash: commandSummary,
+  shell: commandSummary,
+  read: pathSummary,
+  write: pathSummary,
+  edit: pathSummary,
+  apply_patch: pathSummary,
+  patch: pathSummary,
+  grep: grepSummary,
+  glob: (args) => firstString(args.pattern, args.glob, args.path),
+  webfetch: (args) => firstString(args.url, args.uri),
+  fetch: (args) => firstString(args.url, args.uri),
+  websearch: (args) => firstString(args.query, args.q, args.search),
+  search: (args) => firstString(args.query, args.q, args.search),
+  todowrite: () => "Updating todos",
+  todo: () => "Updating todos",
+  task: taskSummary,
+  agent: taskSummary
+};
+function commandSummary(args) {
+  return firstString(args.command, args.cmd, args.script);
+}
+function pathSummary(args) {
+  return firstString(args.filePath, args.filepath, args.path, args.file);
+}
+function grepSummary(args) {
+  return firstString(args.pattern, args.query, args.regex) ?? firstString(args.path, args.include);
+}
+function taskSummary(args) {
+  return firstString(args.description, args.prompt, args.text) ?? "Spawning sub-agent";
+}
+function parseQuestionArgs(args) {
+  const questions = Array.isArray(args.questions) ? args.questions : undefined;
+  if (!questions || questions.length === 0) {
+    const single = questionPromptFrom(args);
+    return single ? [single] : undefined;
+  }
+  const parsed = questions.flatMap((item) => {
+    const question = isRecord(item) ? questionPromptFrom(item) : undefined;
+    return question ? [question] : [];
+  });
+  return parsed.length > 0 ? parsed : undefined;
+}
+function questionPromptFrom(record) {
+  const question = firstString(record.question, record.header, record.text, record.message, record.prompt) ?? undefined;
+  if (!question) {
+    return;
+  }
+  const options = questionOptions(record.options);
+  return { question, options };
+}
+function questionOptions(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const options = [];
+  for (const item of value) {
+    if (typeof item === "string" && item.trim()) {
+      options.push({ label: item.trim() });
+      continue;
+    }
+    if (!isRecord(item)) {
+      continue;
+    }
+    const label = firstString(item.label, item.text, item.value, item.name, item.description);
+    if (label) {
+      const description = firstString(item.description);
+      options.push({ label, ...description && description !== label ? { description } : {} });
+    }
+  }
+  return options;
+}
+function textFromRecord(record) {
+  for (const key of ["text", "message", "command", "description", "summary"]) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return;
+}
+function textFromParts(parts) {
+  if (!Array.isArray(parts)) {
+    return;
+  }
+  const chunks = [];
+  for (const part of parts) {
+    if (!isRecord(part) || part.type !== "text") {
+      continue;
+    }
+    if (typeof part.text === "string" && part.text.trim()) {
+      chunks.push(part.text.trim());
+    }
+  }
+  return chunks.length > 0 ? chunks.join(`
+`) : undefined;
+}
+function compactJson(value) {
+  try {
+    const json = JSON.stringify(value);
+    return json.length > 240 ? `${json.slice(0, 237)}...` : json;
+  } catch {
+    return;
+  }
+}
+
+// src/index.ts
+var DEFAULT_AGENT_ID = "opencode";
+var PragmaOpencodePlugin = async (_input, options) => {
+  const reporter = createSdkReporter(parseOptions(options));
+  reporter.cleared();
+  return createPragmaOpencodeHooks(reporter);
+};
+var src_default = PragmaOpencodePlugin;
+function parseOptions(options) {
+  return options ?? {};
+}
+function createSdkReporter(options) {
+  const agent = nonEmpty(options.agent) ?? DEFAULT_AGENT_ID;
+  const env = { ...process.env, ...options.env };
+  const debug = options.quiet === true ? false : env.PRAGMA_OPENCODE_PLUGIN_DEBUG === "1";
+  return {
+    env,
+    started: () => report(() => reportStarted({ agent, env })),
+    stopped: () => report(() => reportStopped({ agent, env })),
+    attention: (kind) => report(() => reportAttention({ agent, env, kind })),
+    attentionCommand: (command, requestId) => report(() => reportAttention({ agent, env, kind: "command", command, requestId })),
+    attentionQuestion: (question, questionOptions2, requestId) => report(() => reportAttention({
+      agent,
+      env,
+      kind: "question",
+      question,
+      ...questionOptions2.length > 0 ? { options: questionOptions2 } : {},
+      requestId
+    })),
+    attentionQuestions: (questions, requestId) => report(() => reportAttention({
+      agent,
+      env,
+      kind: "question",
+      ...questions.length > 0 ? { questions } : {},
+      requestId
+    })),
+    message: (message) => report(() => reportMessage({ agent, env, message })),
+    cleared: () => report(() => reportCleared({ agent, env })),
+    sessionName: (name) => report(() => reportSessionName({ agent, env, name }))
+  };
+  async function report(run) {
+    if (!hasPragmaEnvironment(env)) {
+      return;
+    }
+    try {
+      await run();
+    } catch (error) {
+      if (debug) {
+        console.warn("@pragma-sh/opencode-plugin failed to report status", error);
+      }
+    }
+  }
+}
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+export {
+  src_default as default,
+  PragmaOpencodePlugin
+};