march-cli 0.1.34 → 0.1.36

package/src/agent/code-search/retrieval/model2vec.mjs

@@ -0,0 +1,96 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { readSafetensors } from "./safetensors.mjs";
+import { normalizedVector } from "./vector.mjs";
+import { WordPieceTokenizer } from "./wordpiece.mjs";
+
+export const POTION_CODE_MODEL_ID = "minishlab/potion-code-16M";
+const HF_RESOLVE_BASE = "https://huggingface.co";
+const MODEL_FILES = ["config.json", "tokenizer.json", "model.safetensors"];
+
+export class Model2VecVectorizer {
+  constructor({ modelDir, modelId = POTION_CODE_MODEL_ID, allowDownload = true } = {}) {
+    if (!modelDir) throw new Error("Model2VecVectorizer requires modelDir");
+    this.modelDir = modelDir;
+    this.modelId = modelId;
+    this.allowDownload = allowDownload;
+    this.id = `model2vec:${modelId}`;
+    this.dimensions = 256;
+    this.modelPromise = null;
+  }
+
+  async encode(texts) {
+    const model = await this.load();
+    return texts.map((text) => model.encode(text));
+  }
+
+  async load() {
+    this.modelPromise ??= this.loadModel();
+    return this.modelPromise;
+  }
+
+  async loadModel() {
+    await ensureModelFiles({ modelDir: this.modelDir, modelId: this.modelId, allowDownload: this.allowDownload });
+    const config = JSON.parse(await readFile(join(this.modelDir, "config.json"), "utf8"));
+    const tokenizerJson = JSON.parse(await readFile(join(this.modelDir, "tokenizer.json"), "utf8"));
+    const tensors = await readSafetensors(join(this.modelDir, "model.safetensors"));
+    const embeddings = tensors.getTensor(tensors.names.includes("embeddings") ? "embeddings" : "embedding.weight");
+    const weights = tensors.names.includes("weights") ? tensors.getTensor("weights") : null;
+    const mapping = tensors.names.includes("mapping") ? tensors.getTensor("mapping") : null;
+    const model = new LoadedModel2Vec({ config, tokenizerJson, embeddings, weights, mapping });
+    this.dimensions = model.dimensions;
+    return model;
+  }
+}
+
+export async function ensureModelFiles({ modelDir, modelId = POTION_CODE_MODEL_ID, allowDownload = true }) {
+  const missing = MODEL_FILES.filter((name) => !existsSync(join(modelDir, name)));
+  if (missing.length === 0) return;
+  if (!allowDownload) throw new Error(`Missing Model2Vec files in ${modelDir}: ${missing.join(", ")}`);
+  await mkdir(modelDir, { recursive: true });
+  for (const name of missing) await downloadModelFile({ modelDir, modelId, name });
+}
+
+class LoadedModel2Vec {
+  constructor({ config, tokenizerJson, embeddings, weights, mapping }) {
+    this.normalize = config?.normalize !== false;
+    this.tokenizer = new WordPieceTokenizer(tokenizerJson);
+    this.embeddings = embeddings.values;
+    this.vocabularySize = embeddings.shape[0];
+    this.dimensions = embeddings.shape[1];
+    this.weights = weights?.values ?? null;
+    this.mapping = mapping?.values ?? null;
+  }
+
+  encode(text) {
+    const ids = this.tokenizer.encode(text);
+    const values = new Float32Array(this.dimensions);
+    let count = 0;
+    for (const id of ids) {
+      const mapped = this.mapping ? this.mapping[id] : id;
+      if (mapped == null || mapped < 0 || mapped >= this.vocabularySize) continue;
+      const weight = this.weights?.[id] ?? 1;
+      const offset = mapped * this.dimensions;
+      for (let dim = 0; dim < this.dimensions; dim += 1) values[dim] += this.embeddings[offset + dim] * weight;
+      count += 1;
+    }
+    if (count > 0) for (let dim = 0; dim < this.dimensions; dim += 1) values[dim] /= count;
+    const vector = normalizedVector(values);
+    if (this.normalize && vector.norm > 0) {
+      for (let dim = 0; dim < values.length; dim += 1) values[dim] /= vector.norm;
+      return normalizedVector(values);
+    }
+    return vector;
+  }
+}
+
+async function downloadModelFile({ modelDir, modelId, name }) {
+  const url = `${HF_RESOLVE_BASE}/${modelId}/resolve/main/${name}`;
+  const response = await fetch(url, { redirect: "follow" });
+  if (!response.ok) throw new Error(`Failed to download ${modelId}/${name}: HTTP ${response.status}`);
+  const target = join(modelDir, name);
+  const tmpPath = join(dirname(target), `${basename(target)}.${process.pid}.tmp`);
+  await writeFile(tmpPath, new Uint8Array(await response.arrayBuffer()));
+  await rename(tmpPath, target);
+}

