@get-bb/plugin-sdk 0.4.108 → 0.5.9

package/dist/provider-bridge-acp.js

@@ -3757,11 +3757,11 @@ function describeResultContentBlock(block) {
   if (!type) {
     return null;
   }
-  const path5 = getStringProperty(block, "path");
+  const path6 = getStringProperty(block, "path");
   const toolName = getStringProperty(block, "tool_name");
   const url = getStringProperty(block, "url") ?? getStringProperty(block, "imageUrl");
-  if (path5) {
-    return `[${type}: ${path5}]`;
+  if (path6) {
+    return `[${type}: ${path6}]`;
   }
   if (toolName) {
     return `[${type}: ${toolName}]`;
@@ -4224,6 +4224,23 @@ function mimeTypeFromExtension(filePath) {
   }
 }
 
+// ../text-utils/src/utf16.ts
+function isHighSurrogateAt(value, index) {
+  const code = value.charCodeAt(index);
+  return code >= 55296 && code <= 56319;
+}
+function isLowSurrogateAt(value, index) {
+  const code = value.charCodeAt(index);
+  return code >= 56320 && code <= 57343;
+}
+function sliceUtf16Head(value, maxChars) {
+  let end = Math.min(value.length, Math.max(0, maxChars));
+  if (isHighSurrogateAt(value, end - 1) && isLowSurrogateAt(value, end)) {
+    end -= 1;
+  }
+  return value.slice(0, end);
+}
+
 // ../provider-bridge-protocol/src/bridge-kit/presentation.ts
 var PRESENTATION_TITLE_MAX_LENGTH = 160;
 function presentationTitle(text) {
@@ -4231,14 +4248,14 @@ function presentationTitle(text) {
   if (firstLine.length === 0) {
     return void 0;
   }
-  return firstLine.length > PRESENTATION_TITLE_MAX_LENGTH ? `${firstLine.slice(0, PRESENTATION_TITLE_MAX_LENGTH - 1)}\u2026` : firstLine;
+  return firstLine.length > PRESENTATION_TITLE_MAX_LENGTH ? `${sliceUtf16Head(firstLine, PRESENTATION_TITLE_MAX_LENGTH - 1)}\u2026` : firstLine;
 }
 function withTitle(presentation, title) {
   return title === void 0 ? presentation : { ...presentation, title };
 }
-function presentationFileName(path5) {
-  const segments = path5.split("/").filter((segment) => segment.length > 0);
-  return segments[segments.length - 1] ?? path5;
+function presentationFileName(path6) {
+  const segments = path6.split("/").filter((segment) => segment.length > 0);
+  return segments[segments.length - 1] ?? path6;
 }
 var COMPACTION_PRESENTATION = {
   label: { pending: "Compacting context", completed: "Compacted context" },
@@ -4248,13 +4265,13 @@ var REASONING_PRESENTATION = {
   label: { pending: "Thinking", completed: "Thought" },
   icon: { glyph: "Brain" }
 };
-function fileReadPresentation(path5) {
+function fileReadPresentation(path6) {
   return withTitle(
     {
       label: { pending: "Reading file", completed: "Read file" },
       icon: { glyph: "FileText" }
     },
-    presentationTitle(presentationFileName(path5))
+    presentationTitle(presentationFileName(path6))
   );
 }
 function searchPresentation(args) {
@@ -4389,12 +4406,12 @@ var ignoredJsonRpcResultSchema = z34.unknown();
 // ../provider-bridge-acp/src/bridge/bridge.ts
 import { execFile as execFile4 } from "node:child_process";
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { promises as fs2, readFileSync } from "node:fs";
+import { promises as fs3, readFileSync } from "node:fs";
 import { createServer } from "node:net";
 import { dirname as dirname2, isAbsolute, basename as basename3, relative, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 
 // ../provider-bridge-acp/src/bridge-protocol.ts
 import { z as z36 } from "zod";
@@ -4816,17 +4833,189 @@ var acpWarningNotificationParamsSchema = z36.object({
 
 // ../provider-bridge-acp/src/dialect.ts
 import { basename } from "node:path";
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 
 // ../provider-bridge-acp/src/bridge/provider-maintenance.ts
 import { execFile as execFile2 } from "node:child_process";
 import { existsSync } from "node:fs";
+import fs2 from "node:fs/promises";
+import os2 from "node:os";
+import path3 from "node:path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { promisify as promisify2 } from "node:util";
+import { z as z38 } from "zod";
+
+// ../provider-bridge-acp/src/bridge/opencode-usage.ts
 import fs from "node:fs/promises";
 import os from "node:os";
 import path2 from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { promisify as promisify2 } from "node:util";
 import { z as z37 } from "zod";
+var apiCredentialSchema = z37.object({
+  type: z37.literal("api"),
+  key: z37.string().trim().min(1)
+});
+var credentialsSchema = z37.record(z37.string(), z37.unknown());
+var accountSchema = z37.object({
+  id: z37.string().min(1),
+  email: z37.email().nullable().catch(null),
+  url: z37.url(),
+  access_token: z37.string().min(1),
+  token_expiry: z37.number().nullable(),
+  active_org_id: z37.string().min(1).nullable()
+});
+var windowSchema = z37.object({
+  status: z37.enum(["ok", "rate-limited"]),
+  percent: z37.number().nonnegative(),
+  resetsAt: z37.iso.datetime({ offset: true })
+});
+var usageSchema = z37.object({
+  usage: z37.object({
+    rolling: windowSchema,
+    weekly: windowSchema,
+    monthly: windowSchema
+  })
+});
+function dataDirectory(env) {
+  const dataHome = env.XDG_DATA_HOME;
+  return path2.join(
+    dataHome && path2.isAbsolute(dataHome) ? dataHome : path2.join(env.HOME || os.homedir(), ".local", "share"),
+    "opencode"
+  );
+}
+async function readAccount(env) {
+  const databasePath = path2.join(dataDirectory(env), "opencode.db");
+  try {
+    await fs.access(databasePath);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+  const database = new DatabaseSync(databasePath, { readOnly: true });
+  try {
+    const tables = database.prepare(
+      "SELECT name FROM sqlite_master WHERE type = 'table' AND name IN ('account', 'account_state')"
+    ).all();
+    if (tables.length !== 2) return null;
+    const row = database.prepare(
+      "SELECT a.id, a.email, a.url, a.access_token, a.token_expiry, s.active_org_id FROM account a JOIN account_state s ON s.active_account_id = a.id WHERE s.id = 1"
+    ).get();
+    if (!row) return null;
+    const account = accountSchema.parse(row);
+    const issuer = new URL(account.url);
+    if (issuer.origin !== "https://opencode.ai" || !["/", "/console", "/console/"].includes(issuer.pathname) || account.active_org_id === null)
+      return null;
+    return account;
+  } finally {
+    database.close();
+  }
+}
+async function readApiKey(env) {
+  if (env.OPENCODE_API_KEY?.trim()) return env.OPENCODE_API_KEY.trim();
+  let content = env.OPENCODE_AUTH_CONTENT;
+  if (content) {
+    try {
+      JSON.parse(content);
+    } catch {
+      content = void 0;
+    }
+  }
+  if (!content) {
+    try {
+      content = await fs.readFile(
+        path2.join(dataDirectory(env), "auth.json"),
+        "utf8"
+      );
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT")
+        return null;
+      throw error;
+    }
+  }
+  const credentials = credentialsSchema.parse(JSON.parse(content));
+  for (const provider of ["opencode-go", "opencode"]) {
+    const credential = apiCredentialSchema.safeParse(credentials[provider]);
+    if (credential.success) return credential.data.key;
+  }
+  return null;
+}
+async function readOpenCodeGoUsage(env) {
+  const failure = (message) => ({
+    supported: true,
+    usage: {
+      status: "error",
+      message,
+      planLabel: "OpenCode Go",
+      accountEmail: null
+    }
+  });
+  let apiKey;
+  let account;
+  try {
+    account = env.OPENCODE_API_KEY?.trim() ? null : await readAccount(env);
+    apiKey = account?.access_token ?? await readApiKey(env);
+  } catch {
+    return failure("OpenCode credentials could not be read.");
+  }
+  if (apiKey === null)
+    return { supported: true, usage: { status: "unauthenticated" } };
+  if (account?.token_expiry != null && account.token_expiry <= Date.now())
+    return { supported: true, usage: { status: "expired" } };
+  try {
+    const response = await fetch(
+      account ? "https://opencode.ai/inference/go/v1/usage" : "https://opencode.ai/zen/go/v1/usage",
+      {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          Accept: "application/json",
+          "User-Agent": "bb-provider-acp",
+          ...account?.active_org_id ? { "x-opencode-org-id": account.active_org_id } : {}
+        },
+        redirect: "error",
+        signal: AbortSignal.timeout(15e3)
+      }
+    );
+    if (response.status === 401)
+      return { supported: true, usage: { status: "expired" } };
+    if (response.status === 403)
+      return failure(
+        "OpenCode Go usage access was denied. Check that the account has an active Go subscription."
+      );
+    if (!response.ok)
+      return failure(
+        `OpenCode Go usage request failed (HTTP ${response.status}).`
+      );
+    const parsed = usageSchema.safeParse(await response.json());
+    if (!parsed.success)
+      return failure("OpenCode Go returned invalid usage information.");
+    const { rolling, weekly, monthly } = parsed.data.usage;
+    return {
+      supported: true,
+      usage: {
+        status: "ok",
+        accountEmail: account?.email ?? null,
+        accountKey: account ? `opencode:organization:${account.active_org_id}:account:${account.id}` : null,
+        planLabel: "OpenCode Go",
+        windows: [
+          { label: "5 hour", kind: "five-hour", window: rolling },
+          { label: "Weekly", kind: "weekly", window: weekly },
+          { label: "Monthly", kind: "custom", window: monthly }
+        ].map(({ label, kind, window }) => ({
+          label,
+          kind,
+          model: null,
+          usedPercent: Math.min(100, window.percent),
+          resetsAt: window.resetsAt
+        }))
+      }
+    };
+  } catch {
+    return failure("OpenCode Go usage could not be collected. Try again.");
+  }
+}
+
+// ../provider-bridge-acp/src/bridge/provider-maintenance.ts
 var execFileAsync2 = promisify2(execFile2);
 var USAGE_FETCH_TIMEOUT_MS = 15e3;
 var CURSOR_DASHBOARD_URL = "https://api2.cursor.sh/aiserver.v1.DashboardService";
@@ -4835,14 +5024,14 @@ var CURSOR_ACCESS_TOKEN_SERVICE = "cursor-access-token";
 var CURSOR_INSTALL_SCRIPT_URL = "https://cursor.com/install";
 function cursorAuthFilePath() {
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA ?? path2.join(os.homedir(), "AppData", "Roaming");
-    return path2.join(appData, "Cursor", "auth.json");
+    const appData = process.env.APPDATA ?? path3.join(os2.homedir(), "AppData", "Roaming");
+    return path3.join(appData, "Cursor", "auth.json");
   }
   if (process.platform === "darwin") {
-    return path2.join(os.homedir(), ".cursor", "auth.json");
+    return path3.join(os2.homedir(), ".cursor", "auth.json");
   }
-  const configHome = process.env.XDG_CONFIG_HOME ?? path2.join(os.homedir(), ".config");
-  return path2.join(configHome, "cursor", "auth.json");
+  const configHome = process.env.XDG_CONFIG_HOME ?? path3.join(os2.homedir(), ".config");
+  return path3.join(configHome, "cursor", "auth.json");
 }
 async function readKeychainAccessToken() {
   if (process.platform !== "darwin") return null;
@@ -4864,15 +5053,15 @@ async function readKeychainAccessToken() {
     return null;
   }
 }
-var cursorFileCredentialsSchema = z37.object({
-  accessToken: z37.string().min(1).nullish()
+var cursorFileCredentialsSchema = z38.object({
+  accessToken: z38.string().min(1).nullish()
 });
 async function readAccessToken() {
   const keychain = await readKeychainAccessToken();
   if (keychain) return keychain;
   try {
     const parsed = cursorFileCredentialsSchema.safeParse(
-      JSON.parse(await fs.readFile(cursorAuthFilePath(), "utf8"))
+      JSON.parse(await fs2.readFile(cursorAuthFilePath(), "utf8"))
     );
     return parsed.success ? parsed.data.accessToken ?? null : null;
   } catch {
@@ -4881,12 +5070,12 @@ async function readAccessToken() {
 }
 function cursorStateDatabasePath() {
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA ?? path2.join(os.homedir(), "AppData", "Roaming");
-    return path2.join(appData, "Cursor", "User", "globalStorage", "state.vscdb");
+    const appData = process.env.APPDATA ?? path3.join(os2.homedir(), "AppData", "Roaming");
+    return path3.join(appData, "Cursor", "User", "globalStorage", "state.vscdb");
   }
   if (process.platform === "darwin") {
-    return path2.join(
-      os.homedir(),
+    return path3.join(
+      os2.homedir(),
       "Library",
       "Application Support",
       "Cursor",
@@ -4895,8 +5084,8 @@ function cursorStateDatabasePath() {
       "state.vscdb"
     );
   }
-  const configHome = process.env.XDG_CONFIG_HOME ?? path2.join(os.homedir(), ".config");
-  return path2.join(
+  const configHome = process.env.XDG_CONFIG_HOME ?? path3.join(os2.homedir(), ".config");
+  return path3.join(
     configHome,
     "Cursor",
     "User",
@@ -4909,10 +5098,10 @@ function readAccountEmail() {
   if (!existsSync(databasePath)) return null;
   let database = null;
   try {
-    database = new DatabaseSync(databasePath);
+    database = new DatabaseSync2(databasePath);
     database.exec("PRAGMA query_only = true");
     const row = database.prepare("SELECT value FROM ItemTable WHERE key = ?").get("cursorAuth/cachedEmail");
-    const parsed = z37.object({ value: z37.string().email() }).safeParse(row);
+    const parsed = z38.object({ value: z38.string().email() }).safeParse(row);
     return parsed.success ? parsed.data.value : null;
   } catch {
     return null;
@@ -5016,14 +5205,14 @@ function buildAcpProviderInstallationRun(status, args) {
     verification: { kind: "installed" }
   };
 }
-var cursorNonNegativeIntegerSchema = z37.union([
-  z37.number().int().nonnegative(),
-  z37.string().regex(/^\d+$/u).transform(Number)
+var cursorNonNegativeIntegerSchema = z38.union([
+  z38.number().int().nonnegative(),
+  z38.string().regex(/^\d+$/u).transform(Number)
 ]).refine(Number.isSafeInteger);
-var cursorUsageResponseSchema = z37.object({
+var cursorUsageResponseSchema = z38.object({
   billingCycleEnd: cursorNonNegativeIntegerSchema.nullish(),
-  planUsage: z37.object({ totalPercentUsed: z37.number().nonnegative().default(0) }).nullish(),
-  spendLimitUsage: z37.object({
+  planUsage: z38.object({ totalPercentUsed: z38.number().nonnegative().default(0) }).nullish(),
+  spendLimitUsage: z38.object({
     overallLimit: cursorNonNegativeIntegerSchema.nullish(),
     overallUsed: cursorNonNegativeIntegerSchema.nullish(),
     individualLimit: cursorNonNegativeIntegerSchema.nullish(),
@@ -5032,8 +5221,8 @@ var cursorUsageResponseSchema = z37.object({
     pooledUsed: cursorNonNegativeIntegerSchema.nullish()
   }).nullish()
 }).passthrough();
-var cursorPlanResponseSchema = z37.object({
-  planInfo: z37.object({ planName: z37.string().min(1) }).nullish()
+var cursorPlanResponseSchema = z38.object({
+  planInfo: z38.object({ planName: z38.string().min(1) }).nullish()
 }).passthrough();
 function normalizeUsage(rawUsage, rawPlan, accountEmail = null) {
   const usage = cursorUsageResponseSchema.safeParse(rawUsage);
@@ -5088,11 +5277,12 @@ function fetchDashboard(method, accessToken) {
   });
 }
 async function getAcpProviderUsage(args) {
-  if (args.maintenance === void 0) return { supported: false };
+  const readUsage = args.dialectId === "opencode" ? () => readOpenCodeGoUsage(args.env) : args.maintenance?.readUsage;
+  if (readUsage === void 0) return { supported: false };
   if (args.command === null || await resolveExecutablePath(args.command) === null) {
     return { supported: true, usage: { status: "not_installed" } };
   }
-  return args.maintenance.readUsage();
+  return readUsage();
 }
 var CURSOR_ACP_MAINTENANCE = {
   loginCommand: "cursor-agent login",
@@ -5245,24 +5435,24 @@ function toolKindPresentation(args) {
 }
 
 // ../provider-bridge-acp/src/tool-classification.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 
 // ../provider-bridge-acp/src/tool-call-operation.ts
-import path3 from "node:path";
-import { z as z38 } from "zod";
-var acpRawInputCommandSchema = z38.object({ command: z38.string() }).passthrough();
-var acpRawInputPathSchema = z38.object({
-  path: z38.string().optional(),
-  filePath: z38.string().optional(),
-  file_path: z38.string().optional(),
-  target_file: z38.string().optional()
+import path4 from "node:path";
+import { z as z39 } from "zod";
+var acpRawInputCommandSchema = z39.object({ command: z39.string() }).passthrough();
+var acpRawInputPathSchema = z39.object({
+  path: z39.string().optional(),
+  filePath: z39.string().optional(),
+  file_path: z39.string().optional(),
+  target_file: z39.string().optional()
 }).passthrough();
 function resolveAcpToolCallPath(value, options) {
   const cwd = options?.cwd;
-  if (cwd === void 0 || path3.isAbsolute(value) || value.startsWith("~")) {
+  if (cwd === void 0 || path4.isAbsolute(value) || value.startsWith("~")) {
     return value;
   }
-  return path3.resolve(cwd, value);
+  return path4.resolve(cwd, value);
 }
 function extractAcpCommand(event) {
   const parsed = acpRawInputCommandSchema.safeParse(event.rawInput);
@@ -5320,8 +5510,8 @@ function classifyAcpToolCall(event, options) {
 }
 function resolveAcpFileChangeWriteScope(paths) {
   const normalized = paths.filter(isNonBlank).map((entry) => {
-    const value = path3.normalize(entry);
-    return value.length > 1 && value.endsWith(path3.sep) ? value.slice(0, -1) : value;
+    const value = path4.normalize(entry);
+    return value.length > 1 && value.endsWith(path4.sep) ? value.slice(0, -1) : value;
   });
   const [first, ...rest] = normalized;
   if (first === void 0) {
@@ -5333,7 +5523,7 @@ function resolveAcpFileChangeWriteScope(paths) {
       candidate = entry;
     }
   }
-  const prefix = candidate.endsWith(path3.sep) ? candidate : candidate + path3.sep;
+  const prefix = candidate.endsWith(path4.sep) ? candidate : candidate + path4.sep;
   for (const entry of normalized) {
     if (entry !== candidate && !entry.startsWith(prefix)) {
       return null;
@@ -5432,14 +5622,14 @@ function extractAcpToolCallOutputText(event) {
   ).trim();
   return rawOutputText.length > 0 ? rawOutputText : void 0;
 }
-var commandRawOutputSchema = z39.object({
-  exitCode: z39.number().int().nullable().optional(),
-  exit_code: z39.number().int().nullable().optional(),
-  stdout: z39.string().optional(),
-  stderr: z39.string().optional(),
-  output_for_prompt: z39.string().optional(),
-  signal: z39.string().nullable().optional(),
-  timed_out: z39.boolean().optional()
+var commandRawOutputSchema = z40.object({
+  exitCode: z40.number().int().nullable().optional(),
+  exit_code: z40.number().int().nullable().optional(),
+  stdout: z40.string().optional(),
+  stderr: z40.string().optional(),
+  output_for_prompt: z40.string().optional(),
+  signal: z40.string().nullable().optional(),
+  timed_out: z40.boolean().optional()
 }).passthrough();
 function emptyToUndefined(value) {
   return value === void 0 || value.length === 0 ? void 0 : value;
@@ -5508,10 +5698,10 @@ function extractAcpCommandResult(event) {
     ...output === void 0 ? {} : { output: scrubInlineImageDataUrls(output) }
   };
 }
-var optionalNonBlank = z39.string().optional().transform(
+var optionalNonBlank = z40.string().optional().transform(
   (value) => value !== void 0 && value.trim().length > 0 ? value : void 0
 );
-var searchRawInputSchema = z39.object({
+var searchRawInputSchema = z40.object({
   pattern: optionalNonBlank,
   query: optionalNonBlank,
   regex: optionalNonBlank,
@@ -5520,8 +5710,8 @@ var searchRawInputSchema = z39.object({
   path: optionalNonBlank,
   directory: optionalNonBlank
 }).passthrough();
-var fetchRawInputSchema = z39.object({ url: optionalNonBlank, uri: optionalNonBlank }).passthrough();
-var thinkRawInputSchema = z39.object({ thought: optionalNonBlank, thinking: optionalNonBlank }).passthrough();
+var fetchRawInputSchema = z40.object({ url: optionalNonBlank, uri: optionalNonBlank }).passthrough();
+var thinkRawInputSchema = z40.object({ thought: optionalNonBlank, thinking: optionalNonBlank }).passthrough();
 var SINGLE_TICKED_TOKEN_PATTERN = /^[^`]*`([^`\n]+)`[^`]*$/;
 var URL_PATTERN = /https?:\/\/[^\s`'"<>]+/g;
 function tickedTokenFromTitle(title) {
@@ -5571,8 +5761,8 @@ function buildAcpFileChanges(event, operation, options) {
   if (changes.length > 0) {
     return changes;
   }
-  const [path5] = operation.paths;
-  return path5 === void 0 ? [] : [{ path: path5, kind: operation.changeKind }];
+  const [path6] = operation.paths;
+  return path6 === void 0 ? [] : [{ path: path6, kind: operation.changeKind }];
 }
 function fileChangeItem(changes, fallbackVerb) {
   return {
@@ -5585,13 +5775,13 @@ function fileChangeItem(changes, fallbackVerb) {
 }
 function fileReadItem(event, title, options) {
   const ticked = tickedTokenFromTitle(title);
-  const path5 = extractAcpToolCallPaths(event, options)[0] ?? (ticked !== void 0 && looksLikePath(ticked) ? ticked : void 0);
-  if (path5 === void 0) {
+  const path6 = extractAcpToolCallPaths(event, options)[0] ?? (ticked !== void 0 && looksLikePath(ticked) ? ticked : void 0);
+  if (path6 === void 0) {
     return null;
   }
   return {
-    item: { type: "fileRead", path: path5 },
-    presentation: fileReadPresentation(path5)
+    item: { type: "fileRead", path: path6 },
+    presentation: fileReadPresentation(path6)
   };
 }
 function searchItem(event) {
@@ -5714,10 +5904,10 @@ function classifyAcpToolCall2(event, injected, options) {
 
 // ../provider-bridge-acp/src/dialect.ts
 var GENERIC_ACP_DIALECT = { id: "acp" };
-var grokToolMetaSchema = z40.object({
-  "x.ai/tool": z40.object({
-    name: z40.string().optional(),
-    kind: z40.string().optional()
+var grokToolMetaSchema = z41.object({
+  "x.ai/tool": z41.object({
+    name: z41.string().optional(),
+    kind: z41.string().optional()
   }).passthrough()
 }).passthrough();
 function grokToolIdentity(event) {
@@ -5733,10 +5923,10 @@ function grokToolIdentity(event) {
   };
 }
 var GROK_SPAWN_SUBAGENT_TOOL = "spawn_subagent";
-var grokSpawnSubagentInputSchema = z40.object({
-  description: z40.string().optional(),
-  prompt: z40.string().optional(),
-  subagent_type: z40.string().optional()
+var grokSpawnSubagentInputSchema = z41.object({
+  description: z41.string().optional(),
+  prompt: z41.string().optional(),
+  subagent_type: z41.string().optional()
 }).passthrough();
 function grokClassifyToolCall(event) {
   if (grokToolIdentity(event)?.name !== GROK_SPAWN_SUBAGENT_TOOL) {
@@ -5764,15 +5954,64 @@ var GROK_ACP_DIALECT = {
   toolIdentity: grokToolIdentity,
   classifyToolCall: grokClassifyToolCall
 };
+var grokModelMetaSchema = z41.object({
+  totalContextTokens: z41.number().int().positive()
+}).passthrough();
+var grokPromptMetaSchema = z41.object({
+  inputTokens: z41.number().int().nonnegative().optional(),
+  totalTokens: z41.number().int().nonnegative().optional(),
+  usage: z41.object({
+    inputTokens: z41.number().int().nonnegative().optional(),
+    totalTokens: z41.number().int().nonnegative().optional()
+  }).passthrough().optional()
+}).passthrough();
+var grokPromptResultSchema = z41.object({
+  _meta: grokPromptMetaSchema.optional()
+}).passthrough();
+var grokSessionModelSchema = z41.object({
+  modelId: z41.string(),
+  _meta: grokModelMetaSchema.optional()
+}).passthrough();
+var grokSessionModelsSchema = z41.object({
+  currentModelId: z41.string().optional(),
+  availableModels: z41.array(grokSessionModelSchema).optional()
+}).passthrough();
+function grokContextWindowSizeFromSessionModels(models) {
+  const parsed = grokSessionModelsSchema.safeParse(models);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const available = parsed.data.availableModels ?? [];
+  const currentId = parsed.data.currentModelId;
+  const ordered = [
+    ...currentId === void 0 ? [] : available.filter((model) => model.modelId === currentId),
+    ...available
+  ];
+  for (const model of ordered) {
+    if (model._meta !== void 0) {
+      return model._meta.totalContextTokens;
+    }
+  }
+  return void 0;
+}
+function grokContextUsageFromPromptResult(result) {
+  const parsed = grokPromptResultSchema.safeParse(result);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const meta = parsed.data._meta;
+  const used = meta?.usage?.inputTokens ?? meta?.inputTokens ?? meta?.usage?.totalTokens ?? meta?.totalTokens;
+  return used === void 0 ? void 0 : { used };
+}
 var CURSOR_TASK_TOOL = "task";
-var cursorTaskRawInputSchema = z40.object({ _toolName: z40.string().optional() }).passthrough();
+var cursorTaskRawInputSchema = z41.object({ _toolName: z41.string().optional() }).passthrough();
 var CURSOR_TASK_METHOD = "cursor/task";
-var cursorTaskParamsSchema = z40.object({
-  toolCallId: z40.string(),
-  description: z40.string().optional(),
-  prompt: z40.string().optional(),
-  agentId: z40.string().optional(),
-  model: z40.string().optional()
+var cursorTaskParamsSchema = z41.object({
+  toolCallId: z41.string(),
+  description: z41.string().optional(),
+  prompt: z41.string().optional(),
+  agentId: z41.string().optional(),
+  model: z41.string().optional()
 }).passthrough();
 function cursorClassifyToolCall(event) {
   const parsed = cursorTaskRawInputSchema.safeParse(event.rawInput);
@@ -5820,23 +6059,23 @@ var CURSOR_ACP_DIALECT = {
   handleClientRequest: cursorHandleClientRequest,
   maintenance: CURSOR_ACP_MAINTENANCE
 };
-var ompBashRawInputSchema = z40.object({
-  command: z40.string(),
-  async: z40.boolean().optional()
+var ompBashRawInputSchema = z41.object({
+  command: z41.string(),
+  async: z41.boolean().optional()
 }).passthrough();
 var ompBashRawOutputSchema = commandRawOutputSchema.extend({
-  content: z40.array(
-    z40.object({
-      type: z40.literal("text"),
-      text: z40.string()
+  content: z41.array(
+    z41.object({
+      type: z41.literal("text"),
+      text: z41.string()
     }).passthrough()
   ),
-  details: z40.object({
-    exitCode: z40.number().int().optional(),
-    wallTimeMs: z40.number().nonnegative().optional(),
-    timedOut: z40.boolean().optional(),
-    signal: z40.unknown().optional(),
-    async: z40.unknown().optional()
+  details: z41.object({
+    exitCode: z41.number().int().optional(),
+    wallTimeMs: z41.number().nonnegative().optional(),
+    timedOut: z41.boolean().optional(),
+    signal: z41.unknown().optional(),
+    async: z41.unknown().optional()
   }).passthrough()
 });
 function stripOmpTrailingNotice(text, notice) {
@@ -5899,11 +6138,11 @@ var OMP_ACP_DIALECT = {
   id: "omp",
   commandResult: ompCommandResult
 };
-var openCodeCommandRawOutputSchema = z40.object({
-  output: z40.unknown().optional(),
-  metadata: z40.object({
-    exit: z40.number().int().nullable().optional(),
-    output: z40.string().optional()
+var openCodeCommandRawOutputSchema = z41.object({
+  output: z41.unknown().optional(),
+  metadata: z41.object({
+    exit: z41.number().int().nullable().optional(),
+    output: z41.string().optional()
   }).passthrough().optional()
 }).passthrough();
 function normalizeOpenCodeCommandEvent(event) {
@@ -6919,7 +7158,7 @@ function resolveAcpPermissionDecision(args) {
 }
 
 // ../provider-bridge-acp/src/session-params.ts
-import path4 from "node:path";
+import path5 from "node:path";
 
 // ../provider-bridge-acp/src/bridge/model-catalog.ts
 var ACP_NATIVE_REASONING_EFFORTS = [
@@ -7378,7 +7617,7 @@ function buildAcpSkillsInstructions(skillRoots) {
   }
   const skillLines = skillRoots.flatMap((skillRoot) => {
     return skillRoot.skills.map((skill) => {
-      const skillFilePath = path4.join(
+      const skillFilePath = path5.join(
         skillRoot.skillDirectoryRootPath,
         skill.name,
         "SKILL.md"
@@ -7821,7 +8060,7 @@ import { basename as basename2, dirname, join as join2, resolve as resolve2 } fr
 // ../provider-bridge-acp/src/bridge/tool-proxy-mcp.ts
 import { createConnection } from "node:net";
 import { createInterface as createInterface2 } from "node:readline";
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var ACP_BRIDGE_MCP_SERVER_NAME = "bb-bridge";
 var ENV_HOST = "BB_ACP_DYNAMIC_TOOL_HOST";
 var ENV_PORT = "BB_ACP_DYNAMIC_TOOL_PORT";
@@ -7829,45 +8068,45 @@ var ENV_TOKEN = "BB_ACP_DYNAMIC_TOOL_TOKEN";
 var ENV_THREAD_ID = "BB_ACP_DYNAMIC_TOOL_THREAD_ID";
 var ENV_TOOLS = "BB_ACP_DYNAMIC_TOOLS";
 var ENV_PROGRESS_INTERVAL_MS = "BB_ACP_DYNAMIC_TOOL_PROGRESS_INTERVAL_MS";
-var dynamicToolBridgeRequestSchema = z41.discriminatedUnion("kind", [
-  z41.object({
-    kind: z41.literal("initialized"),
-    threadId: z41.string().min(1),
-    token: z41.string().min(1),
-    toolCount: z41.number().int().nonnegative()
+var dynamicToolBridgeRequestSchema = z42.discriminatedUnion("kind", [
+  z42.object({
+    kind: z42.literal("initialized"),
+    threadId: z42.string().min(1),
+    token: z42.string().min(1),
+    toolCount: z42.number().int().nonnegative()
   }),
-  z41.object({
-    kind: z41.literal("toolCall"),
-    arguments: z41.record(z41.string(), z41.unknown()).default({}),
-    callId: z41.string().min(1),
-    threadId: z41.string().min(1),
-    token: z41.string().min(1),
-    tool: z41.string().min(1)
+  z42.object({
+    kind: z42.literal("toolCall"),
+    arguments: z42.record(z42.string(), z42.unknown()).default({}),
+    callId: z42.string().min(1),
+    threadId: z42.string().min(1),
+    token: z42.string().min(1),
+    tool: z42.string().min(1)
   })
 ]);
-var bridgeToolCallResponseSchema = z41.union([
-  z41.object({
-    ok: z41.literal(true),
-    content: z41.string(),
-    contentBlocks: z41.array(
-      z41.discriminatedUnion("type", [
-        z41.object({ type: z41.literal("text"), text: z41.string() }),
-        z41.object({
-          type: z41.literal("image"),
-          data: z41.string(),
-          mimeType: z41.string()
+var bridgeToolCallResponseSchema = z42.union([
+  z42.object({
+    ok: z42.literal(true),
+    content: z42.string(),
+    contentBlocks: z42.array(
+      z42.discriminatedUnion("type", [
+        z42.object({ type: z42.literal("text"), text: z42.string() }),
+        z42.object({
+          type: z42.literal("image"),
+          data: z42.string(),
+          mimeType: z42.string()
         })
       ])
     ).optional(),
-    images: z41.array(z41.object({ data: z41.string(), mimeType: z41.string() })).default([]),
-    isError: z41.boolean().optional()
+    images: z42.array(z42.object({ data: z42.string(), mimeType: z42.string() })).default([]),
+    isError: z42.boolean().optional()
   }),
-  z41.object({ ok: z41.literal(false), error: z41.string() })
+  z42.object({ ok: z42.literal(false), error: z42.string() })
 ]);
-var jsonRpcMessageSchema = z41.object({
-  id: z41.union([z41.string(), z41.number().int()]).optional(),
-  method: z41.string().optional(),
-  params: z41.unknown().optional()
+var jsonRpcMessageSchema = z42.object({
+  id: z42.union([z42.string(), z42.number().int()]).optional(),
+  method: z42.string().optional(),
+  params: z42.unknown().optional()
 });
 var nextMcpToolCallId = 0;
 var TOOL_CALL_PROGRESS_INTERVAL_MS = 15e3;
@@ -8167,10 +8406,10 @@ async function resolveCursorProjectRoot(args) {
     );
   });
 }
-async function readApprovals(path5) {
+async function readApprovals(path6) {
   let text;
   try {
-    text = await readFile(path5, "utf8");
+    text = await readFile(path6, "utf8");
   } catch (error) {
     if (errorCode(error) === "ENOENT") {
       return [];
@@ -8179,29 +8418,29 @@ async function readApprovals(path5) {
   }
   const value = JSON.parse(text);
   if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
-    throw new Error(`Cursor MCP approval file is not a string array: ${path5}`);
+    throw new Error(`Cursor MCP approval file is not a string array: ${path6}`);
   }
   return value;
 }
-async function writeApprovals(path5, approvals) {
-  await mkdir(dirname(path5), { recursive: true });
-  const tempPath = `${path5}.bb-${process.pid}-${randomBytes(6).toString("hex")}.tmp`;
+async function writeApprovals(path6, approvals) {
+  await mkdir(dirname(path6), { recursive: true });
+  const tempPath = `${path6}.bb-${process.pid}-${randomBytes(6).toString("hex")}.tmp`;
   try {
     await writeFile(tempPath, `${JSON.stringify(approvals, null, 2)}
 `, {
       encoding: "utf8",
       mode: 384
     });
-    await rename(tempPath, path5);
+    await rename(tempPath, path6);
   } catch (error) {
     await rm(tempPath, { force: true });
     throw error;
   }
 }
-async function acquireApprovalLock(path5) {
-  const lockPath = `${path5}.bb-lock`;
+async function acquireApprovalLock(path6) {
+  const lockPath = `${path6}.bb-lock`;
   const deadline = Date.now() + CURSOR_APPROVAL_LOCK_TIMEOUT_MS;
-  await mkdir(dirname(path5), { recursive: true });
+  await mkdir(dirname(path6), { recursive: true });
   for (; ; ) {
     try {
       await mkdir(lockPath, { mode: 448 });
@@ -8224,18 +8463,18 @@ async function acquireApprovalLock(path5) {
       throw error;
     }
     if (Date.now() >= deadline) {
-      throw new Error(`Timed out updating Cursor MCP approvals: ${path5}`);
+      throw new Error(`Timed out updating Cursor MCP approvals: ${path6}`);
     }
     await new Promise((resolveDelay) => setTimeout(resolveDelay, 25));
   }
 }
-async function mutateApprovals(path5, mutate) {
-  const releaseLock = await acquireApprovalLock(path5);
+async function mutateApprovals(path6, mutate) {
+  const releaseLock = await acquireApprovalLock(path6);
   try {
-    const approvals = await readApprovals(path5);
+    const approvals = await readApprovals(path6);
     const nextApprovals = mutate(approvals);
     if (approvals.length !== nextApprovals.length || approvals.some((approval, index) => approval !== nextApprovals[index])) {
-      await writeApprovals(path5, nextApprovals);
+      await writeApprovals(path6, nextApprovals);
     }
   } finally {
     await releaseLock();
@@ -8249,7 +8488,7 @@ async function approveCursorSessionMcpServer(args) {
     cwd: args.cwd,
     env: args.env
   });
-  const path5 = join2(
+  const path6 = join2(
     cursorDataDirectory(args.env),
     "projects",
     cursorProjectSlug(projectRoot),
@@ -8260,14 +8499,14 @@ async function approveCursorSessionMcpServer(args) {
     projectRoot
   });
   let installedByBb = false;
-  await mutateApprovals(path5, (approvals) => {
+  await mutateApprovals(path6, (approvals) => {
     if (approvals.includes(approval)) {
       return approvals;
     }
     installedByBb = true;
     return [...approvals, approval];
   });
-  return { approval, installedByBb, path: path5 };
+  return { approval, installedByBb, path: path6 };
 }
 async function revokeCursorSessionMcpServer(approval) {
   if (!approval.installedByBb) {
@@ -8334,6 +8573,29 @@ function sendThreadDeltas(threadId, deltas) {
     deltas: [...deltas]
   });
 }
+function rememberGrokContextWindow(session, models) {
+  if (session.dialect.id !== "grok") {
+    return;
+  }
+  const size = grokContextWindowSizeFromSessionModels(models);
+  if (size !== void 0) {
+    session.grokContextWindowSize = size;
+  }
+}
+function emitGrokContextWindow(session, used) {
+  if (session.dialect.id !== "grok" || session.grokContextWindowSize === void 0) {
+    return;
+  }
+  sendThreadDeltas(session.bbThreadId, [
+    {
+      kind: "contextWindow",
+      used,
+      size: session.grokContextWindowSize,
+      estimated: false,
+      attach: "open"
+    }
+  ]);
+}
 function emitForSession(session, method, params) {
   sendThreadDeltas(
     session.bbThreadId,
@@ -8641,7 +8903,7 @@ async function authenticateAcpAgent(args) {
     await args.connection.request({
       method: "authenticate",
       params: { methodId, _meta: { headless: true } },
-      resultSchema: z42.unknown()
+      resultSchema: z43.unknown()
     });
   } catch (error) {
     throw new AcpAuthRequiredError(
@@ -8971,7 +9233,7 @@ async function selectAcpNativeModel(args) {
             configId: modelOption.id,
             value: selection.modelId
           },
-          resultSchema: z42.union([acpConfigStateResultSchema, z42.null()])
+          resultSchema: z43.union([acpConfigStateResultSchema, z43.null()])
         });
         setModel = false;
       } catch {
@@ -8982,7 +9244,7 @@ async function selectAcpNativeModel(args) {
       configState = await args.connection.request({
         method: "session/set_model",
         params: { sessionId: args.sessionId, modelId: selection.modelId },
-        resultSchema: z42.union([acpConfigStateResultSchema, z42.null()])
+        resultSchema: z43.union([acpConfigStateResultSchema, z43.null()])
       });
     }
     configOptions = configState?.configOptions ?? configOptions;
@@ -9237,7 +9499,7 @@ async function handleFsReadTextFile(params, responder) {
     return;
   }
   try {
-    const content = await fs2.readFile(parsed.data.path, "utf8");
+    const content = await fs3.readFile(parsed.data.path, "utf8");
     responder.result({
       content: sliceFileContent(content, parsed.data.line, parsed.data.limit)
     });
@@ -9264,12 +9526,12 @@ async function handleFsWriteTextFile(session, params, responder) {
   try {
     let oldText;
     try {
-      oldText = await fs2.readFile(parsed.data.path, "utf8");
+      oldText = await fs3.readFile(parsed.data.path, "utf8");
     } catch {
       oldText = void 0;
     }
-    await fs2.mkdir(dirname2(parsed.data.path), { recursive: true });
-    await fs2.writeFile(parsed.data.path, parsed.data.content, "utf8");
+    await fs3.mkdir(dirname2(parsed.data.path), { recursive: true });
+    await fs3.writeFile(parsed.data.path, parsed.data.content, "utf8");
     emitForSession(session, ACP_FS_WRITE_METHOD, {
       threadId: session.bbThreadId,
       path: parsed.data.path,
@@ -9403,6 +9665,7 @@ async function startAgentSession(request) {
     loading: false,
     loadingSessionId: void 0,
     pendingLoadUsageUpdate: void 0,
+    grokContextWindowSize: void 0,
     stopping: false,
     turnSettled: void 0,
     pendingPermissions: /* @__PURE__ */ new Set(),
@@ -9449,6 +9712,7 @@ async function startAgentSession(request) {
     let sessionId;
     let loadedConfigOptions;
     let loadedModels;
+    let createdFreshSession = false;
     if (request.kind === "fork") {
       const forkedSession = await connection.request({
         method: "session/fork",
@@ -9467,6 +9731,7 @@ async function startAgentSession(request) {
       sessionId = forkedSession.sessionId;
       loadedConfigOptions = forkedSession.configOptions;
       loadedModels = forkedSession.models;
+      rememberGrokContextWindow(session, forkedSession.models);
     } else if (request.kind === "resume" && supportsLoadSession) {
       session.loading = true;
       session.loadingSessionId = request.resumeProviderThreadId;
@@ -9479,10 +9744,11 @@ async function startAgentSession(request) {
             cwd: params.cwd,
             mcpServers
           },
-          resultSchema: z42.union([acpConfigStateResultSchema, z42.null()])
+          resultSchema: z43.union([acpConfigStateResultSchema, z43.null()])
         });
         loadedConfigOptions = configState?.configOptions;
         loadedModels = configState?.models;
+        rememberGrokContextWindow(session, configState?.models);
         sessionId = request.resumeProviderThreadId;
       } catch {
         sessionId = void 0;
@@ -9501,6 +9767,8 @@ async function startAgentSession(request) {
         resultSchema: acpSessionNewResultSchema
       });
       sessionId = newSession.sessionId;
+      createdFreshSession = true;
+      rememberGrokContextWindow(session, newSession.models);
       await selectAcpNativeModel({
         connection,
         sessionId,
@@ -9548,6 +9816,9 @@ async function startAgentSession(request) {
       sessionRestorable: session.supportsLoadSession
     });
     sendThreadDeltas(bbThreadId, [{ kind: "session.reset" }]);
+    if (createdFreshSession) {
+      emitGrokContextWindow(session, 0);
+    }
     session.deferStartEmit = void 0;
     for (const deferred of deferredEmits) {
       if (deferred.sessionId !== void 0 && deferred.sessionId !== sessionId) {
@@ -9700,6 +9971,10 @@ function runTurn(session, firstInput) {
         }
         const result = await promptResult;
         stopReason = result.stopReason;
+        const grokUsage = grokContextUsageFromPromptResult(result);
+        if (grokUsage !== void 0) {
+          emitGrokContextWindow(session, grokUsage.used);
+        }
       } catch (error) {
         session.promptRequestPending = false;
         dropTurnInput(pending, "ACP turn failed before the prompt was sent");
@@ -9749,6 +10024,10 @@ function startCompaction(session, pending) {
   });
   acceptTurnInput(session, pending);
   session.turnSettled = promptResult.then((result) => {
+    const grokUsage = grokContextUsageFromPromptResult(result);
+    if (grokUsage !== void 0) {
+      emitGrokContextWindow(session, grokUsage.used);
+    }
     finish(
       result.stopReason === "end_turn" ? compactionOutcomeForEndTurn(
         session.dialect,
@@ -9925,12 +10204,12 @@ function decodeLaunchSpec(providerOptions) {
   );
   return launchSpec.success ? launchSpec.data : null;
 }
-var acpProviderOptionsSchema = z42.object({
-  additionalWorkspaceWriteRoots: z42.array(z42.string()).optional(),
-  acpDialect: z42.string().min(1).optional(),
-  parameterizedModelPicker: z42.boolean().optional(),
-  primaryModels: z42.array(z42.string().min(1)).optional(),
-  reasoningProbePriorityModelIds: z42.array(z42.string().min(1)).optional()
+var acpProviderOptionsSchema = z43.object({
+  additionalWorkspaceWriteRoots: z43.array(z43.string()).optional(),
+  acpDialect: z43.string().min(1).optional(),
+  parameterizedModelPicker: z43.boolean().optional(),
+  primaryModels: z43.array(z43.string().min(1)).optional(),
+  reasoningProbePriorityModelIds: z43.array(z43.string().min(1)).optional()
 }).passthrough();
 function decodeAcpModelPickerOptions(providerOptions) {
   const parsed = acpProviderOptionsSchema.parse(providerOptions ?? {});
@@ -9948,18 +10227,17 @@ function decodeAdditionalWorkspaceWriteRoots(providerOptions) {
 function decodeDialectId(providerOptions) {
   return acpProviderOptionsSchema.parse(providerOptions ?? {}).acpDialect;
 }
-function maintenanceForRequest(providerOptions, launchSpec) {
-  const dialectId = decodeDialectId(providerOptions);
-  return resolveAcpDialect({
-    ...dialectId === void 0 ? {} : { dialectId },
-    command: launchSpec?.command ?? ""
-  }).maintenance;
-}
 function maintenanceTarget(providerOptions) {
   const launchSpec = decodeLaunchSpec(providerOptions);
+  const dialect = resolveAcpDialect({
+    dialectId: decodeDialectId(providerOptions),
+    command: launchSpec?.command ?? ""
+  });
   return {
-    maintenance: maintenanceForRequest(providerOptions, launchSpec),
-    command: launchSpec?.command ?? null
+    maintenance: dialect.maintenance,
+    command: launchSpec?.command ?? null,
+    dialectId: dialect.id,
+    env: { ...process.env, ...launchSpec?.env }
   };
 }
 async function handleRequest2(request) {
@@ -10247,7 +10525,7 @@ var experimental_providerBridge = experimental_defineProviderBridge({
 });
 
 // ../provider-bridge-acp/src/probe.ts
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 var PROBE_TIMEOUT_MS = 1e4;
 function describe(error) {
   if (error instanceof AcpAgentExitedError) {
@@ -10305,9 +10583,9 @@ async function probeAcpAgent(request) {
     connected.kill();
   }
 }
-var acpAgentProbeSchema = z43.union([
-  z43.object({ reachable: z43.literal(true), fork: z43.boolean() }),
-  z43.object({ reachable: z43.literal(false), reason: z43.string() })
+var acpAgentProbeSchema = z44.union([
+  z44.object({ reachable: z44.literal(true), fork: z44.boolean() }),
+  z44.object({ reachable: z44.literal(false), reason: z44.string() })
 ]);
 export {
   acpAgentProbeSchema as experimental_acpAgentProbeSchema,