@j0hanz/code-assistant 0.9.0

package/dist/lib/gemini.js

@@ -0,0 +1,833 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomInt } from 'node:crypto';
+import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { performance } from 'node:perf_hooks';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { debuglog } from 'node:util';
+import { FinishReason, GoogleGenAI, HarmBlockThreshold, HarmCategory, ThinkingLevel, } from '@google/genai';
+import { ConcurrencyLimiter } from './concurrency.js';
+import { createCachedEnvInt } from './config.js';
+import { getErrorMessage, RETRYABLE_UPSTREAM_ERROR_PATTERN, toRecord, } from './errors.js';
+import { formatUsNumber } from './format.js';
+const CONSTRAINT_KEY_VALUES = [
+    'minLength',
+    'maxLength',
+    'minimum',
+    'maximum',
+    'exclusiveMinimum',
+    'exclusiveMaximum',
+    'minItems',
+    'maxItems',
+    'multipleOf',
+    'pattern',
+    'format',
+];
+const CONSTRAINT_KEYS = new Set(CONSTRAINT_KEY_VALUES);
+const INTEGER_JSON_TYPE = 'integer';
+const NUMBER_JSON_TYPE = 'number';
+function isJsonRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stripConstraintValue(value) {
+    if (Array.isArray(value)) {
+        const stripped = new Array(value.length);
+        for (let index = 0; index < value.length; index += 1) {
+            stripped[index] = stripConstraintValue(value[index]);
+        }
+        return stripped;
+    }
+    if (isJsonRecord(value)) {
+        return stripJsonSchemaConstraints(value);
+    }
+    return value;
+}
+export function stripJsonSchemaConstraints(schema) {
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (CONSTRAINT_KEYS.has(key)) {
+            continue;
+        }
+        if (key === 'type' && value === INTEGER_JSON_TYPE) {
+            result[key] = NUMBER_JSON_TYPE;
+            continue;
+        }
+        result[key] = stripConstraintValue(value);
+    }
+    return result;
+}
+const DIGITS_ONLY_PATTERN = /^\d+$/;
+const RETRY_DELAY_BASE_MS = 300;
+const RETRY_DELAY_MAX_MS = 5_000;
+const RETRY_JITTER_RATIO = 0.2;
+export const RETRYABLE_NUMERIC_CODES = new Set([429, 500, 502, 503, 504]);
+export const RETRYABLE_TRANSIENT_CODES = new Set([
+    'RESOURCE_EXHAUSTED',
+    'UNAVAILABLE',
+    'DEADLINE_EXCEEDED',
+    'INTERNAL',
+    'ABORTED',
+]);
+function getNestedError(error) {
+    const record = toRecord(error);
+    if (!record) {
+        return undefined;
+    }
+    const nested = record.error;
+    const nestedRecord = toRecord(nested);
+    if (!nestedRecord) {
+        return record;
+    }
+    return nestedRecord;
+}
+function toNumericCode(candidate) {
+    if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+        return candidate;
+    }
+    if (typeof candidate === 'string' && DIGITS_ONLY_PATTERN.test(candidate)) {
+        return Number.parseInt(candidate, 10);
+    }
+    return undefined;
+}
+export function toUpperStringCode(candidate) {
+    if (typeof candidate !== 'string') {
+        return undefined;
+    }
+    const normalized = candidate.trim().toUpperCase();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function findFirstNumericCode(record, keys) {
+    for (const key of keys) {
+        const numericCode = toNumericCode(record[key]);
+        if (numericCode !== undefined) {
+            return numericCode;
+        }
+    }
+    return undefined;
+}
+function findFirstStringCode(record, keys) {
+    for (const key of keys) {
+        const stringCode = toUpperStringCode(record[key]);
+        if (stringCode !== undefined) {
+            return stringCode;
+        }
+    }
+    return undefined;
+}
+const NUMERIC_ERROR_KEYS = ['status', 'statusCode', 'code'];
+export function getNumericErrorCode(error) {
+    const record = getNestedError(error);
+    if (!record) {
+        return undefined;
+    }
+    return findFirstNumericCode(record, NUMERIC_ERROR_KEYS);
+}
+const TRANSIENT_ERROR_KEYS = ['code', 'status', 'statusText'];
+function getTransientErrorCode(error) {
+    const record = getNestedError(error);
+    if (!record) {
+        return undefined;
+    }
+    return findFirstStringCode(record, TRANSIENT_ERROR_KEYS);
+}
+export function shouldRetry(error) {
+    const numericCode = getNumericErrorCode(error);
+    if (numericCode !== undefined && RETRYABLE_NUMERIC_CODES.has(numericCode)) {
+        return true;
+    }
+    const transientCode = getTransientErrorCode(error);
+    if (transientCode !== undefined &&
+        RETRYABLE_TRANSIENT_CODES.has(transientCode)) {
+        return true;
+    }
+    const message = getErrorMessage(error);
+    return RETRYABLE_UPSTREAM_ERROR_PATTERN.test(message);
+}
+export function getRetryDelayMs(attempt) {
+    const exponentialDelay = RETRY_DELAY_BASE_MS * 2 ** attempt;
+    const boundedDelay = Math.min(RETRY_DELAY_MAX_MS, exponentialDelay);
+    const jitterWindow = Math.max(1, Math.floor(boundedDelay * RETRY_JITTER_RATIO));
+    const jitter = randomInt(0, jitterWindow);
+    return Math.min(RETRY_DELAY_MAX_MS, boundedDelay + jitter);
+}
+export function canRetryAttempt(attempt, maxRetries, error) {
+    return attempt < maxRetries && shouldRetry(error);
+}
+// Lazy-cached: first call happens after parseCommandLineArgs() sets GEMINI_MODEL.
+let _defaultModel;
+const DEFAULT_MODEL = 'gemini-3-flash-preview';
+const MODEL_FALLBACK_TARGET = 'gemini-2.5-flash';
+const GEMINI_MODEL_ENV_VAR = 'GEMINI_MODEL';
+const GEMINI_HARM_BLOCK_THRESHOLD_ENV_VAR = 'GEMINI_HARM_BLOCK_THRESHOLD';
+const GEMINI_INCLUDE_THOUGHTS_ENV_VAR = 'GEMINI_INCLUDE_THOUGHTS';
+const GEMINI_BATCH_MODE_ENV_VAR = 'GEMINI_BATCH_MODE';
+const GEMINI_API_KEY_ENV_VAR = 'GEMINI_API_KEY';
+const GOOGLE_API_KEY_ENV_VAR = 'GOOGLE_API_KEY';
+function getDefaultModel() {
+    _defaultModel ??= process.env[GEMINI_MODEL_ENV_VAR] ?? DEFAULT_MODEL;
+    return _defaultModel;
+}
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_TIMEOUT_MS = 90_000;
+const DEFAULT_MAX_OUTPUT_TOKENS = 16_384;
+const DEFAULT_SAFETY_THRESHOLD = HarmBlockThreshold.BLOCK_NONE;
+const DEFAULT_INCLUDE_THOUGHTS = false;
+const DEFAULT_BATCH_MODE = 'off';
+const UNKNOWN_REQUEST_CONTEXT_VALUE = 'unknown';
+const TRUE_ENV_VALUES = new Set(['1', 'true', 'yes', 'on']);
+const FALSE_ENV_VALUES = new Set(['0', 'false', 'no', 'off']);
+const SLEEP_UNREF_OPTIONS = { ref: false };
+const JSON_CODE_BLOCK_PATTERN = /```(?:json)?\n?([\s\S]*?)(?=\n?```)/u;
+const NEVER_ABORT_SIGNAL = new AbortController().signal;
+const CANCELLED_REQUEST_MESSAGE = 'Gemini request was cancelled.';
+const maxConcurrentCallsConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS', 10);
+const maxConcurrentBatchCallsConfig = createCachedEnvInt('MAX_CONCURRENT_BATCH_CALLS', 2);
+const concurrencyWaitMsConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS_WAIT_MS', 2_000);
+const batchPollIntervalMsConfig = createCachedEnvInt('GEMINI_BATCH_POLL_INTERVAL_MS', 2_000);
+const batchTimeoutMsConfig = createCachedEnvInt('GEMINI_BATCH_TIMEOUT_MS', 120_000);
+const callLimiter = new ConcurrencyLimiter(() => maxConcurrentCallsConfig.get(), () => concurrencyWaitMsConfig.get(), (limit, ms) => formatConcurrencyLimitErrorMessage(limit, ms), () => CANCELLED_REQUEST_MESSAGE);
+const batchCallLimiter = new ConcurrencyLimiter(() => maxConcurrentBatchCallsConfig.get(), () => concurrencyWaitMsConfig.get(), (limit, ms) => formatConcurrencyLimitErrorMessage(limit, ms), () => CANCELLED_REQUEST_MESSAGE);
+const SAFETY_CATEGORIES = [
+    HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+    HarmCategory.HARM_CATEGORY_HARASSMENT,
+    HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+];
+const SAFETY_THRESHOLD_BY_NAME = {
+    BLOCK_NONE: HarmBlockThreshold.BLOCK_NONE,
+    BLOCK_ONLY_HIGH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
+    BLOCK_MEDIUM_AND_ABOVE: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    BLOCK_LOW_AND_ABOVE: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+};
+let cachedSafetyThresholdEnv;
+let cachedSafetyThreshold = DEFAULT_SAFETY_THRESHOLD;
+let cachedIncludeThoughtsEnv;
+let cachedIncludeThoughts = DEFAULT_INCLUDE_THOUGHTS;
+const safetySettingsCache = new Map();
+function getSafetyThreshold() {
+    const threshold = process.env[GEMINI_HARM_BLOCK_THRESHOLD_ENV_VAR];
+    if (threshold === cachedSafetyThresholdEnv) {
+        return cachedSafetyThreshold;
+    }
+    cachedSafetyThresholdEnv = threshold;
+    if (!threshold) {
+        cachedSafetyThreshold = DEFAULT_SAFETY_THRESHOLD;
+        return cachedSafetyThreshold;
+    }
+    const parsedThreshold = parseSafetyThreshold(threshold);
+    if (parsedThreshold) {
+        cachedSafetyThreshold = parsedThreshold;
+        return cachedSafetyThreshold;
+    }
+    cachedSafetyThreshold = DEFAULT_SAFETY_THRESHOLD;
+    return cachedSafetyThreshold;
+}
+function parseSafetyThreshold(threshold) {
+    const normalizedThreshold = threshold.trim().toUpperCase();
+    if (!(normalizedThreshold in SAFETY_THRESHOLD_BY_NAME)) {
+        return undefined;
+    }
+    return SAFETY_THRESHOLD_BY_NAME[normalizedThreshold];
+}
+const THINKING_LEVEL_MAP = {
+    minimal: ThinkingLevel.MINIMAL,
+    low: ThinkingLevel.LOW,
+    medium: ThinkingLevel.MEDIUM,
+    high: ThinkingLevel.HIGH,
+};
+function getThinkingConfig(thinkingLevel, includeThoughts) {
+    if (!thinkingLevel && !includeThoughts) {
+        return undefined;
+    }
+    return {
+        ...(thinkingLevel
+            ? { thinkingLevel: THINKING_LEVEL_MAP[thinkingLevel] }
+            : {}),
+        ...(includeThoughts ? { includeThoughts: true } : {}),
+    };
+}
+function parseBooleanEnv(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized.length === 0) {
+        return undefined;
+    }
+    if (TRUE_ENV_VALUES.has(normalized)) {
+        return true;
+    }
+    if (FALSE_ENV_VALUES.has(normalized)) {
+        return false;
+    }
+    return undefined;
+}
+function getDefaultIncludeThoughts() {
+    const value = process.env[GEMINI_INCLUDE_THOUGHTS_ENV_VAR];
+    if (value === cachedIncludeThoughtsEnv) {
+        return cachedIncludeThoughts;
+    }
+    cachedIncludeThoughtsEnv = value;
+    if (!value) {
+        cachedIncludeThoughts = DEFAULT_INCLUDE_THOUGHTS;
+        return cachedIncludeThoughts;
+    }
+    cachedIncludeThoughts = parseBooleanEnv(value) ?? DEFAULT_INCLUDE_THOUGHTS;
+    return cachedIncludeThoughts;
+}
+function getDefaultBatchMode() {
+    const value = process.env[GEMINI_BATCH_MODE_ENV_VAR]?.trim().toLowerCase();
+    if (value === 'inline') {
+        return 'inline';
+    }
+    return DEFAULT_BATCH_MODE;
+}
+function applyResponseKeyOrdering(responseSchema, responseKeyOrdering) {
+    if (!responseKeyOrdering || responseKeyOrdering.length === 0) {
+        return responseSchema;
+    }
+    return {
+        ...responseSchema,
+        propertyOrdering: [...responseKeyOrdering],
+    };
+}
+function getPromptWithFunctionCallingContext(request) {
+    return request.prompt;
+}
+function getSafetySettings(threshold) {
+    const cached = safetySettingsCache.get(threshold);
+    if (cached) {
+        return cached;
+    }
+    const settings = SAFETY_CATEGORIES.map((category) => ({
+        category,
+        threshold,
+    }));
+    safetySettingsCache.set(threshold, settings);
+    return settings;
+}
+let cachedClient;
+export const geminiEvents = new EventEmitter();
+const debug = debuglog('gemini');
+geminiEvents.on('log', (payload) => {
+    if (debug.enabled) {
+        debug('%j', payload);
+    }
+});
+const geminiContext = new AsyncLocalStorage({
+    name: 'gemini_request',
+    defaultValue: {
+        requestId: UNKNOWN_REQUEST_CONTEXT_VALUE,
+        model: UNKNOWN_REQUEST_CONTEXT_VALUE,
+    },
+});
+const UNKNOWN_CONTEXT = {
+    requestId: UNKNOWN_REQUEST_CONTEXT_VALUE,
+    model: UNKNOWN_REQUEST_CONTEXT_VALUE,
+};
+export function getCurrentRequestId() {
+    const context = geminiContext.getStore();
+    return context?.requestId ?? UNKNOWN_REQUEST_CONTEXT_VALUE;
+}
+function getApiKey() {
+    const apiKey = process.env[GEMINI_API_KEY_ENV_VAR] ?? process.env[GOOGLE_API_KEY_ENV_VAR];
+    if (!apiKey) {
+        throw new Error(`Missing ${GEMINI_API_KEY_ENV_VAR} or ${GOOGLE_API_KEY_ENV_VAR}.`);
+    }
+    return apiKey;
+}
+function getClient() {
+    cachedClient ??= new GoogleGenAI({
+        apiKey: getApiKey(),
+        apiVersion: 'v1beta',
+    });
+    return cachedClient;
+}
+export function setClientForTesting(client) {
+    cachedClient = client;
+}
+function nextRequestId() {
+    return randomUUID();
+}
+function logEvent(event, details) {
+    const context = geminiContext.getStore() ?? UNKNOWN_CONTEXT;
+    geminiEvents.emit('log', {
+        event,
+        requestId: context.requestId,
+        model: context.model,
+        ...details,
+    });
+}
+async function safeCallOnLog(onLog, level, data) {
+    try {
+        await onLog?.(level, data);
+    }
+    catch {
+        // Log callbacks are best-effort; never fail the tool call.
+    }
+}
+async function emitGeminiLog(onLog, level, payload) {
+    logEvent(payload.event, payload.details);
+    await safeCallOnLog(onLog, level, {
+        event: payload.event,
+        ...payload.details,
+    });
+}
+function buildGenerationConfig(request, abortSignal) {
+    const includeThoughts = request.includeThoughts ?? getDefaultIncludeThoughts();
+    const thinkingConfig = getThinkingConfig(request.thinkingLevel, includeThoughts);
+    const config = {
+        temperature: request.temperature ?? 1.0,
+        maxOutputTokens: request.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS,
+        responseMimeType: 'application/json',
+        responseSchema: applyResponseKeyOrdering(request.responseSchema, request.responseKeyOrdering),
+        safetySettings: getSafetySettings(getSafetyThreshold()),
+        abortSignal,
+    };
+    if (request.systemInstruction) {
+        config.systemInstruction = request.systemInstruction;
+    }
+    if (thinkingConfig) {
+        config.thinkingConfig = thinkingConfig;
+    }
+    return config;
+}
+function combineSignals(signal, requestSignal) {
+    return requestSignal ? AbortSignal.any([signal, requestSignal]) : signal;
+}
+function throwIfRequestCancelled(requestSignal) {
+    if (requestSignal?.aborted) {
+        throw new Error(CANCELLED_REQUEST_MESSAGE);
+    }
+}
+function getSleepOptions(signal) {
+    return signal ? { ...SLEEP_UNREF_OPTIONS, signal } : SLEEP_UNREF_OPTIONS;
+}
+function parseStructuredResponse(responseText) {
+    if (!responseText) {
+        throw new Error('Gemini returned an empty response body.');
+    }
+    try {
+        return JSON.parse(responseText);
+    }
+    catch {
+        // fast-path failed; try extracting from markdown block
+    }
+    const jsonMatch = JSON_CODE_BLOCK_PATTERN.exec(responseText);
+    const jsonText = jsonMatch?.[1] ?? responseText;
+    try {
+        return JSON.parse(jsonText);
+    }
+    catch (error) {
+        throw new Error(`Model produced invalid JSON: ${getErrorMessage(error)}`, {
+            cause: error,
+        });
+    }
+}
+function formatTimeoutErrorMessage(timeoutMs) {
+    return `Gemini request timed out after ${formatUsNumber(timeoutMs)}ms.`;
+}
+function formatConcurrencyLimitErrorMessage(limit, waitLimitMs) {
+    return `Too many concurrent Gemini calls (limit: ${formatUsNumber(limit)}; waited ${formatUsNumber(waitLimitMs)}ms).`;
+}
+async function generateContentWithTimeout(request, model, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, timeoutMs);
+    timeout.unref();
+    const signal = combineSignals(controller.signal, request.signal);
+    try {
+        return await getClient().models.generateContent({
+            model,
+            contents: getPromptWithFunctionCallingContext(request),
+            config: buildGenerationConfig(request, signal),
+        });
+    }
+    catch (error) {
+        throwIfRequestCancelled(request.signal);
+        if (controller.signal.aborted) {
+            throw new Error(formatTimeoutErrorMessage(timeoutMs), { cause: error });
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function extractThoughtsFromParts(parts) {
+    if (!Array.isArray(parts)) {
+        return undefined;
+    }
+    const thoughtParts = parts.filter((part) => typeof part === 'object' &&
+        part !== null &&
+        part.thought === true &&
+        typeof part.text === 'string');
+    if (thoughtParts.length === 0) {
+        return undefined;
+    }
+    return thoughtParts.map((part) => part.text).join('\n\n');
+}
+async function executeAttempt(request, model, timeoutMs, attempt, onLog) {
+    const startedAt = performance.now();
+    const response = await generateContentWithTimeout(request, model, timeoutMs);
+    const latencyMs = Math.round(performance.now() - startedAt);
+    const finishReason = response.candidates?.[0]?.finishReason;
+    const thoughts = extractThoughtsFromParts(response.candidates?.[0]?.content?.parts);
+    await emitGeminiLog(onLog, 'info', {
+        event: 'gemini_call',
+        details: {
+            attempt,
+            latencyMs,
+            finishReason: finishReason ?? null,
+            usageMetadata: response.usageMetadata ?? null,
+            ...(thoughts ? { thoughts } : {}),
+        },
+    });
+    if (finishReason === FinishReason.MAX_TOKENS) {
+        const limit = request.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
+        throw new Error(`Response truncated: model output exceeds limit (maxOutputTokens=${formatUsNumber(limit)}). Increase maxOutputTokens or reduce prompt complexity.`);
+    }
+    return parseStructuredResponse(response.text);
+}
+async function waitBeforeRetry(attempt, error, onLog, requestSignal) {
+    const delayMs = getRetryDelayMs(attempt);
+    const reason = getErrorMessage(error);
+    await emitGeminiLog(onLog, 'warning', {
+        event: 'gemini_retry',
+        details: {
+            attempt,
+            delayMs,
+            reason,
+        },
+    });
+    throwIfRequestCancelled(requestSignal);
+    try {
+        await sleep(delayMs, undefined, getSleepOptions(requestSignal));
+    }
+    catch (sleepError) {
+        throwIfRequestCancelled(requestSignal);
+        throw sleepError;
+    }
+}
+async function throwGeminiFailure(attemptsMade, lastError, onLog) {
+    const message = getErrorMessage(lastError);
+    await emitGeminiLog(onLog, 'error', {
+        event: 'gemini_failure',
+        details: {
+            error: message,
+            attempts: attemptsMade,
+        },
+    });
+    throw new Error(`Gemini request failed after ${attemptsMade} attempts: ${message}`, { cause: lastError });
+}
+function shouldUseModelFallback(error, model) {
+    return getNumericErrorCode(error) === 404 && model === DEFAULT_MODEL;
+}
+async function applyModelFallback(request, onLog, reason) {
+    await emitGeminiLog(onLog, 'warning', {
+        event: 'gemini_model_fallback',
+        details: {
+            from: DEFAULT_MODEL,
+            to: MODEL_FALLBACK_TARGET,
+            reason,
+        },
+    });
+    return {
+        model: MODEL_FALLBACK_TARGET,
+        request: omitThinkingLevel(request),
+    };
+}
+async function tryApplyModelFallback(error, model, request, onLog, reason) {
+    if (!shouldUseModelFallback(error, model)) {
+        return undefined;
+    }
+    return applyModelFallback(request, onLog, reason);
+}
+function countAttemptsMade(attempt) {
+    return attempt + 1;
+}
+async function runWithRetries(request, model, timeoutMs, maxRetries, onLog) {
+    let lastError;
+    let currentModel = model;
+    let effectiveRequest = request;
+    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+        try {
+            return await executeAttempt(effectiveRequest, currentModel, timeoutMs, attempt, onLog);
+        }
+        catch (error) {
+            lastError = error;
+            const fallback = await tryApplyModelFallback(error, currentModel, request, onLog, 'Model not found (404)');
+            if (fallback) {
+                currentModel = fallback.model;
+                effectiveRequest = fallback.request;
+                continue;
+            }
+            if (!canRetryAttempt(attempt, maxRetries, error)) {
+                return throwGeminiFailure(countAttemptsMade(attempt), lastError, onLog);
+            }
+            await waitBeforeRetry(attempt, error, onLog, request.signal);
+        }
+    }
+    return throwGeminiFailure(maxRetries + 1, lastError, onLog);
+}
+function omitThinkingLevel(request) {
+    const copy = { ...request };
+    Reflect.deleteProperty(copy, 'thinkingLevel');
+    return copy;
+}
+function isInlineBatchMode(mode) {
+    return mode === 'inline';
+}
+async function acquireQueueSlot(mode, requestSignal) {
+    const queueWaitStartedAt = performance.now();
+    if (isInlineBatchMode(mode)) {
+        await batchCallLimiter.acquire(requestSignal);
+    }
+    else {
+        await callLimiter.acquire(requestSignal);
+    }
+    return {
+        queueWaitMs: Math.round(performance.now() - queueWaitStartedAt),
+        waitingCalls: isInlineBatchMode(mode)
+            ? batchCallLimiter.pendingCount
+            : callLimiter.pendingCount,
+    };
+}
+function releaseQueueSlot(mode) {
+    if (isInlineBatchMode(mode)) {
+        batchCallLimiter.release();
+        return;
+    }
+    callLimiter.release();
+}
+const BatchHelper = {
+    getState(payload) {
+        const record = toRecord(payload);
+        if (!record)
+            return undefined;
+        const directState = toUpperStringCode(record.state);
+        if (directState)
+            return directState;
+        const metadata = toRecord(record.metadata);
+        return metadata ? toUpperStringCode(metadata.state) : undefined;
+    },
+    getResponseText(payload) {
+        const record = toRecord(payload);
+        if (!record)
+            return undefined;
+        // Try inlineResponse.text
+        const inline = toRecord(record.inlineResponse);
+        if (typeof inline?.text === 'string')
+            return inline.text;
+        const response = toRecord(record.response);
+        if (!response)
+            return undefined;
+        // Try response.text
+        if (typeof response.text === 'string')
+            return response.text;
+        // Try response.inlineResponses[0].text
+        if (Array.isArray(response.inlineResponses) &&
+            response.inlineResponses.length > 0) {
+            const first = toRecord(response.inlineResponses[0]);
+            if (typeof first?.text === 'string')
+                return first.text;
+        }
+        return undefined;
+    },
+    getErrorDetail(payload) {
+        const record = toRecord(payload);
+        if (!record)
+            return undefined;
+        // Try error.message
+        const directError = toRecord(record.error);
+        if (typeof directError?.message === 'string')
+            return directError.message;
+        // Try metadata.error.message
+        const metadata = toRecord(record.metadata);
+        const metaError = toRecord(metadata?.error);
+        if (typeof metaError?.message === 'string')
+            return metaError.message;
+        // Try response.error.message
+        const response = toRecord(record.response);
+        const respError = toRecord(response?.error);
+        return typeof respError?.message === 'string'
+            ? respError.message
+            : undefined;
+    },
+    getSuccessResponseText(polled) {
+        const text = this.getResponseText(polled);
+        if (text)
+            return text;
+        const err = this.getErrorDetail(polled);
+        throw new Error(err
+            ? `Gemini batch request succeeded but returned no response text: ${err}`
+            : 'Gemini batch request succeeded but returned no response text.');
+    },
+    handleTerminalState(state, payload) {
+        if (state === 'JOB_STATE_FAILED' || state === 'JOB_STATE_CANCELLED') {
+            const err = this.getErrorDetail(payload);
+            throw new Error(err
+                ? `Gemini batch request ended with state ${state}: ${err}`
+                : `Gemini batch request ended with state ${state}.`);
+        }
+    },
+};
+async function pollBatchStatusWithRetries(batches, batchName, onLog, requestSignal) {
+    const maxPollRetries = 2;
+    for (let attempt = 0; attempt <= maxPollRetries; attempt += 1) {
+        try {
+            return await batches.get({ name: batchName });
+        }
+        catch (error) {
+            if (!canRetryAttempt(attempt, maxPollRetries, error)) {
+                throw error;
+            }
+            await waitBeforeRetry(attempt, error, onLog, requestSignal);
+        }
+    }
+    throw new Error('Batch polling retries exhausted unexpectedly.');
+}
+async function cancelBatchIfNeeded(request, batches, batchName, onLog, completed, timedOut) {
+    const aborted = request.signal?.aborted === true;
+    const shouldCancel = !completed && (aborted || timedOut);
+    if (!shouldCancel || !batchName || !batches.cancel) {
+        return;
+    }
+    const reason = timedOut ? 'timeout' : 'aborted';
+    try {
+        await batches.cancel({ name: batchName });
+        await emitGeminiLog(onLog, 'info', {
+            event: 'gemini_batch_cancelled',
+            details: { batchName, reason },
+        });
+    }
+    catch (error) {
+        await emitGeminiLog(onLog, 'warning', {
+            event: 'gemini_batch_cancel_failed',
+            details: {
+                batchName,
+                reason,
+                error: getErrorMessage(error),
+            },
+        });
+    }
+}
+async function createBatchJobWithFallback(request, batches, model, onLog) {
+    let currentModel = model;
+    let effectiveRequest = request;
+    const createSignal = request.signal ?? NEVER_ABORT_SIGNAL;
+    for (let attempt = 0; attempt <= 1; attempt += 1) {
+        try {
+            const createPayload = {
+                model: currentModel,
+                src: [
+                    {
+                        contents: [
+                            { role: 'user', parts: [{ text: effectiveRequest.prompt }] },
+                        ],
+                        config: buildGenerationConfig(effectiveRequest, createSignal),
+                    },
+                ],
+            };
+            return await batches.create(createPayload);
+        }
+        catch (error) {
+            if (attempt === 0 && shouldUseModelFallback(error, currentModel)) {
+                const fallback = await applyModelFallback(request, onLog, 'Model not found (404) during batch create');
+                currentModel = fallback.model;
+                effectiveRequest = fallback.request;
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error('Unexpected state: batch creation loop exited without returning or throwing.');
+}
+async function pollBatchForCompletion(batches, batchName, onLog, requestSignal) {
+    const pollIntervalMs = batchPollIntervalMsConfig.get();
+    const timeoutMs = batchTimeoutMsConfig.get();
+    const pollStart = performance.now();
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    while (true) {
+        throwIfRequestCancelled(requestSignal);
+        const elapsedMs = Math.round(performance.now() - pollStart);
+        if (elapsedMs > timeoutMs) {
+            throw new Error(`Gemini batch request timed out after ${formatUsNumber(timeoutMs)}ms.`);
+        }
+        const polled = await pollBatchStatusWithRetries(batches, batchName, onLog, requestSignal);
+        const state = BatchHelper.getState(polled);
+        if (state === 'JOB_STATE_SUCCEEDED') {
+            const responseText = BatchHelper.getSuccessResponseText(polled);
+            return parseStructuredResponse(responseText);
+        }
+        BatchHelper.handleTerminalState(state, polled);
+        await sleep(pollIntervalMs, undefined, getSleepOptions(requestSignal));
+    }
+}
+async function runInlineBatchWithPolling(request, model, onLog) {
+    const client = getClient();
+    const { batches } = client;
+    if (!batches) {
+        throw new Error('Batch mode requires SDK batch support, but batches API is unavailable.');
+    }
+    let batchName;
+    let completed = false;
+    let timedOut = false;
+    try {
+        const createdJob = await createBatchJobWithFallback(request, batches, model, onLog);
+        const createdRecord = toRecord(createdJob);
+        batchName =
+            typeof createdRecord?.name === 'string' ? createdRecord.name : undefined;
+        if (!batchName)
+            throw new Error('Batch mode failed to return a job name.');
+        await emitGeminiLog(onLog, 'info', {
+            event: 'gemini_batch_created',
+            details: { batchName },
+        });
+        const result = await pollBatchForCompletion(batches, batchName, onLog, request.signal);
+        completed = true;
+        return result;
+    }
+    catch (error) {
+        if (getErrorMessage(error).includes('timed out')) {
+            timedOut = true;
+        }
+        throw error;
+    }
+    finally {
+        await cancelBatchIfNeeded(request, batches, batchName, onLog, completed, timedOut);
+    }
+}
+export function getGeminiQueueSnapshot() {
+    return {
+        activeWaiters: callLimiter.pendingCount,
+        activeCalls: callLimiter.active,
+        activeBatchWaiters: batchCallLimiter.pendingCount,
+        activeBatchCalls: batchCallLimiter.active,
+    };
+}
+export async function generateStructuredJson(request) {
+    const model = request.model ?? getDefaultModel();
+    const timeoutMs = request.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxRetries = request.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const batchMode = request.batchMode ?? getDefaultBatchMode();
+    const { onLog } = request;
+    const { queueWaitMs, waitingCalls } = await acquireQueueSlot(batchMode, request.signal);
+    await safeCallOnLog(onLog, 'info', {
+        event: 'gemini_queue_acquired',
+        queueWaitMs,
+        waitingCalls,
+        activeCalls: callLimiter.active,
+        activeBatchCalls: batchCallLimiter.active,
+        mode: batchMode,
+    });
+    try {
+        return await geminiContext.run({ requestId: nextRequestId(), model }, () => {
+            if (isInlineBatchMode(batchMode)) {
+                return runInlineBatchWithPolling(request, model, onLog);
+            }
+            return runWithRetries(request, model, timeoutMs, maxRetries, onLog);
+        });
+    }
+    finally {
+        releaseQueueSlot(batchMode);
+    }
+}