@anyforge/control 0.13.0 → 0.14.0

package/dist/opencode-plugin.js

@@ -150,19 +150,55 @@ function attr(key, value) {
 function sanitize(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
+function mcpPrefixesOf(server2) {
+  return [.../* @__PURE__ */ new Set([`${sanitize(server2)}_`, `${server2}_`, `${server2}.`, `${server2}/`, `${server2}:`])];
+}
+var BUILTIN_TOOLS = /* @__PURE__ */ new Set([
+  "bash",
+  "read",
+  "write",
+  "edit",
+  "multiedit",
+  "patch",
+  "apply_patch",
+  "glob",
+  "grep",
+  "list",
+  "ls",
+  "webfetch",
+  "websearch",
+  "codesearch",
+  "todowrite",
+  "todoread",
+  "task",
+  "skill",
+  "lsp",
+  "question",
+  "batch",
+  "invalid",
+  "external_directory",
+  "doom_loop"
+]);
+var UNNAMED_TOOL = "other_tool";
+var STOPPED_ERROR = /abort|cancel|interrupt/i;
 var TOOL_NAME = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,99}$/;
 var OpencodeTelemetry = class {
   constructor(options) {
     this.options = options;
-    this.mcpPrefixes = options.mcpServers.map((server) => ({ server, prefix: `${sanitize(server)}_` })).sort((a, b) => b.prefix.length - a.prefix.length);
+    this.setMcpServers(options.mcpServers);
   }
   options;
-  mcpPrefixes;
+  mcpPrefixes = [];
   models = new Remembered();
   callTools = new Remembered();
   permissionTools = new Remembered();
   reported = new Remembered();
+  toolStarts = new Remembered();
   proxiedProviders = /* @__PURE__ */ new Set();
+  /** The configured MCP servers, which V2 reports after the plugin has started. */
+  setMcpServers(servers) {
+    this.mcpPrefixes = servers.flatMap((server2) => mcpPrefixesOf(server2).map((prefix) => ({ server: server2, prefix }))).sort((a, b) => b.prefix.length - a.prefix.length);
+  }
   /** `chat.message`: the member sent a prompt. Its text is never read. */
   prompt(nowMs) {
     return { logs: [this.record("user_prompt", nowMs, [])], usage: [] };
@@ -225,14 +261,24 @@ var OpencodeTelemetry = class {
     if (part.type === "tool") return this.tool(part, id, nowMs);
     return EMPTY;
   }
-  /** One finished model call: an `api_request`, and its tokens unless the proxy metered them. */
+  /** One finished model call (V1 `step-finish` part). */
   step(part, id, nowMs) {
-    if (this.reported.has(`step:${id}`)) return EMPTY;
-    this.reported.set(`step:${id}`, true);
-    const model = this.models.get(str(part.messageID) ?? "");
-    const logs = [this.record("api_request", nowMs, model ? [attr("model", model.modelID)] : [])];
-    if (model && this.proxiedProviders.has(model.providerID)) return { logs, usage: [] };
-    const tokens = isRecord(part.tokens) ? part.tokens : {};
+    return this.modelCall(`step:${id}`, str(part.messageID), part.tokens, part.cost, "api_request", nowMs);
+  }
+  /**
+   * One model call: an `api_request` (or `api_error`) and its tokens, unless
+   * the AnyForge proxy already metered them. Reported once per key.
+   */
+  modelCall(key, messageID, rawTokens, cost, event, nowMs) {
+    if (this.reported.has(key)) return EMPTY;
+    this.reported.set(key, true);
+    const model = this.models.get(messageID ?? "");
+    const logs = [this.record(event, nowMs, model ? [attr("model", model.modelID)] : [])];
+    return { logs, usage: this.usage(model, rawTokens, cost) };
+  }
+  usage(model, rawTokens, cost) {
+    if (model && this.proxiedProviders.has(model.providerID)) return [];
+    const tokens = isRecord(rawTokens) ? rawTokens : {};
     const cache = isRecord(tokens.cache) ? tokens.cache : {};
     const reading = {
       model: model?.modelID ?? "unknown",
@@ -241,10 +287,85 @@ var OpencodeTelemetry = class {
       output: num(tokens.output) + num(tokens.reasoning),
       cacheRead: num(cache.read),
       cacheWrite: num(cache.write),
-      costUsd: num(part.cost)
+      costUsd: num(cost)
     };
     const any = reading.input + reading.output + reading.cacheRead + reading.cacheWrite + reading.costUsd > 0;
-    return { logs, usage: any ? [reading] : [] };
+    return any ? [reading] : [];
+  }
+  // ── OpenCode V2 ──────────────────────────────────────────────────────────
+  /** One V2 session or permission event, `{ id, type, data }`. */
+  eventV2(event, nowMs) {
+    if (!isRecord(event) || !isRecord(event.data)) return EMPTY;
+    const data = event.data;
+    const eventId = str(event.id);
+    switch (event.type) {
+      case "session.inbox.enqueued": {
+        const inboxID = str(data.inboxID);
+        if (!isRecord(data.item) || data.item.type !== "user" || !inboxID || this.reported.has(`prompt:${inboxID}`)) return EMPTY;
+        this.reported.set(`prompt:${inboxID}`, true);
+        return this.prompt(nowMs);
+      }
+      case "session.step.started": {
+        const messageID = str(data.assistantMessageID);
+        const model = isRecord(data.model) ? data.model : {};
+        const modelID = str(model.id);
+        const providerID = str(model.providerID);
+        if (messageID && modelID && providerID) this.models.set(messageID, { modelID, providerID });
+        return EMPTY;
+      }
+      case "session.step.ended":
+        if (!eventId) return EMPTY;
+        return this.modelCall(`step2:${eventId}`, str(data.assistantMessageID), data.tokens, data.cost, "api_request", nowMs);
+      case "session.step.failed": {
+        if (!eventId) return EMPTY;
+        const error = isRecord(data.error) ? data.error : {};
+        if (STOPPED_ERROR.test(str(error.type) ?? "")) {
+          this.reported.set(`step2:${eventId}`, true);
+          return { logs: [], usage: this.usage(this.models.get(str(data.assistantMessageID) ?? ""), data.tokens, data.cost) };
+        }
+        return this.modelCall(`step2:${eventId}`, str(data.assistantMessageID), data.tokens, data.cost, "api_error", nowMs);
+      }
+      case "session.skill.activated": {
+        if (!eventId || this.reported.has(`skill:${eventId}`)) return EMPTY;
+        this.reported.set(`skill:${eventId}`, true);
+        return { logs: [this.record("skill_activated", nowMs, [attr("skill.name", this.skillName({ name: data.name }))])], usage: [] };
+      }
+      case "permission.asked": {
+        const source = isRecord(data.source) ? data.source : {};
+        this.notePermission(str(data.id), str(source.id), str(data.action));
+        return EMPTY;
+      }
+      case "permission.replied":
+        return this.decision(str(data.requestID), str(data.reply), nowMs);
+      default:
+        return EMPTY;
+    }
+  }
+  /** V2 `tool` hook `execute.before`: remember the call's tool and start time. */
+  toolStarted(callID, tool, nowMs) {
+    const id = str(callID);
+    const name = str(tool);
+    if (!id || !name) return;
+    this.callTools.set(id, name);
+    this.toolStarts.set(id, nowMs);
+  }
+  /** V2 `tool` hook `execute.after`: one finished call. V2 reports skills as their own event. */
+  toolEnded(callID, tool, status, nowMs) {
+    const id = str(callID);
+    const name = str(tool) ?? (id ? this.callTools.get(id) : void 0);
+    if (!id || !name || status !== "completed" && status !== "error") return EMPTY;
+    if (this.reported.has(`tool2:${id}`)) return EMPTY;
+    this.reported.set(`tool2:${id}`, true);
+    const started = this.toolStarts.get(id);
+    const duration = started === void 0 ? 0 : nowMs - started;
+    return {
+      logs: [this.record("tool_result", nowMs, [
+        ...this.toolAttributes(name),
+        attr("success", status === "completed"),
+        ...duration > 0 && duration < 864e5 ? [attr("duration_ms", Math.round(duration))] : []
+      ])],
+      usage: []
+    };
   }
   tool(part, id, nowMs) {
     const tool = str(part.tool);
@@ -294,7 +415,8 @@ var OpencodeTelemetry = class {
       const name = this.options.sendNames ? `mcp__${mcp.server}__${tool.slice(mcp.prefix.length)}` : "mcp_tool";
       return [attr("tool_name", TOOL_NAME.test(name) ? name : "mcp_tool"), attr("tool_source", "mcp")];
     }
-    return TOOL_NAME.test(tool) ? [attr("tool_name", tool), attr("tool_source", "builtin")] : [attr("tool_source", "builtin")];
+    const named = this.options.sendNames ? TOOL_NAME.test(tool) : BUILTIN_TOOLS.has(tool);
+    return [attr("tool_name", named ? tool : UNNAMED_TOOL), attr("tool_source", "builtin")];
   }
   skillName(input) {
     const name = isRecord(input) ? str(input.name) : void 0;
@@ -335,24 +457,20 @@ async function mcpServerNames(input) {
     return [];
   }
 }
-var AnyforgeTelemetry = async (input) => {
+async function start(mcpServers) {
   const anyforgeDir = join(homedir(), ".anyforge");
   const creds = await readJson(join(anyforgeDir, "credentials"));
   const apiKey = typeof creds?.apiKey === "string" ? creds.apiKey : null;
   const endpoint = typeof creds?.endpoint === "string" ? creds.endpoint.replace(/\/+$/, "") : null;
-  if (!apiKey || !endpoint) return {};
-  let anyforgeHost = null;
+  if (!apiKey || !endpoint) return null;
+  let anyforgeHost;
   try {
     anyforgeHost = new URL(endpoint).host;
   } catch {
-    return {};
+    return null;
   }
   const settings = await readJson(join(anyforgeDir, "opencode-telemetry.json"));
-  const telemetry = new OpencodeTelemetry({
-    sendNames: settings?.sendNames === true,
-    mcpServers: await mcpServerNames(input),
-    anyforgeHost
-  });
+  const telemetry = new OpencodeTelemetry({ sendNames: settings?.sendNames === true, mcpServers, anyforgeHost });
   const exporter = new TelemetryExporter({
     endpoint,
     apiKey,
@@ -363,36 +481,87 @@ var AnyforgeTelemetry = async (input) => {
     void exporter.flush();
   }, FLUSH_INTERVAL_MS);
   timer.unref?.();
-  const take = (t) => {
-    exporter.addLogs(t.logs);
-    exporter.addUsage(t.usage);
-  };
   return {
-    "chat.message": async () => {
-      try {
-        take(telemetry.prompt(Date.now()));
-      } catch {
-      }
-    },
-    "chat.params": async (params) => {
-      try {
-        telemetry.provider(params?.provider?.info?.id, params?.provider?.options?.baseURL);
-      } catch {
-      }
-    },
-    event: async ({ event }) => {
-      try {
-        take(telemetry.event(event, Date.now()));
-        if (event?.type === "session.idle") void exporter.flush();
-      } catch {
-      }
+    telemetry,
+    exporter,
+    take: (t) => {
+      exporter.addLogs(t.logs);
+      exporter.addUsage(t.usage);
     },
-    dispose: async () => {
+    stop: async () => {
       clearInterval(timer);
       await exporter.flush();
     }
   };
-};
+}
+function quietly(step) {
+  try {
+    step();
+  } catch {
+  }
+}
+async function server(input) {
+  const run = await start(await mcpServerNames(input));
+  if (!run) return {};
+  const { telemetry, take, exporter } = run;
+  return {
+    "chat.message": async () => quietly(() => take(telemetry.prompt(Date.now()))),
+    "chat.params": async (params) => quietly(() => telemetry.provider(params?.provider?.info?.id, params?.provider?.options?.baseURL)),
+    event: async ({ event }) => quietly(() => {
+      take(telemetry.event(event, Date.now()));
+      if (event?.type === "session.idle") void exporter.flush();
+    }),
+    dispose: () => run.stop()
+  };
+}
+var V2_EVENTS = [
+  "session.inbox.enqueued",
+  "session.step.started",
+  "session.step.ended",
+  "session.step.failed",
+  "session.skill.activated",
+  "session.execution.succeeded",
+  "session.execution.failed",
+  "permission.asked",
+  "permission.replied"
+];
+async function setup(ctx) {
+  const run = await start([]);
+  if (!run) return;
+  const { telemetry, take, exporter } = run;
+  const registrations = [];
+  const register = async (registering) => {
+    try {
+      registrations.push(await registering());
+    } catch {
+    }
+  };
+  await register(() => ctx.mcp.transform((editor) => quietly(() => telemetry.setMcpServers(editor.list().map(([name]) => name)))));
+  await register(() => ctx.session.hook("model.request", (input) => quietly(() => telemetry.provider(input?.model?.providerID, input?.baseURL))));
+  await register(() => ctx.tool.hook("execute.before", (input) => quietly(() => telemetry.toolStarted(input?.id, input?.tool, Date.now()))));
+  await register(() => ctx.tool.hook("execute.after", (input) => quietly(() => take(telemetry.toolEnded(input?.id, input?.tool, input?.status, Date.now())))));
+  const abort = new AbortController();
+  void (async () => {
+    try {
+      for await (const event of ctx.event.subscribe({ types: V2_EVENTS, signal: abort.signal })) {
+        quietly(() => {
+          take(telemetry.eventV2(event, Date.now()));
+          const type = event?.type;
+          if (type === "session.execution.succeeded" || type === "session.execution.failed") void exporter.flush();
+        });
+      }
+    } catch {
+    }
+  })();
+  return async () => {
+    abort.abort();
+    await Promise.all(registrations.map((r) => r.dispose().catch(() => {
+    })));
+    await run.stop();
+  };
+}
+var AnyforgeTelemetry = { id: "anyforge-telemetry", setup, server };
+var plugin_default = AnyforgeTelemetry;
 export {
-  AnyforgeTelemetry
+  plugin_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anyforge/control",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "AnyForge CLI — hosted Oracle conversations, a governed LLM proxy, and a scriptable client for approvals, crews, work items and workflows.",
   "license": "Apache-2.0",
   "homepage": "https://anyforge.ai",