package/src/agent/code-search/retrieval/safetensors.mjs

@@ -0,0 +1,49 @@
+import { readFile } from "node:fs/promises";
+
+const HEADER_BYTES = 8;
+const DTYPE_READERS = {
+  F32: { size: 4, read: (view, offset) => view.getFloat32(offset, true) },
+  F64: { size: 8, read: (view, offset) => view.getFloat64(offset, true) },
+  I32: { size: 4, read: (view, offset) => view.getInt32(offset, true) },
+  I64: { size: 8, read: (view, offset) => Number(view.getBigInt64(offset, true)) },
+  U32: { size: 4, read: (view, offset) => view.getUint32(offset, true) },
+  U64: { size: 8, read: (view, offset) => Number(view.getBigUint64(offset, true)) },
+};
+
+export async function readSafetensors(filePath) {
+  const buffer = await readFile(filePath);
+  return parseSafetensors(buffer);
+}
+
+export function parseSafetensors(buffer) {
+  const data = toArrayBuffer(buffer);
+  const headerLength = Number(new DataView(data, 0, HEADER_BYTES).getBigUint64(0, true));
+  const headerStart = HEADER_BYTES;
+  const headerEnd = headerStart + headerLength;
+  const headerJson = new TextDecoder().decode(new Uint8Array(data, headerStart, headerLength));
+  const header = JSON.parse(headerJson);
+  return {
+    names: Object.keys(header).filter((name) => name !== "__metadata__"),
+    getTensor(name) {
+      const descriptor = header[name];
+      if (!descriptor) throw new Error(`Missing safetensors tensor: ${name}`);
+      return readTensor(data, headerEnd, descriptor);
+    },
+  };
+}
+
+function readTensor(data, dataStart, descriptor) {
+  const reader = DTYPE_READERS[descriptor.dtype];
+  if (!reader) throw new Error(`Unsupported safetensors dtype: ${descriptor.dtype}`);
+  const [start, end] = descriptor.data_offsets;
+  const byteOffset = dataStart + start;
+  const length = (end - start) / reader.size;
+  const view = new DataView(data, byteOffset, end - start);
+  const values = new Float32Array(length);
+  for (let index = 0; index < length; index += 1) values[index] = reader.read(view, index * reader.size);
+  return { values, shape: descriptor.shape, dtype: descriptor.dtype };
+}
+
+function toArrayBuffer(buffer) {
+  return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+}

package/src/agent/code-search/retrieval/vector.mjs

