@j0hanz/code-assistant 0.9.0

package/dist/lib/config.js

@@ -0,0 +1,87 @@
+function parsePositiveInteger(value) {
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(normalized, 10);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+function resolveEnvInt(envVar, defaultValue) {
+    const envValue = process.env[envVar] ?? '';
+    return parsePositiveInteger(envValue) ?? defaultValue;
+}
+/** Creates a cached integer value from an environment variable, with a default fallback. */
+export function createCachedEnvInt(envVar, defaultValue) {
+    let cached;
+    return {
+        get() {
+            if (cached !== undefined) {
+                return cached;
+            }
+            cached = resolveEnvInt(envVar, defaultValue);
+            return cached;
+        },
+        reset() {
+            cached = undefined;
+        },
+    };
+}
+/** Fast, cost-effective model for summarization and light analysis. */
+export const FLASH_MODEL = 'gemini-3-flash-preview';
+/** Default language hint. */
+export const DEFAULT_LANGUAGE = 'detect';
+/** Default test-framework hint. */
+export const DEFAULT_FRAMEWORK = 'detect';
+/** Extended timeout for deep analysis calls (ms). */
+export const DEFAULT_TIMEOUT_EXTENDED_MS = 120_000;
+export const MODEL_TIMEOUT_MS = Object.freeze({
+    extended: DEFAULT_TIMEOUT_EXTENDED_MS,
+});
+// ---------------------------------------------------------------------------
+// Budgets (Thinking & Output)
+// ---------------------------------------------------------------------------
+const THINKING_LEVELS = {
+    /** Minimal thinking for triage/classification. */
+    flashTriage: 'minimal',
+    /** Medium thinking for analysis tasks. */
+    flash: 'medium',
+    /** High thinking for deep review and patches. */
+    flashHigh: 'high',
+};
+/** Thinking level for Flash triage. */
+export const FLASH_TRIAGE_THINKING_LEVEL = THINKING_LEVELS.flashTriage;
+/** Thinking level for Flash analysis. */
+export const FLASH_THINKING_LEVEL = THINKING_LEVELS.flash;
+/** Thinking level for Flash deep analysis. */
+export const FLASH_HIGH_THINKING_LEVEL = THINKING_LEVELS.flashHigh;
+// Output token caps for various tools. Set to a high default to avoid cutting off important information, but can be adjusted as needed.
+const DEFAULT_OUTPUT_CAP = 65_536;
+/** Output cap for Flash API breaking-change detection. */
+export const FLASH_API_BREAKING_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
+/** Output cap for Flash complexity analysis. */
+export const FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
+/** Output cap for Flash test-plan generation. */
+export const FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
+/** Output cap for Flash triage tools. */
+export const FLASH_TRIAGE_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
+/** Output cap for Flash patch generation. */
+export const FLASH_PATCH_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
+/** Output cap for Flash deep review findings. */
+export const FLASH_REVIEW_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
+// ---------------------------------------------------------------------------
+// Temperatures
+// ---------------------------------------------------------------------------
+const TOOL_TEMPERATURE = {
+    analysis: 1.0, // Gemini 3 recommends 1.0 for all tasks
+    creative: 1.0, // Gemini 3 recommends 1.0 for all tasks
+    patch: 1.0, // Gemini 3 recommends 1.0 for all tasks
+    triage: 1.0, // Gemini 3 recommends 1.0 for all tasks
+};
+/** Temperature for analytical tools. */
+export const ANALYSIS_TEMPERATURE = TOOL_TEMPERATURE.analysis;
+/** Temperature for creative synthesis (test plans). */
+export const CREATIVE_TEMPERATURE = TOOL_TEMPERATURE.creative;
+/** Temperature for code patch generation. */
+export const PATCH_TEMPERATURE = TOOL_TEMPERATURE.patch;
+/** Temperature for triage/classification tools. */
+export const TRIAGE_TEMPERATURE = TOOL_TEMPERATURE.triage;

package/dist/lib/diff.d.ts

@@ -0,0 +1,49 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { File as ParsedFile } from 'parse-diff';
+import { createErrorToolResponse } from './tools.js';
+export type { ParsedFile };
+export declare function getMaxDiffChars(): number;
+export declare function resetMaxDiffCharsCacheForTesting(): void;
+export declare function exceedsDiffBudget(diff: string): boolean;
+export declare function getDiffBudgetError(diffLength: number, maxChars?: number): string;
+export declare function validateDiffBudget(diff: string): ReturnType<typeof createErrorToolResponse> | undefined;
+export declare const NOISY_EXCLUDE_PATHSPECS: readonly [":(exclude)package-lock.json", ":(exclude)yarn.lock", ":(exclude)pnpm-lock.yaml", ":(exclude)bun.lockb", ":(exclude)*.lock", ":(exclude)dist/", ":(exclude)build/", ":(exclude)out/", ":(exclude).next/", ":(exclude)coverage/", ":(exclude)*.min.js", ":(exclude)*.min.css", ":(exclude)*.map"];
+export declare function cleanDiff(raw: string): string;
+export declare function isEmptyDiff(diff: string): boolean;
+export declare const EMPTY_DIFF_STATS: Readonly<DiffStats>;
+export interface DiffStats {
+    files: number;
+    added: number;
+    deleted: number;
+}
+export declare function parseDiffFiles(diff: string): ParsedFile[];
+export declare function computeDiffStatsAndSummaryFromFiles(files: readonly ParsedFile[]): Readonly<{
+    stats: DiffStats;
+    summary: string;
+}>;
+export declare function computeDiffStatsAndPathsFromFiles(files: readonly ParsedFile[]): Readonly<{
+    stats: DiffStats;
+    paths: string[];
+}>;
+export declare function extractChangedPathsFromFiles(files: readonly ParsedFile[]): string[];
+export declare function extractChangedPaths(diff: string): string[];
+export declare function computeDiffStatsFromFiles(files: readonly ParsedFile[]): Readonly<DiffStats>;
+export declare function computeDiffStats(diff: string): Readonly<DiffStats>;
+export declare function formatFileSummary(files: ParsedFile[]): string;
+export declare const DIFF_RESOURCE_URI = "diff://current";
+export declare const diffStaleWarningMs: import("./config.js").CachedEnvInt;
+export interface DiffSlot {
+    diff: string;
+    parsedFiles: readonly ParsedFile[];
+    stats: DiffStats;
+    generatedAt: string;
+    mode: string;
+}
+/** Binds diff resource notifications to the currently active server instance. */
+export declare function initDiffStore(server: McpServer): void;
+export declare function storeDiff(data: DiffSlot, key?: string): void;
+export declare function getDiff(key?: string): DiffSlot | undefined;
+export declare function hasDiff(key?: string): boolean;
+/** Test-only: directly set or clear the diff slot without emitting resource-updated. */
+export declare function setDiffForTesting(data: DiffSlot | undefined, key?: string): void;
+export declare function createNoDiffError(): ReturnType<typeof createErrorToolResponse>;

package/dist/lib/diff.js

@@ -0,0 +1,241 @@
+import parseDiff from 'parse-diff';
+import { createCachedEnvInt } from './config.js';
+import { formatUsNumber } from './format.js';
+import { createErrorToolResponse } from './tools.js';
+// --- Diff Budget ---
+const DEFAULT_MAX_DIFF_CHARS = 120_000;
+const MAX_DIFF_CHARS_ENV_VAR = 'MAX_DIFF_CHARS';
+const diffCharsConfig = createCachedEnvInt(MAX_DIFF_CHARS_ENV_VAR, DEFAULT_MAX_DIFF_CHARS);
+export function getMaxDiffChars() {
+    return diffCharsConfig.get();
+}
+export function resetMaxDiffCharsCacheForTesting() {
+    diffCharsConfig.reset();
+}
+export function exceedsDiffBudget(diff) {
+    return diff.length > getMaxDiffChars();
+}
+export function getDiffBudgetError(diffLength, maxChars = getMaxDiffChars()) {
+    return `diff exceeds max allowed size (${formatUsNumber(diffLength)} chars > ${formatUsNumber(maxChars)} chars)`;
+}
+const BUDGET_ERROR_META = { retryable: false, kind: 'budget' };
+export function validateDiffBudget(diff) {
+    const providedChars = diff.length;
+    const maxChars = getMaxDiffChars();
+    if (providedChars <= maxChars) {
+        return undefined;
+    }
+    return createErrorToolResponse('E_INPUT_TOO_LARGE', getDiffBudgetError(providedChars, maxChars), { providedChars, maxChars }, BUDGET_ERROR_META);
+}
+// --- Diff Cleaner ---
+export const NOISY_EXCLUDE_PATHSPECS = [
+    ':(exclude)package-lock.json',
+    ':(exclude)yarn.lock',
+    ':(exclude)pnpm-lock.yaml',
+    ':(exclude)bun.lockb',
+    ':(exclude)*.lock',
+    ':(exclude)dist/',
+    ':(exclude)build/',
+    ':(exclude)out/',
+    ':(exclude).next/',
+    ':(exclude)coverage/',
+    ':(exclude)*.min.js',
+    ':(exclude)*.min.css',
+    ':(exclude)*.map',
+];
+const BINARY_FILE_LINE = /^Binary files .+ differ$/m;
+const GIT_BINARY_PATCH = /^GIT binary patch/m;
+const HAS_HUNK = /^@@/m;
+const HAS_OLD_MODE = /^old mode /m;
+function shouldKeepSection(section) {
+    return (Boolean(section.trim()) &&
+        !BINARY_FILE_LINE.test(section) &&
+        !GIT_BINARY_PATCH.test(section) &&
+        (!HAS_OLD_MODE.test(section) || HAS_HUNK.test(section)));
+}
+function processSection(raw, start, end, sections) {
+    if (end > start) {
+        const section = raw.slice(start, end);
+        if (shouldKeepSection(section)) {
+            sections.push(section);
+        }
+    }
+}
+function extractAllSections(raw, sections, firstIndex) {
+    let lastIndex = 0;
+    let nextIndex = firstIndex;
+    while (nextIndex !== -1) {
+        const matchIndex = nextIndex === 0 ? 0 : nextIndex + 1; // +1 to skip \n
+        processSection(raw, lastIndex, matchIndex, sections);
+        lastIndex = matchIndex;
+        nextIndex = raw.indexOf('\ndiff --git ', lastIndex);
+    }
+    processSection(raw, lastIndex, raw.length, sections);
+}
+export function cleanDiff(raw) {
+    if (!raw)
+        return '';
+    const sections = [];
+    const nextIndex = raw.startsWith('diff --git ')
+        ? 0
+        : raw.indexOf('\ndiff --git ');
+    if (nextIndex === -1) {
+        processSection(raw, 0, raw.length, sections);
+    }
+    else {
+        extractAllSections(raw, sections, nextIndex);
+    }
+    return sections.join('').trim();
+}
+export function isEmptyDiff(diff) {
+    return diff.trim().length === 0;
+}
+// --- Diff Parser ---
+const UNKNOWN_PATH = 'unknown';
+const NO_FILES_CHANGED = 'No files changed.';
+const EMPTY_PATHS = [];
+const MAX_SUMMARY_FILES = 40;
+export const EMPTY_DIFF_STATS = Object.freeze({
+    files: 0,
+    added: 0,
+    deleted: 0,
+});
+const PATH_SORTER = (left, right) => left.localeCompare(right);
+export function parseDiffFiles(diff) {
+    return diff ? parseDiff(diff) : [];
+}
+function cleanPath(path) {
+    if (path.startsWith('a/') || path.startsWith('b/')) {
+        return path.slice(2);
+    }
+    return path;
+}
+function resolveChangedPath(file) {
+    if (file.to && file.to !== '/dev/null')
+        return cleanPath(file.to);
+    if (file.from && file.from !== '/dev/null')
+        return cleanPath(file.from);
+    return undefined;
+}
+function sortPaths(paths) {
+    return Array.from(paths).sort(PATH_SORTER);
+}
+function isNoFiles(files) {
+    return files.length === 0;
+}
+function calculateStats(files) {
+    let added = 0;
+    let deleted = 0;
+    for (const file of files) {
+        added += file.additions;
+        deleted += file.deletions;
+    }
+    return { files: files.length, added, deleted };
+}
+function getUniquePaths(files) {
+    const paths = new Set();
+    for (const file of files) {
+        const path = resolveChangedPath(file);
+        if (path)
+            paths.add(path);
+    }
+    return paths;
+}
+function buildFileSummaryList(files, maxFiles = 40) {
+    return files.slice(0, maxFiles).map((file) => {
+        const path = resolveChangedPath(file) ?? UNKNOWN_PATH;
+        return `${path} (+${Math.max(0, file.additions)} -${Math.max(0, file.deletions)})`;
+    });
+}
+export function computeDiffStatsAndSummaryFromFiles(files) {
+    if (isNoFiles(files)) {
+        return { stats: EMPTY_DIFF_STATS, summary: NO_FILES_CHANGED };
+    }
+    const stats = calculateStats(files);
+    const summaries = buildFileSummaryList(files, MAX_SUMMARY_FILES);
+    if (files.length > MAX_SUMMARY_FILES) {
+        summaries.push(`... and ${files.length - MAX_SUMMARY_FILES} more files`);
+    }
+    return {
+        stats,
+        summary: `${summaries.join(', ')} [${stats.files} files, +${stats.added} -${Math.abs(stats.deleted)}]`,
+    };
+}
+export function computeDiffStatsAndPathsFromFiles(files) {
+    if (isNoFiles(files)) {
+        return { stats: EMPTY_DIFF_STATS, paths: EMPTY_PATHS };
+    }
+    const stats = calculateStats(files);
+    const paths = sortPaths(getUniquePaths(files));
+    return { stats, paths };
+}
+export function extractChangedPathsFromFiles(files) {
+    if (isNoFiles(files))
+        return EMPTY_PATHS;
+    return sortPaths(getUniquePaths(files));
+}
+export function extractChangedPaths(diff) {
+    return extractChangedPathsFromFiles(parseDiffFiles(diff));
+}
+export function computeDiffStatsFromFiles(files) {
+    if (isNoFiles(files))
+        return EMPTY_DIFF_STATS;
+    return calculateStats(files);
+}
+export function computeDiffStats(diff) {
+    return computeDiffStatsFromFiles(parseDiffFiles(diff));
+}
+export function formatFileSummary(files) {
+    return computeDiffStatsAndSummaryFromFiles(files).summary;
+}
+export const DIFF_RESOURCE_URI = 'diff://current';
+const diffCacheTtlMs = createCachedEnvInt('DIFF_CACHE_TTL_MS', 60 * 60 * 1_000 // 1 hour default
+);
+export const diffStaleWarningMs = createCachedEnvInt('DIFF_STALE_WARNING_MS', 5 * 60 * 1_000 // 5 minutes default
+);
+const diffSlots = new Map();
+let sendResourceUpdated;
+function setDiffSlot(key, data) {
+    if (data) {
+        diffSlots.set(key, data);
+    }
+    else {
+        diffSlots.delete(key);
+    }
+}
+function notifyDiffUpdated() {
+    void sendResourceUpdated?.({ uri: DIFF_RESOURCE_URI }).catch(() => {
+        // Ignore errors sending resource-updated, which can happen if the server is not fully initialized yet.
+    });
+}
+/** Binds diff resource notifications to the currently active server instance. */
+export function initDiffStore(server) {
+    sendResourceUpdated = (params) => server.server.sendResourceUpdated(params);
+}
+export function storeDiff(data, key = process.cwd()) {
+    setDiffSlot(key, data);
+    notifyDiffUpdated();
+}
+export function getDiff(key = process.cwd()) {
+    const slot = diffSlots.get(key);
+    if (!slot) {
+        return undefined;
+    }
+    const age = Date.now() - new Date(slot.generatedAt).getTime();
+    if (age > diffCacheTtlMs.get()) {
+        diffSlots.delete(key);
+        notifyDiffUpdated();
+        return undefined;
+    }
+    return slot;
+}
+export function hasDiff(key = process.cwd()) {
+    return getDiff(key) !== undefined;
+}
+/** Test-only: directly set or clear the diff slot without emitting resource-updated. */
+export function setDiffForTesting(data, key = process.cwd()) {
+    setDiffSlot(key, data);
+}
+export function createNoDiffError() {
+    return createErrorToolResponse('E_NO_DIFF', 'No diff cached. You must call the generate_diff tool before using any review tool. Run generate_diff with mode="unstaged" or mode="staged" to capture the current branch changes, then retry this tool.', undefined, { retryable: false, kind: 'validation' });
+}

package/dist/lib/errors.d.ts

@@ -0,0 +1,8 @@
+import type { ErrorMeta } from './tools.js';
+/** Matches transient upstream provider failures that are typically safe to retry. */
+export declare const RETRYABLE_UPSTREAM_ERROR_PATTERN: RegExp;
+export declare function toRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function getErrorMessage(error: unknown): string;
+declare const CANCELLED_ERROR_PATTERN: RegExp;
+export { CANCELLED_ERROR_PATTERN };
+export declare function classifyErrorMeta(error: unknown, message: string): ErrorMeta;

package/dist/lib/errors.js

@@ -0,0 +1,69 @@
+import { inspect } from 'node:util';
+import { z } from 'zod';
+/** Matches transient upstream provider failures that are typically safe to retry. */
+export const RETRYABLE_UPSTREAM_ERROR_PATTERN = /(429|500|502|503|504|rate.?limit|quota|overload|unavailable|gateway|timeout|timed.out|connection|reset|econn|enotfound|temporary|transient)/i;
+function isObjectRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function toRecord(value) {
+    if (!isObjectRecord(value)) {
+        return undefined;
+    }
+    return value;
+}
+function getStringProperty(value, key) {
+    if (!isObjectRecord(value) || !(key in value)) {
+        return undefined;
+    }
+    const property = value[key];
+    return typeof property === 'string' ? property : undefined;
+}
+export function getErrorMessage(error) {
+    const message = getStringProperty(error, 'message');
+    if (message !== undefined) {
+        return message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    return inspect(error, { depth: 3, breakLength: 120 });
+}
+const CANCELLED_ERROR_PATTERN = /cancelled|canceled/i;
+const TIMEOUT_ERROR_PATTERN = /timed out|timeout/i;
+const BUDGET_ERROR_PATTERN = /exceeds limit|max allowed size|input too large/i;
+const BUSY_ERROR_PATTERN = /too many concurrent/i;
+const VALIDATION_ERROR_PATTERN = /validation/i;
+export { CANCELLED_ERROR_PATTERN };
+const ERROR_CLASSIFIERS = [
+    {
+        pattern: CANCELLED_ERROR_PATTERN,
+        meta: { kind: 'cancelled', retryable: false },
+    },
+    {
+        pattern: TIMEOUT_ERROR_PATTERN,
+        meta: { kind: 'timeout', retryable: true },
+    },
+    { pattern: BUDGET_ERROR_PATTERN, meta: { kind: 'budget', retryable: false } },
+    { pattern: BUSY_ERROR_PATTERN, meta: { kind: 'busy', retryable: true } },
+    {
+        pattern: RETRYABLE_UPSTREAM_ERROR_PATTERN,
+        meta: { kind: 'upstream', retryable: true },
+    },
+];
+export function classifyErrorMeta(error, message) {
+    if (error instanceof z.ZodError || VALIDATION_ERROR_PATTERN.test(message)) {
+        return {
+            kind: 'validation',
+            retryable: false,
+        };
+    }
+    for (const { pattern, meta } of ERROR_CLASSIFIERS) {
+        if (pattern.test(message)) {
+            return meta;
+        }
+    }
+    return {
+        kind: 'internal',
+        retryable: false,
+    };
+}

package/dist/lib/format.d.ts

@@ -0,0 +1,14 @@
+export declare function formatOptionalLine(label: string, value: string | number | undefined): string;
+export interface OptionalLineEntry {
+    label: string;
+    value: string | number | undefined;
+}
+export declare function formatOptionalLines(entries: readonly OptionalLineEntry[]): string;
+export declare function formatLanguageSegment(language: string | undefined): string;
+export declare function buildLanguageDiffPrompt(language: string | undefined, diff: string, conclusion: string): string;
+export declare function formatCountLabel(count: number, singular: string, plural: string): string;
+export declare function formatUsNumber(value: number): string;
+export declare function formatTimeoutSeconds(timeoutMs: number): string;
+export declare function formatThinkingLevel(thinkingLevel: string | undefined, fallback?: string): string;
+export declare function toBulletedList(lines: readonly string[]): string;
+export declare function toInlineCode(value: string): string;

package/dist/lib/format.js

@@ -0,0 +1,33 @@
+export function formatOptionalLine(label, value) {
+    return value === undefined ? '' : `\n${label}: ${value}`;
+}
+export function formatOptionalLines(entries) {
+    return entries
+        .map((entry) => formatOptionalLine(entry.label, entry.value))
+        .join('');
+}
+export function formatLanguageSegment(language) {
+    return formatOptionalLine('Language', language);
+}
+export function buildLanguageDiffPrompt(language, diff, conclusion) {
+    return `${formatLanguageSegment(language)}\nDiff:\n${diff}\n\n${conclusion}`.trimStart();
+}
+export function formatCountLabel(count, singular, plural) {
+    return `${count} ${count === 1 ? singular : plural}`;
+}
+const usNumberFormatter = new Intl.NumberFormat('en-US');
+export function formatUsNumber(value) {
+    return usNumberFormatter.format(value);
+}
+export function formatTimeoutSeconds(timeoutMs) {
+    return `${Math.round(timeoutMs / 1_000)}s`;
+}
+export function formatThinkingLevel(thinkingLevel, fallback = '-') {
+    return thinkingLevel ?? fallback;
+}
+export function toBulletedList(lines) {
+    return lines.map((line) => `- ${line}`).join('\n');
+}
+export function toInlineCode(value) {
+    return `\`${value}\``;
+}

package/dist/lib/gemini.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from 'node:events';
+import { GoogleGenAI } from '@google/genai';
+export type JsonObject = Record<string, unknown>;
+export type GeminiLogHandler = (level: string, data: unknown) => Promise<void>;
+export type GeminiThinkingLevel = 'minimal' | 'low' | 'medium' | 'high';
+export interface GeminiRequestExecutionOptions {
+    maxRetries?: number;
+    timeoutMs?: number;
+    temperature?: number;
+    maxOutputTokens?: number;
+    thinkingLevel?: GeminiThinkingLevel;
+    includeThoughts?: boolean;
+    signal?: AbortSignal;
+    onLog?: GeminiLogHandler;
+    responseKeyOrdering?: readonly string[];
+    batchMode?: 'off' | 'inline';
+}
+export interface GeminiStructuredRequestOptions extends GeminiRequestExecutionOptions {
+    model?: string;
+}
+export interface GeminiStructuredRequest extends GeminiStructuredRequestOptions {
+    systemInstruction?: string;
+    prompt: string;
+    responseSchema: Readonly<JsonObject>;
+}
+type JsonRecord = Record<string, unknown>;
+export declare function stripJsonSchemaConstraints(schema: JsonRecord): JsonRecord;
+export declare const RETRYABLE_NUMERIC_CODES: Set<number>;
+export declare const RETRYABLE_TRANSIENT_CODES: Set<string>;
+export declare function toUpperStringCode(candidate: unknown): string | undefined;
+export declare function getNumericErrorCode(error: unknown): number | undefined;
+export declare function shouldRetry(error: unknown): boolean;
+export declare function getRetryDelayMs(attempt: number): number;
+export declare function canRetryAttempt(attempt: number, maxRetries: number, error: unknown): boolean;
+export declare const geminiEvents: EventEmitter<[never]>;
+export declare function getCurrentRequestId(): string;
+export declare function setClientForTesting(client: GoogleGenAI): void;
+export declare function getGeminiQueueSnapshot(): {
+    activeWaiters: number;
+    activeCalls: number;
+    activeBatchWaiters: number;
+    activeBatchCalls: number;
+};
+export declare function generateStructuredJson(request: GeminiStructuredRequest): Promise<unknown>;
+export {};