@rahularya01/pi-cursor 1.0.0

package/src/client/bridge.ts

@@ -0,0 +1,206 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { resolve as pathResolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const CURSOR_API_URL = "https://api2.cursor.sh";
+const CONNECT_END_STREAM_FLAG = 0b00000010;
+const BRIDGE_PATH = pathResolve(dirname(fileURLToPath(import.meta.url)), "h2-bridge.mjs");
+
+export interface SpawnBridgeOptions {
+  accessToken: string;
+  rpcPath: string;
+  url?: string;
+  unary?: boolean;
+}
+
+export interface BridgeHandle {
+  proc: Pick<ChildProcess, "kill">;
+  readonly alive: boolean;
+  write(data: Uint8Array): void;
+  end(): void;
+  onData(cb: (chunk: Buffer) => void): void;
+  onClose(cb: (code: number) => void): void;
+}
+
+export type BridgeFactory = (options: SpawnBridgeOptions) => BridgeHandle;
+export type BridgeDebugLog = (event: string, data?: Record<string, unknown>) => void;
+
+function noopDebugLog(): void {}
+
+type BridgeChildProcess = Pick<ChildProcess, "kill"> & {
+  on(event: string | symbol, listener: (...args: any[]) => void): unknown;
+  stdin?: NodeJS.WritableStream | null;
+  stdout?: NodeJS.ReadableStream | null;
+};
+
+export function lpEncode(data: Uint8Array): Buffer {
+  const buf = Buffer.alloc(4 + data.length);
+  buf.writeUInt32BE(data.length, 0);
+  buf.set(data, 4);
+  return buf;
+}
+
+export function frameConnectMessage(data: Uint8Array, flags = 0): Buffer {
+  const frame = Buffer.alloc(5 + data.length);
+  frame[0] = flags;
+  frame.writeUInt32BE(data.length, 1);
+  frame.set(data, 5);
+  return frame;
+}
+
+export function spawnBridge(
+  options: SpawnBridgeOptions,
+  debugLog: BridgeDebugLog = noopDebugLog,
+): BridgeHandle {
+  debugLog("bridge.spawn", {
+    rpcPath: options.rpcPath,
+    url: options.url ?? CURSOR_API_URL,
+    unary: options.unary ?? false,
+    cursorClientVersion: process.env.PI_CURSOR_CLIENT_VERSION || "cli-2026.05.01-eea359f",
+  });
+  const proc = spawn(process.execPath, [BRIDGE_PATH], {
+    stdio: ["pipe", "pipe", "ignore"],
+  });
+
+  return createBridgeHandleForChild(proc, options, debugLog);
+}
+
+function createBridgeHandleForChild(
+  proc: BridgeChildProcess,
+  options: SpawnBridgeOptions,
+  debugLog: BridgeDebugLog = noopDebugLog,
+): BridgeHandle {
+  const stdin = proc.stdin;
+  const stdout = proc.stdout;
+
+  const cbs = {
+    data: null as ((chunk: Buffer) => void) | null,
+    close: null as ((code: number) => void) | null,
+  };
+
+  let exited = false;
+  let exitCode = 1;
+  let stdinClosed = !stdin;
+  const markStdinClosed = (err?: unknown): void => {
+    stdinClosed = true;
+    if (err) {
+      debugLog("bridge.stdin_error", {
+        code:
+          typeof err === "object" && err !== null && "code" in err
+            ? String((err as { code?: unknown }).code)
+            : undefined,
+        message: err instanceof Error ? err.message : String(err),
+      });
+    }
+  };
+  stdin?.on?.("error", markStdinClosed);
+  stdin?.on?.("close", () => markStdinClosed());
+  stdin?.on?.("finish", () => markStdinClosed());
+
+  const safeWrite = (data: Uint8Array): void => {
+    if (!stdin || stdinClosed) return;
+    try {
+      stdin.write(lpEncode(data));
+    } catch (err) {
+      markStdinClosed(err);
+    }
+  };
+
+  const safeEnd = (): void => {
+    if (!stdin || stdinClosed) return;
+    try {
+      stdin.end();
+      stdinClosed = true;
+    } catch (err) {
+      markStdinClosed(err);
+    }
+  };
+
+  const config = JSON.stringify({
+    accessToken: options.accessToken,
+    url: options.url ?? CURSOR_API_URL,
+    path: options.rpcPath,
+    unary: options.unary ?? false,
+  });
+  safeWrite(new TextEncoder().encode(config));
+
+  let pending = Buffer.alloc(0);
+  stdout?.on("data", (chunk: Buffer) => {
+    pending = Buffer.concat([pending, chunk]);
+    while (pending.length >= 4) {
+      const len = pending.readUInt32BE(0);
+      if (pending.length < 4 + len) break;
+      const payload = pending.subarray(4, 4 + len);
+      pending = pending.subarray(4 + len);
+      cbs.data?.(Buffer.from(payload));
+    }
+  });
+
+  proc.on("exit", (code) => {
+    exited = true;
+    exitCode = code ?? 1;
+    debugLog("bridge.exit", { rpcPath: options.rpcPath, exitCode });
+    cbs.close?.(exitCode);
+  });
+
+  return {
+    proc,
+    get alive() {
+      return !exited;
+    },
+    write(data: Uint8Array) {
+      safeWrite(data);
+    },
+    end() {
+      safeWrite(new Uint8Array(0));
+      safeEnd();
+    },
+    onData(cb: (chunk: Buffer) => void) {
+      cbs.data = cb;
+    },
+    onClose(cb: (code: number) => void) {
+      if (exited) {
+        queueMicrotask(() => cb(exitCode));
+      } else {
+        cbs.close = cb;
+      }
+    },
+  };
+}
+
+export const __testInternals = {
+  createBridgeHandleForChild,
+};
+
+export function createConnectFrameParser(
+  onMessage: (bytes: Uint8Array) => void,
+  onEndStream: (bytes: Uint8Array) => void,
+): (incoming: Buffer) => void {
+  let pending = Buffer.alloc(0);
+  return (incoming: Buffer) => {
+    pending = Buffer.concat([pending, incoming]);
+    while (pending.length >= 5) {
+      const flags = pending[0]!;
+      const msgLen = pending.readUInt32BE(1);
+      if (pending.length < 5 + msgLen) break;
+      const messageBytes = pending.subarray(5, 5 + msgLen);
+      pending = pending.subarray(5 + msgLen);
+      if (flags & CONNECT_END_STREAM_FLAG) onEndStream(messageBytes);
+      else onMessage(messageBytes);
+    }
+  };
+}
+
+export function parseConnectEndStream(data: Uint8Array): Error | null {
+  try {
+    const payload = JSON.parse(new TextDecoder().decode(data));
+    const error = payload?.error;
+    if (error)
+      return new Error(
+        `Connect error ${error.code ?? "unknown"}: ${error.message ?? "Unknown error"}`,
+      );
+    return null;
+  } catch {
+    return new Error("Failed to parse Connect end stream");
+  }
+}

package/src/client/cursor-wire.ts

@@ -0,0 +1,212 @@
+export interface CursorModelParameter {
+  id: string;
+  value: string;
+}
+
+export interface CursorParameterizedVariant {
+  parameters: CursorModelParameter[];
+  isMaxMode: boolean;
+  isDefaultMaxConfig?: boolean;
+  isDefaultNonMaxConfig?: boolean;
+  displayName?: string;
+  displayNameOutsidePicker?: string;
+  variantStringRepresentation?: string;
+}
+
+export interface CursorParameterizedModel {
+  name: string;
+  clientDisplayName?: string;
+  serverModelName?: string;
+  supportsMaxMode?: boolean;
+  supportsNonMaxMode?: boolean;
+  supportsImages?: boolean;
+  contextTokenLimit?: number;
+  contextTokenLimitForMaxMode?: number;
+  variants: CursorParameterizedVariant[];
+}
+
+function encodeVarint(value: number): number[] {
+  const out: number[] = [];
+  let v = value >>> 0;
+  while (v >= 0x80) {
+    out.push((v & 0x7f) | 0x80);
+    v >>>= 7;
+  }
+  out.push(v);
+  return out;
+}
+
+function encodeBoolField(fieldNo: number, value: boolean): number[] {
+  return [...encodeVarint(fieldNo << 3), value ? 1 : 0];
+}
+
+export function encodeAvailableModelsRequest(): Uint8Array {
+  // aiserver.v1.AvailableModelsRequest {
+  //   optional bool use_model_parameters = 5;
+  //   optional bool do_not_use_markdown = 7;
+  // }
+  return new Uint8Array([...encodeBoolField(5, true), ...encodeBoolField(7, true)]);
+}
+
+interface WireReader {
+  bytes: Uint8Array;
+  offset: number;
+}
+
+function readVarint(reader: WireReader): number {
+  let result = 0;
+  let shift = 0;
+  while (reader.offset < reader.bytes.length) {
+    const byte = reader.bytes[reader.offset++]!;
+    // Avoid JS bitwise operators here: they truncate to 32 bits, but protobuf
+    // varints can legally carry 64-bit values on fields we merely skip.
+    if (shift < 53) result += (byte & 0x7f) * 2 ** shift;
+    if ((byte & 0x80) === 0) return result;
+    shift += 7;
+    if (shift >= 70) throw new Error("varint too long");
+  }
+  throw new Error("unexpected EOF while reading varint");
+}
+
+function readLengthDelimited(reader: WireReader): Uint8Array {
+  const length = readVarint(reader);
+  if (!Number.isSafeInteger(length)) throw new Error("length-delimited size is too large");
+  const end = reader.offset + length;
+  if (end > reader.bytes.length) throw new Error("length-delimited field exceeds buffer");
+  const value = reader.bytes.subarray(reader.offset, end);
+  reader.offset = end;
+  return value;
+}
+
+function skipBytes(reader: WireReader, length: number): void {
+  const end = reader.offset + length;
+  if (end > reader.bytes.length) throw new Error("fixed-width field exceeds buffer");
+  reader.offset = end;
+}
+
+function skipWireField(reader: WireReader, wireType: number): void {
+  switch (wireType) {
+    case 0:
+      readVarint(reader);
+      return;
+    case 1:
+      skipBytes(reader, 8);
+      return;
+    case 2:
+      readLengthDelimited(reader);
+      return;
+    case 5:
+      skipBytes(reader, 4);
+      return;
+    default:
+      throw new Error(`unsupported wire type ${wireType}`);
+  }
+}
+
+function decodeString(bytes: Uint8Array): string {
+  return new TextDecoder().decode(bytes);
+}
+
+function decodeModelParameter(bytes: Uint8Array): CursorModelParameter {
+  const reader: WireReader = { bytes, offset: 0 };
+  const parameter: CursorModelParameter = { id: "", value: "" };
+  while (reader.offset < bytes.length) {
+    const tag = readVarint(reader);
+    const fieldNo = tag >>> 3;
+    const wireType = tag & 0x7;
+    if (fieldNo === 1 && wireType === 2) parameter.id = decodeString(readLengthDelimited(reader));
+    else if (fieldNo === 2 && wireType === 2)
+      parameter.value = decodeString(readLengthDelimited(reader));
+    else skipWireField(reader, wireType);
+  }
+  return parameter;
+}
+
+function decodeParameterizedVariant(bytes: Uint8Array): CursorParameterizedVariant {
+  const reader: WireReader = { bytes, offset: 0 };
+  const variant: CursorParameterizedVariant = { parameters: [], isMaxMode: false };
+  while (reader.offset < bytes.length) {
+    const tag = readVarint(reader);
+    const fieldNo = tag >>> 3;
+    const wireType = tag & 0x7;
+    if (fieldNo === 1 && wireType === 2)
+      variant.parameters.push(decodeModelParameter(readLengthDelimited(reader)));
+    else if (fieldNo === 2 && wireType === 2)
+      variant.displayName = decodeString(readLengthDelimited(reader));
+    else if (fieldNo === 8 && wireType === 2)
+      variant.displayNameOutsidePicker = decodeString(readLengthDelimited(reader));
+    else if (fieldNo === 3 && wireType === 0) variant.isMaxMode = readVarint(reader) !== 0;
+    else if (fieldNo === 4 && wireType === 0) variant.isDefaultMaxConfig = readVarint(reader) !== 0;
+    else if (fieldNo === 5 && wireType === 0)
+      variant.isDefaultNonMaxConfig = readVarint(reader) !== 0;
+    else if (fieldNo === 9 && wireType === 2)
+      variant.variantStringRepresentation = decodeString(readLengthDelimited(reader));
+    else skipWireField(reader, wireType);
+  }
+  return variant;
+}
+
+function decodeParameterizedModel(bytes: Uint8Array): CursorParameterizedModel {
+  const reader: WireReader = { bytes, offset: 0 };
+  const model: CursorParameterizedModel = { name: "", variants: [] };
+  while (reader.offset < bytes.length) {
+    const tag = readVarint(reader);
+    const fieldNo = tag >>> 3;
+    const wireType = tag & 0x7;
+    if (fieldNo === 1 && wireType === 2) model.name = decodeString(readLengthDelimited(reader));
+    else if (fieldNo === 10 && wireType === 0) model.supportsImages = readVarint(reader) !== 0;
+    else if (fieldNo === 14 && wireType === 0) model.supportsMaxMode = readVarint(reader) !== 0;
+    else if (fieldNo === 19 && wireType === 0) model.supportsNonMaxMode = readVarint(reader) !== 0;
+    else if (fieldNo === 15 && wireType === 0) model.contextTokenLimit = readVarint(reader);
+    else if (fieldNo === 16 && wireType === 0)
+      model.contextTokenLimitForMaxMode = readVarint(reader);
+    else if (fieldNo === 17 && wireType === 2)
+      model.clientDisplayName = decodeString(readLengthDelimited(reader));
+    else if (fieldNo === 18 && wireType === 2)
+      model.serverModelName = decodeString(readLengthDelimited(reader));
+    else if (fieldNo === 30 && wireType === 2)
+      model.variants.push(decodeParameterizedVariant(readLengthDelimited(reader)));
+    else skipWireField(reader, wireType);
+  }
+  return model;
+}
+
+export function decodeAvailableModelsResponse(bytes: Uint8Array): CursorParameterizedModel[] {
+  const reader: WireReader = { bytes, offset: 0 };
+  const models: CursorParameterizedModel[] = [];
+  while (reader.offset < bytes.length) {
+    const tag = readVarint(reader);
+    const fieldNo = tag >>> 3;
+    const wireType = tag & 0x7;
+    if (fieldNo === 2 && wireType === 2) {
+      const model = decodeParameterizedModel(readLengthDelimited(reader));
+      if (model.name) models.push(model);
+    } else {
+      skipWireField(reader, wireType);
+    }
+  }
+  return models;
+}
+
+// No generated schema for selectedContextBlob; emit raw wire format for the two
+// fields Cursor actually reads: field 1 (repeated bytes) rootPromptMessagesJson
+// refs, field 22 (string) clientName. blobId.length < 128 (SHA256 = 32 bytes).
+export function buildSelectedContextBlob(
+  rootPromptBlobIds: Uint8Array[],
+  clientName: string,
+): Uint8Array {
+  const parts: Uint8Array[] = [];
+  for (const blobId of rootPromptBlobIds) {
+    parts.push(new Uint8Array([0x0a, blobId.length, ...blobId]));
+  }
+  const clientBytes = new TextEncoder().encode(clientName);
+  parts.push(new Uint8Array([0xb2, 0x01, clientBytes.length, ...clientBytes]));
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const result = new Uint8Array(total);
+  let offset = 0;
+  for (const p of parts) {
+    result.set(p, offset);
+    offset += p.length;
+  }
+  return result;
+}

package/src/client/h2-bridge.mjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+/**
+ * Dumb HTTP/2 bidirectional pipe for Cursor gRPC.
+ *
+ * Originally from https://github.com/ephraimduncan/opencode-cursor by Ephraim Duncan (MIT).
+ *
+ * Bun's node:http2 is broken. This Node script acts as a transparent
+ * HTTP/2 proxy: it opens a single bidirectional stream and ferries
+ * raw bytes between the parent process (via stdin/stdout) and Cursor.
+ *
+ * Protocol (length-prefixed framing over stdin/stdout):
+ *   [4 bytes big-endian length][payload]
+ *
+ * First message on stdin is JSON config:
+ *   { "accessToken": "...", "url": "...", "path": "...", "unary": false }
+ *
+ * When unary=true, the bridge uses application/proto (raw protobuf) instead
+ * of application/connect+proto (Connect streaming). The single stdin message
+ * is written as the request body and the stream is ended immediately.
+ * After config, subsequent stdin messages are raw bytes to write to the H2 stream.
+ * H2 response data is written to stdout using the same length-prefixed framing.
+ */
+import http2 from "node:http2";
+import crypto from "node:crypto";
+
+const CURSOR_CLIENT_VERSION = process.env.PI_CURSOR_CLIENT_VERSION || "cli-2026.05.01-eea359f";
+
+/** Write one length-prefixed message to stdout. */
+function writeMessage(data) {
+  const lenBuf = Buffer.alloc(4);
+  lenBuf.writeUInt32BE(data.length, 0);
+  process.stdout.write(lenBuf);
+  process.stdout.write(data);
+}
+
+function connectEndStreamError(code, message) {
+  const payload = Buffer.from(JSON.stringify({ error: { code, message } }), "utf8");
+  const frame = Buffer.alloc(5 + payload.length);
+  frame[0] = 0b00000010;
+  frame.writeUInt32BE(payload.length, 1);
+  payload.copy(frame, 5);
+  return frame;
+}
+
+// --- Buffered stdin reader ---
+
+let stdinBuf = Buffer.alloc(0);
+let stdinResolve = null;
+let stdinEnded = false;
+
+process.stdin.on("data", (chunk) => {
+  stdinBuf = Buffer.concat([stdinBuf, chunk]);
+  if (stdinResolve) {
+    const r = stdinResolve;
+    stdinResolve = null;
+    r();
+  }
+});
+
+process.stdin.on("end", () => {
+  stdinEnded = true;
+  if (stdinResolve) {
+    const r = stdinResolve;
+    stdinResolve = null;
+    r();
+  }
+});
+
+function waitForData() {
+  return new Promise((resolve) => {
+    stdinResolve = resolve;
+  });
+}
+
+async function readExact(n) {
+  while (stdinBuf.length < n) {
+    if (stdinEnded) return null;
+    await waitForData();
+  }
+  const result = stdinBuf.subarray(0, n);
+  stdinBuf = stdinBuf.subarray(n);
+  return Buffer.from(result);
+}
+
+async function readMessage() {
+  const lenBuf = await readExact(4);
+  if (!lenBuf) return null;
+  const len = lenBuf.readUInt32BE(0);
+  if (len === 0) return Buffer.alloc(0);
+  return readExact(len);
+}
+
+// --- Main ---
+
+const configBuf = await readMessage();
+if (!configBuf) process.exit(1);
+
+const config = JSON.parse(configBuf.toString("utf8"));
+const { accessToken, url, path: rpcPath, unary } = config;
+
+const client = http2.connect(url || "https://api2.cursor.sh");
+
+// Guard against initial connection failure. Reset on any h2 activity
+// so long-running agent conversations (with tool call round-trips) survive.
+let timeout = setTimeout(killBridge, 30_000);
+
+function resetTimeout() {
+  clearTimeout(timeout);
+  timeout = setTimeout(killBridge, 120_000);
+}
+
+function killBridge() {
+  clearTimeout(timeout);
+  client.destroy();
+  process.exit(1);
+}
+
+client.on("error", () => {
+  clearTimeout(timeout);
+  process.exit(1);
+});
+
+const headers = {
+  ":method": "POST",
+  ":path": rpcPath || "/agent.v1.AgentService/Run",
+  "content-type": unary ? "application/proto" : "application/connect+proto",
+  "connect-protocol-version": "1",
+  te: "trailers",
+  authorization: `Bearer ${accessToken}`,
+  "x-ghost-mode": "true",
+  "x-cursor-client-version": CURSOR_CLIENT_VERSION,
+  "x-cursor-client-type": "cli",
+  "x-request-id": crypto.randomUUID(),
+};
+const h2Stream = client.request(headers);
+let responseStatus = 0;
+let responseStatusText = "";
+const errorChunks = [];
+const isErrorStatus = () => responseStatus !== 0 && (responseStatus < 200 || responseStatus >= 300);
+
+h2Stream.on("response", (responseHeaders) => {
+  resetTimeout();
+  responseStatus = Number(responseHeaders[":status"] || 0);
+  responseStatusText =
+    responseHeaders["grpc-message"] || responseHeaders["connect-error-message"] || "";
+});
+
+// Forward H2 response data → stdout (length-prefixed)
+h2Stream.on("data", (chunk) => {
+  resetTimeout();
+  if (isErrorStatus()) {
+    errorChunks.push(Buffer.from(chunk));
+  } else {
+    writeMessage(chunk);
+  }
+});
+
+h2Stream.on("end", () => {
+  clearTimeout(timeout);
+  client.close();
+  if (isErrorStatus()) {
+    const body = Buffer.concat(errorChunks).toString("utf8").trim();
+    const detail = responseStatusText || body || "HTTP/2 upstream request failed";
+    writeMessage(
+      connectEndStreamError(`http_${responseStatus}`, `Cursor HTTP ${responseStatus}: ${detail}`),
+    );
+    setTimeout(() => process.exit(1), 100);
+    return;
+  }
+  // Give stdout time to flush
+  setTimeout(() => process.exit(0), 100);
+});
+
+h2Stream.on("error", () => {
+  clearTimeout(timeout);
+  client.close();
+  process.exit(1);
+});
+
+// Forward stdin → H2 stream (after config message)
+if (unary) {
+  // Unary mode: read a single body message, write it, and end the stream.
+  const body = await readMessage();
+  if (body && body.length > 0 && !h2Stream.closed && !h2Stream.destroyed) {
+    h2Stream.end(body);
+  } else {
+    h2Stream.end();
+  }
+} else {
+  // Streaming mode: forward all stdin messages as Connect frames.
+  (async () => {
+    while (true) {
+      const msg = await readMessage();
+      if (!msg || msg.length === 0) {
+        // EOF or zero-length = done writing
+        break;
+      }
+      if (!h2Stream.closed && !h2Stream.destroyed) {
+        resetTimeout();
+        h2Stream.write(msg);
+      }
+    }
+
+    if (!h2Stream.closed && !h2Stream.destroyed) {
+      h2Stream.end();
+    }
+  })();
+}

package/src/client/index.ts

@@ -0,0 +1,19 @@
+export {
+  spawnBridge,
+  createConnectFrameParser,
+  frameConnectMessage,
+  parseConnectEndStream,
+  lpEncode,
+  type BridgeHandle,
+  type BridgeFactory,
+  type SpawnBridgeOptions,
+} from "./bridge.js";
+export {
+  encodeAvailableModelsRequest,
+  decodeAvailableModelsResponse,
+  buildSelectedContextBlob,
+  type CursorModelParameter,
+  type CursorParameterizedModel,
+  type CursorParameterizedVariant,
+} from "./cursor-wire.js";
+export { getCursorAgentUrl } from "../stream/native-core.js";

package/src/diagnostics/diagnostics.ts

@@ -0,0 +1,62 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { redactSecrets } from "../utils/security.js";
+
+export type DiagnosticsSnapshot = {
+  status?: number;
+  endpoint?: string;
+  error?: string;
+  projectId?: string;
+  resolvedRuntimeModel?: string;
+  availableModels?: string;
+  matchedModelDebug?: string;
+  lastRpc?: string;
+};
+
+const storage = new AsyncLocalStorage<DiagnosticsSnapshot>();
+let lastSnapshot: DiagnosticsSnapshot = {};
+
+function currentBag(): DiagnosticsSnapshot {
+  return storage.getStore() ?? lastSnapshot;
+}
+
+export async function runWithDiagnostics<T>(fn: () => Promise<T>): Promise<T> {
+  const bag: DiagnosticsSnapshot = {};
+  return storage.run(bag, async () => {
+    try {
+      return await fn();
+    } finally {
+      lastSnapshot = { ...bag };
+    }
+  });
+}
+
+export function getLastDiagnostics(): Readonly<DiagnosticsSnapshot> {
+  return lastSnapshot;
+}
+
+export function setLastStatus(status: number | undefined): void {
+  currentBag().status = status;
+}
+export function setLastEndpoint(endpoint: string | undefined): void {
+  currentBag().endpoint = endpoint;
+}
+export function setLastError(error: string | undefined): void {
+  currentBag().error = error === undefined ? undefined : redactSecrets(error).slice(0, 800);
+}
+export function setLastResolvedRuntimeModel(model: string | undefined): void {
+  currentBag().resolvedRuntimeModel = model;
+}
+export function setLastAvailableModels(models: string | undefined): void {
+  currentBag().availableModels = models;
+}
+export function setLastRpc(rpc: string | undefined): void {
+  currentBag().lastRpc = rpc;
+}
+export function setLastMatchedModelDebug(debug: string | undefined): void {
+  currentBag().matchedModelDebug =
+    debug === undefined ? undefined : redactSecrets(debug).slice(0, 1200);
+}
+
+export function resetDiagnosticsForTests(): void {
+  lastSnapshot = {};
+}

package/src/diagnostics/index.ts

@@ -0,0 +1 @@
+export * from "./diagnostics.js";