@@ -0,0 +1,107 @@
+import { tokenize } from "../tokenize.mjs";
+
+const DEFAULT_DIMENSIONS = 256;
+const SEMANTIC_MIN_SCORE = 0.05;
+
+export class LocalVectorIndex {
+  constructor(chunks, vectors, { vectorizer = defaultVectorizer } = {}) {
+    this.chunks = chunks;
+    this.dimensions = vectorizer.dimensions;
+    this.vectorizer = vectorizer;
+    this.vectors = vectors;
+  }
+
+  static async create(chunks, { vectorizer = defaultVectorizer } = {}) {
+    const vectors = await vectorizer.encode(chunks.map(chunkVectorText));
+    return new LocalVectorIndex(chunks, vectors, { vectorizer });
+  }
+
+  async search(query, { limit = 50 } = {}) {
+    const [queryVector] = await this.vectorizer.encode([query]);
+    return this.searchVector(queryVector, { limit });
+  }
+
+  searchVector(queryVector, { limit = 50 } = {}) {
+    if (queryVector.norm === 0) return [];
+    const scored = [];
+    for (let index = 0; index < this.vectors.length; index += 1) {
+      const score = cosineSimilarity(queryVector, this.vectors[index]);
+      if (score >= SEMANTIC_MIN_SCORE) scored.push({ chunk: this.chunks[index], score });
+    }
+    scored.sort((a, b) => b.score - a.score || a.chunk.file_path.localeCompare(b.chunk.file_path));
+    return scored.slice(0, limit);
+  }
+}
+
+export class HashingVectorizer {
+  constructor({ dimensions = DEFAULT_DIMENSIONS } = {}) {
+    this.id = `hashing-${dimensions}`;
+    this.dimensions = dimensions;
+  }
+
+  async encode(texts) {
+    return texts.map((text) => vectorizeText(text, this.dimensions));
+  }
+}
+
+export const defaultVectorizer = new HashingVectorizer();
+
+function chunkVectorText(chunk) {
+  return [
+    chunk.file_path,
+    chunk.symbols.join(" "),
+    chunk.identifiers.join(" "),
+    chunk.content,
+  ].join("\n");
+}
+
+function vectorizeText(text, dimensions) {
+  const values = new Float32Array(dimensions);
+  const tokens = tokenize(text);
+  for (const token of tokens) {
+    addFeature(values, token, 1);
+    for (const gram of charTrigrams(token)) addFeature(values, gram, 0.35);
+  }
+  return normalizedVector(values);
+}
+
+export function normalizedVector(values) {
+  return { values, norm: vectorNorm(values) };
+}
+
+function addFeature(values, feature, weight) {
+  const hash = hashString(feature);
+  const index = hash % values.length;
+  const sign = hash & 1 ? 1 : -1;
+  values[index] += sign * weight;
+}
+
+function charTrigrams(token) {
+  const padded = `^${token}$`;
+  if (padded.length <= 3) return [padded];
+  const grams = [];
+  for (let index = 0; index <= padded.length - 3; index += 1) grams.push(padded.slice(index, index + 3));
+  return grams;
+}
+
+function cosineSimilarity(left, right) {
+  if (left.norm === 0 || right.norm === 0) return 0;
+  let dot = 0;
+  for (let index = 0; index < left.values.length; index += 1) dot += left.values[index] * right.values[index];
+  return dot / (left.norm * right.norm);
+}
+
+function vectorNorm(values) {
+  let sum = 0;
+  for (const value of values) sum += value * value;
+  return Math.sqrt(sum);
+}
+
+function hashString(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}

package/src/agent/code-search/retrieval/wordpiece.mjs

@@ -0,0 +1,82 @@
+const MAX_INPUT_CHARS_PER_WORD = 100;
+
+export class WordPieceTokenizer {
+  constructor(tokenizerJson) {
+    const model = tokenizerJson?.model ?? {};
+    this.vocab = model.vocab ?? {};
+    this.unkToken = model.unk_token ?? "[UNK]";
+    this.unkId = this.vocab[this.unkToken] ?? 1;
+    this.prefix = model.continuing_subword_prefix ?? "##";
+    this.lowercase = tokenizerJson?.normalizer?.lowercase !== false;
+    this.maxInputCharsPerWord = model.max_input_chars_per_word ?? MAX_INPUT_CHARS_PER_WORD;
+  }
+
+  encode(text, { maxLength = 512 } = {}) {
+    const ids = [];
+    for (const token of preTokenize(normalizeText(text, { lowercase: this.lowercase }))) {
+      for (const id of this.wordPiece(token)) {
+        if (id !== this.unkId) ids.push(id);
+        if (ids.length >= maxLength) return ids;
+      }
+    }
+    return ids;
+  }
+
+  wordPiece(token) {
+    if (!token) return [];
+    if (token.length > this.maxInputCharsPerWord) return [this.unkId];
+    const ids = [];
+    let start = 0;
+    while (start < token.length) {
+      let end = token.length;
+      let current = null;
+      while (start < end) {
+        const piece = start === 0 ? token.slice(start, end) : `${this.prefix}${token.slice(start, end)}`;
+        if (Object.hasOwn(this.vocab, piece)) {
+          current = piece;
+          break;
+        }
+        end -= 1;
+      }
+      if (current === null) return [this.unkId];
+      ids.push(this.vocab[current]);
+      start = end;
+    }
+    return ids;
+  }
+}
+
+function normalizeText(text, { lowercase }) {
+  let normalized = String(text ?? "").replace(/[\t\n\r]+/g, " ");
+  normalized = normalized.replace(/[\u0000-\u001f\u007f]/g, " ");
+  return lowercase ? normalized.toLowerCase() : normalized;
+}
+
+function preTokenize(text) {
+  const tokens = [];
+  let current = "";
+  for (const char of text) {
+    if (/\s/u.test(char)) {
+      pushCurrent();
+    } else if (isPunctuation(char)) {
+      pushCurrent();
+      tokens.push(char);
+    } else {
+      current += char;
+    }
+  }
+  pushCurrent();
+  return tokens;
+
+  function pushCurrent() {
+    if (current) tokens.push(current);
+    current = "";
+  }
+}
+
+function isPunctuation(char) {
+  const code = char.codePointAt(0);
+  if ((code >= 33 && code <= 47) || (code >= 58 && code <= 64)) return true;
+  if ((code >= 91 && code <= 96) || (code >= 123 && code <= 126)) return true;
+  return /\p{P}/u.test(char);
+}

package/src/agent/code-search/scanner.mjs

@@ -0,0 +1,84 @@
+import { execFile } from "node:child_process";
+import { lstat, readdir, readFile, stat } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { resolveRipgrepCommand } from "../../memory/markdown/ripgrep.mjs";
+import { isSearchableTextPath, languageForPath } from "./languages.mjs";
+
+const DEFAULT_MAX_FILES = 2_000;
+const DEFAULT_MAX_FILE_BYTES = 512 * 1024;
+const SKIP_DIRS = new Set([".git", "node_modules", "dist", "build", "coverage", ".next", ".turbo", ".cache"]);
+
+export async function scanCodeFiles({ root, path = ".", maxFiles = DEFAULT_MAX_FILES, maxFileBytes = DEFAULT_MAX_FILE_BYTES } = {}) {
+  const rootPath = resolve(root);
+  const base = resolve(rootPath, path);
+  const baseRel = relative(rootPath, base);
+  if (baseRel.startsWith("..") || isAbsolute(baseRel)) throw new Error(`Search path escapes workspace: ${path}`);
+  let baseInfo;
+  try { baseInfo = await stat(base); } catch { return []; }
+  const candidates = baseInfo.isFile()
+    ? [relative(rootPath, base).replace(/\\/g, "/")]
+    : await listCandidateFiles(rootPath, base);
+  const files = [];
+  for (const relPath of [...candidates].sort()) {
+    if (files.length >= maxFiles) break;
+    if (!isSearchableTextPath(relPath)) continue;
+    const absPath = resolve(root, relPath);
+    let info;
+    try { info = await stat(absPath); } catch { continue; }
+    if (!info.isFile() || info.size > maxFileBytes) continue;
+    const content = await readUtf8Text(absPath);
+    if (content === null) continue;
+    files.push({
+      absPath,
+      relPath: relPath.replace(/\\/g, "/"),
+      language: languageForPath(relPath),
+      content,
+      size: info.size,
+      mtimeMs: info.mtimeMs,
+    });
+  }
+  return files;
+}
+
+async function listCandidateFiles(root, base) {
+  const fromRipgrep = await listRipgrepFiles(root, base);
+  if (fromRipgrep) return fromRipgrep;
+  return listFilesRecursively(root, base);
+}
+
+function listRipgrepFiles(root, base) {
+  return new Promise((resolveResult) => {
+    const command = resolveRipgrepCommand();
+    const args = ["--files", "--hidden", "--glob", "!.git/**", "--glob", "!node_modules/**"];
+    execFile(command, args, { cwd: base, maxBuffer: 50 * 1024 * 1024 }, (error, stdout) => {
+      if (error) return resolveResult(null);
+      const baseRel = relative(root, base).replace(/\\/g, "/");
+      const prefix = baseRel ? `${baseRel}/` : "";
+      resolveResult(stdout.split(/\r?\n/).filter(Boolean).map((file) => `${prefix}${file.replace(/\\/g, "/")}`));
+    });
+  });
+}
+
+async function listFilesRecursively(root, dir) {
+  let entries;
+  try { entries = await readdir(dir, { withFileTypes: true }); } catch { return []; }
+  const files = [];
+  for (const entry of entries) {
+    if (entry.isDirectory() && SKIP_DIRS.has(entry.name)) continue;
+    const absPath = join(dir, entry.name);
+    if (entry.isDirectory()) files.push(...await listFilesRecursively(root, absPath));
+    else if (entry.isFile()) files.push(relative(root, absPath).replace(/\\/g, "/"));
+  }
+  return files;
+}
+
+async function readUtf8Text(path) {
+  try {
+    if ((await lstat(path)).isSymbolicLink()) return null;
+    const buffer = await readFile(path);
+    if (buffer.includes(0)) return null;
+    return buffer.toString("utf8");
+  } catch {
+    return null;
+  }
+}

package/src/agent/code-search/tokenize.mjs

@@ -0,0 +1,16 @@
+const STOP_WORDS = new Set([
+  "a", "an", "and", "are", "as", "at", "be", "by", "for", "from", "how", "in", "is", "it", "of", "on", "or", "that", "the", "this", "to", "with",
+]);
+
+export function tokenize(text) {
+  const raw = String(text ?? "")
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[_\-./\\:]+/g, " ")
+    .toLowerCase()
+    .match(/[a-z0-9]+/g) ?? [];
+  return raw.filter((token) => token.length > 1 && !STOP_WORDS.has(token));
+}
+
+export function uniqueTokens(text) {
+  return [...new Set(tokenize(text))];
+}

package/src/agent/code-search/tool.mjs

@@ -0,0 +1,75 @@
+import { join } from "node:path";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { toolText } from "../tool-result.mjs";
+import { CodeSearchIndexCache } from "./cache.mjs";
+import { searchCode } from "./engine.mjs";
+import { Model2VecVectorizer, POTION_CODE_MODEL_ID } from "./retrieval/model2vec.mjs";
+
+const persistentCaches = new Map();
+
+export function createCodeSearchTool({ engine, stateRoot = null }) {
+  const cache = stateRoot ? persistentCacheFor(stateRoot) : null;
+  return defineTool({
+    name: "code_search",
+    label: "Code Search",
+    description: "Native code-aware search over the workspace. Use it to locate relevant code snippets before reading full files; use grep for exact string confirmation.",
+    parameters: Type.Object({
+      query: Type.Optional(Type.String({ description: "Natural-language or symbol query" })),
+      path: Type.Optional(Type.String({ description: "Relative or absolute workspace path to search; default current workspace" })),
+      top_k: Type.Optional(Type.Number({ description: "Maximum results to return; default 5, max 20" })),
+      mode: Type.Optional(Type.Union([
+        Type.Literal("auto"),
+        Type.Literal("symbol"),
+        Type.Literal("lexical"),
+        Type.Literal("semantic"),
+      ], { description: "Search mode. auto uses BM25 + Model2Vec retrieval with RRF fusion." })),
+      include_tests: Type.Optional(Type.Boolean({ description: "Include test/spec paths without penalty; default false" })),
+      related_to: Type.Optional(Type.Object({
+        file_path: Type.String({ description: "Workspace-relative file path containing the known code" }),
+        line: Type.Number({ description: "Line inside the known code chunk" }),
+      }, { description: "Find code related to a known file location; query can optionally refine the relation" })),
+    }),
+    execute: async (_toolCallId, params) => executeCodeSearch({ engine, cache, ...params }),
+  });
+}
+
+export async function executeCodeSearch({ engine, cache, query, path = ".", top_k, mode = "auto", include_tests = false, related_to }) {
+  try {
+    const root = engine.cwd;
+    const searchPath = path === "." ? "." : engine.resolvePath(path);
+    const result = await searchCode({ root, query, path: searchPath, top_k, mode, include_tests, related_to, cache });
+    return toolText(formatSearchOutput(result), result);
+  } catch (err) {
+    return toolText(`Error running code_search: ${err.message}`, { error: true });
+  }
+}
+
+function persistentCacheFor(stateRoot) {
+  const storagePath = join(stateRoot, "code-search", "chunks.json");
+  const modelDir = join(stateRoot, "code-search", "models", POTION_CODE_MODEL_ID.replaceAll("/", "__"));
+  const cacheKey = `${storagePath}\n${modelDir}`;
+  let cache = persistentCaches.get(cacheKey);
+  if (!cache) {
+    cache = new CodeSearchIndexCache({
+      storagePath,
+      vectorizer: new Model2VecVectorizer({ modelDir }),
+    });
+    persistentCaches.set(cacheKey, cache);
+  }
+  return cache;
+}
+
+function formatSearchOutput({ results, stats }) {
+  const header = `--- code_search (${results.length} results, ${stats.files} files, ${stats.chunks} chunks, ${stats.mode}) ---`;
+  if (results.length === 0) return `${header}\nNo matching code snippets found.`;
+  const body = results.map((result, index) => [
+    `${index + 1}. ${result.file_path}:${result.start_line}-${result.end_line} score=${result.score} kind=${result.kind}${result.symbols.length ? ` symbols=${result.symbols.join(",")}` : ""}`,
+    fenceSnippet(result.snippet),
+  ].join("\n")).join("\n\n");
+  return `${header}\n${body}`;
+}
+
+function fenceSnippet(snippet) {
+  return "```\n" + snippet.trimEnd() + "\n```";
+}

package/src/agent/lifecycle/runner-lifecycle.mjs

@@ -0,0 +1,16 @@
+export function createRunnerLifecycle() {
+  let pendingAction = null;
+  return {
+    requestRuntimeRestart({ reason = "" } = {}) {
+      pendingAction = { type: "restart_runtime", reason };
+    },
+    takePendingAction() {
+      const action = pendingAction;
+      pendingAction = null;
+      return action;
+    },
+    clearPendingAction() {
+      pendingAction = null;
+    },
+  };
+}

package/src/agent/lifecycle/runtime-restart-tool.mjs

@@ -0,0 +1,22 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { toolText } from "../tool-result.mjs";
+
+export function createRuntimeRestartTool({ lifecycle }) {
+  return defineTool({
+    name: "request_runtime_restart",
+    label: "Request Runtime Restart",
+    description: "Request March to restart the runtime after the current turn so the next turn loads updated runner/tool code from disk.",
+    parameters: Type.Object({
+      reason: Type.Optional(Type.String({ description: "Why the runtime needs to restart" })),
+    }),
+    execute: async (_toolCallId, params = {}) => {
+      const reason = String(params.reason ?? "").trim();
+      lifecycle?.requestRuntimeRestart?.({ reason });
+      return toolText(
+        "March runtime restart requested. The current turn will finish first; the next turn will use the latest code from disk.",
+        { lifecycleAction: { type: "restart_runtime", reason } },
+      );
+    },
+  });
+}

package/src/agent/runner/provider-quota-runtime.mjs

@@ -0,0 +1,38 @@
+import { createProviderQuotaService } from "../../provider/quota/index.mjs";
+import { installProviderQuotaTransportObserver, subscribeProviderQuotaTransport } from "../../provider/quota/transport-observer.mjs";
+
+export function createRunnerProviderQuotaRuntime({ authStorage, getCurrentModel, ui } = {}) {
+  installProviderQuotaTransportObserver();
+  const providerQuota = createProviderQuotaService({ authStorage });
+  let lastSnapshot = null;
+  const unsubscribeTransport = subscribeProviderQuotaTransport((event) => {
+    const model = getCurrentModel?.();
+    if (!providerQuota.supports(model?.provider) || event.providerId !== model.provider) return;
+    const snapshot = event.source === "headers"
+      ? providerQuota.observeHeaders(event.headers, model)
+      : providerQuota.observeEvent(event.payload, model);
+    if (!snapshot) return;
+    lastSnapshot = snapshot;
+    ui?.providerQuotaSnapshot?.(lastSnapshot);
+  });
+
+  return {
+    getCachedProviderQuotaSnapshot() {
+      return lastSnapshot;
+    },
+    async getProviderQuotaSnapshot({ emit = false } = {}) {
+      const model = getCurrentModel?.();
+      if (!providerQuota.supports(model?.provider)) {
+        lastSnapshot = null;
+        if (emit) ui?.providerQuotaSnapshot?.(null);
+        return null;
+      }
+      lastSnapshot = await providerQuota.refresh(model);
+      if (emit) ui?.providerQuotaSnapshot?.(lastSnapshot);
+      return lastSnapshot;
+    },
+    disposeProviderQuotaRuntime() {
+      unsubscribeTransport();
+    },
+  };
+}