@j0hanz/code-assistant 0.9.0

package/dist/lib/tools.js

@@ -0,0 +1,646 @@
+import { z } from 'zod';
+import { DefaultOutputSchema } from '../schemas/outputs.js';
+import { ANALYSIS_TEMPERATURE, CREATIVE_TEMPERATURE, FLASH_API_BREAKING_MAX_OUTPUT_TOKENS, FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS, FLASH_MODEL, FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS, FLASH_THINKING_LEVEL, FLASH_TRIAGE_MAX_OUTPUT_TOKENS, FLASH_TRIAGE_THINKING_LEVEL, TRIAGE_TEMPERATURE, } from './config.js';
+import { createCachedEnvInt } from './config.js';
+import { createNoDiffError, diffStaleWarningMs, getDiff, } from './diff.js';
+import { validateDiffBudget } from './diff.js';
+import { EMPTY_DIFF_STATS } from './diff.js';
+import { classifyErrorMeta } from './errors.js';
+import { getErrorMessage } from './errors.js';
+import { stripJsonSchemaConstraints } from './gemini.js';
+import { generateStructuredJson } from './gemini.js';
+import { createFailureStatusMessage, DEFAULT_PROGRESS_CONTEXT, extractValidationMessage, getOrCreateProgressReporter, normalizeProgressContext, RunReporter, sendSingleStepProgress, STEP_BUILDING_PROMPT, STEP_CALLING_MODEL, STEP_FINALIZING, STEP_STARTING, STEP_VALIDATING, STEP_VALIDATING_RESPONSE, } from './progress.js';
+function appendErrorMeta(error, meta) {
+    if (meta?.retryable !== undefined) {
+        error.retryable = meta.retryable;
+    }
+    if (meta?.kind !== undefined) {
+        error.kind = meta.kind;
+    }
+}
+function createToolError(code, message, meta) {
+    const error = { code, message };
+    appendErrorMeta(error, meta);
+    return error;
+}
+function toTextContent(structured, textContent) {
+    const text = textContent ?? JSON.stringify(structured);
+    return [{ type: 'text', text }];
+}
+function createErrorStructuredContent(code, message, result, meta) {
+    const error = createToolError(code, message, meta);
+    if (result === undefined) {
+        return { ok: false, error };
+    }
+    return { ok: false, error, result };
+}
+export function createToolResponse(structured, textContent) {
+    return {
+        content: toTextContent(structured, textContent),
+        structuredContent: structured,
+    };
+}
+export function createErrorToolResponse(code, message, result, meta) {
+    const structured = createErrorStructuredContent(code, message, result, meta);
+    return {
+        content: toTextContent(structured),
+        isError: true,
+    };
+}
+const DEFAULT_TIMEOUT_FLASH_MS = 90_000;
+export const INSPECTION_FOCUS_AREAS = [
+    'security',
+    'correctness',
+    'performance',
+    'regressions',
+    'tests',
+    'maintainability',
+    'concurrency',
+];
+export function buildStructuredToolRuntimeOptions(contract) {
+    return {
+        ...(contract.thinkingLevel !== undefined
+            ? { thinkingLevel: contract.thinkingLevel }
+            : {}),
+        ...(contract.temperature !== undefined
+            ? { temperature: contract.temperature }
+            : {}),
+        ...(contract.deterministicJson !== undefined
+            ? { deterministicJson: contract.deterministicJson }
+            : {}),
+    };
+}
+export function buildStructuredToolExecutionOptions(contract) {
+    return {
+        timeoutMs: contract.timeoutMs,
+        maxOutputTokens: contract.maxOutputTokens,
+        ...buildStructuredToolRuntimeOptions(contract),
+    };
+}
+function createParam(name, type, required, constraints, description) {
+    return { name, type, required, constraints, description };
+}
+function cloneParams(...params) {
+    return params.map((param) => ({ ...param }));
+}
+const MODE_PARAM = createParam('mode', 'string', true, "'unstaged' | 'staged'", "'unstaged': working tree changes not yet staged. 'staged': changes added to the index (git add).");
+const REPOSITORY_PARAM = createParam('repository', 'string', true, '1-200 chars', 'Repository identifier (org/repo).');
+const LANGUAGE_PARAM = createParam('language', 'string', false, '2-32 chars', 'Primary language hint.');
+const TEST_FRAMEWORK_PARAM = createParam('testFramework', 'string', false, '1-50 chars', 'Framework hint (jest, vitest, pytest, node:test).');
+const MAX_TEST_CASES_PARAM = createParam('maxTestCases', 'number', false, '1-30', 'Post-generation cap applied to test cases.');
+export const TOOL_CONTRACTS = [
+    {
+        name: 'generate_diff',
+        purpose: 'Generate a diff of current changes and cache it server-side. MUST be called before any other tool. Uses git to capture unstaged or staged changes in the current working directory.',
+        model: 'none',
+        timeoutMs: 0,
+        maxOutputTokens: 0,
+        params: cloneParams(MODE_PARAM),
+        outputShape: '{ok, result: {diffRef, stats{files, added, deleted}, generatedAt, mode, message}}',
+        gotchas: [
+            'Must be called first — all other tools return E_NO_DIFF if no diff is cached.',
+            'Noisy files (lock files, dist/, build/, minified assets) are excluded automatically.',
+            'Empty diff (no changes) returns E_NO_CHANGES.',
+        ],
+        crossToolFlow: [
+            'Caches diff at diff://current — consumed automatically by all review tools.',
+        ],
+    },
+    {
+        name: 'analyze_pr_impact',
+        purpose: 'Assess severity, categories, breaking changes, and rollback complexity.',
+        model: FLASH_MODEL,
+        timeoutMs: DEFAULT_TIMEOUT_FLASH_MS,
+        thinkingLevel: FLASH_TRIAGE_THINKING_LEVEL,
+        maxOutputTokens: FLASH_TRIAGE_MAX_OUTPUT_TOKENS,
+        temperature: TRIAGE_TEMPERATURE,
+        deterministicJson: true,
+        params: cloneParams(REPOSITORY_PARAM, LANGUAGE_PARAM),
+        outputShape: '{severity, categories[], summary, breakingChanges[], affectedAreas[], rollbackComplexity}',
+        gotchas: [
+            'Requires generate_diff to be called first.',
+            'Flash triage tool optimized for speed.',
+        ],
+        crossToolFlow: [
+            'severity/categories feed triage and merge-gate decisions.',
+        ],
+    },
+    {
+        name: 'generate_review_summary',
+        purpose: 'Produce PR summary, risk rating, and merge recommendation.',
+        model: FLASH_MODEL,
+        timeoutMs: DEFAULT_TIMEOUT_FLASH_MS,
+        thinkingLevel: FLASH_TRIAGE_THINKING_LEVEL,
+        maxOutputTokens: FLASH_TRIAGE_MAX_OUTPUT_TOKENS,
+        temperature: TRIAGE_TEMPERATURE,
+        deterministicJson: true,
+        params: cloneParams(REPOSITORY_PARAM, LANGUAGE_PARAM),
+        outputShape: '{summary, overallRisk, keyChanges[], recommendation, stats{filesChanged, linesAdded, linesRemoved}}',
+        gotchas: [
+            'Requires generate_diff to be called first.',
+            'stats are computed locally from the diff.',
+        ],
+        crossToolFlow: [
+            'Use before deep review to decide whether Pro analysis is needed.',
+        ],
+    },
+    {
+        name: 'generate_test_plan',
+        purpose: 'Generate prioritized test cases and coverage guidance.',
+        model: FLASH_MODEL,
+        timeoutMs: DEFAULT_TIMEOUT_FLASH_MS,
+        thinkingLevel: FLASH_THINKING_LEVEL,
+        maxOutputTokens: FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS,
+        temperature: CREATIVE_TEMPERATURE,
+        deterministicJson: true,
+        params: cloneParams(REPOSITORY_PARAM, LANGUAGE_PARAM, TEST_FRAMEWORK_PARAM, MAX_TEST_CASES_PARAM),
+        outputShape: '{summary, testCases[], coverageSummary}',
+        gotchas: [
+            'Requires generate_diff to be called first.',
+            'maxTestCases caps output after generation.',
+        ],
+        crossToolFlow: ['Pair with review tools to validate high-risk paths.'],
+    },
+    {
+        name: 'analyze_time_space_complexity',
+        purpose: 'Analyze Big-O complexity and detect degradations in changed code.',
+        model: FLASH_MODEL,
+        timeoutMs: DEFAULT_TIMEOUT_FLASH_MS,
+        thinkingLevel: FLASH_THINKING_LEVEL,
+        maxOutputTokens: FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS,
+        temperature: ANALYSIS_TEMPERATURE,
+        deterministicJson: true,
+        params: cloneParams(LANGUAGE_PARAM),
+        outputShape: '{timeComplexity, spaceComplexity, explanation, potentialBottlenecks[], isDegradation}',
+        gotchas: [
+            'Requires generate_diff to be called first.',
+            'Analyzes only changed code visible in the diff.',
+        ],
+        crossToolFlow: ['Use for algorithmic/performance-sensitive changes.'],
+    },
+    {
+        name: 'detect_api_breaking_changes',
+        purpose: 'Detect breaking API/interface changes in a diff.',
+        model: FLASH_MODEL,
+        timeoutMs: DEFAULT_TIMEOUT_FLASH_MS,
+        thinkingLevel: FLASH_TRIAGE_THINKING_LEVEL,
+        maxOutputTokens: FLASH_API_BREAKING_MAX_OUTPUT_TOKENS,
+        temperature: TRIAGE_TEMPERATURE,
+        deterministicJson: true,
+        params: cloneParams(LANGUAGE_PARAM),
+        outputShape: '{hasBreakingChanges, breakingChanges[]}',
+        gotchas: [
+            'Requires generate_diff to be called first.',
+            'Targets public API contracts over internal refactors.',
+        ],
+        crossToolFlow: ['Run before merge for API-surface-sensitive changes.'],
+    },
+];
+const TOOL_CONTRACTS_BY_NAME = new Map(TOOL_CONTRACTS.map((contract) => [contract.name, contract]));
+export function getToolContracts() {
+    return TOOL_CONTRACTS;
+}
+export function getToolContract(toolName) {
+    return TOOL_CONTRACTS_BY_NAME.get(toolName);
+}
+export function requireToolContract(toolName) {
+    const contract = getToolContract(toolName);
+    if (contract) {
+        return contract;
+    }
+    throw new Error(`Unknown tool contract: ${toolName}`);
+}
+export function getToolContractNames() {
+    return TOOL_CONTRACTS.map((contract) => contract.name);
+}
+const DEFAULT_SCHEMA_RETRIES = 1;
+const geminiSchemaRetriesConfig = createCachedEnvInt('GEMINI_SCHEMA_RETRIES', DEFAULT_SCHEMA_RETRIES);
+const DEFAULT_SCHEMA_RETRY_ERROR_CHARS = 1_500;
+const schemaRetryErrorCharsConfig = createCachedEnvInt('MAX_SCHEMA_RETRY_ERROR_CHARS', DEFAULT_SCHEMA_RETRY_ERROR_CHARS);
+const DEFAULT_TASK_TTL_MS = 300_000;
+const taskTtlMsConfig = createCachedEnvInt('TASK_TTL_MS', DEFAULT_TASK_TTL_MS);
+const DETERMINISTIC_JSON_RETRY_NOTE = 'Deterministic JSON mode: keep key names exactly as schema-defined and preserve stable field ordering.';
+const COMPLETED_STATUS_PREFIX = 'completed: ';
+const STALE_DIFF_WARNING_PREFIX = '\n\nWarning: The analyzed diff is over ';
+const STALE_DIFF_WARNING_SUFFIX = ' minutes old. If you have made recent changes, please run generate_diff again.';
+const JSON_PARSE_ERROR_PATTERN = /model produced invalid json/i;
+const responseSchemaCache = new WeakMap();
+function buildToolAnnotations(annotations) {
+    if (!annotations) {
+        return {
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        };
+    }
+    const { destructiveHint, ...annotationOverrides } = annotations;
+    return {
+        readOnlyHint: !destructiveHint,
+        idempotentHint: !destructiveHint,
+        openWorldHint: true,
+        ...annotationOverrides,
+    };
+}
+function createGeminiResponseSchema(config) {
+    const sourceSchema = config.geminiSchema ?? config.resultSchema;
+    return stripJsonSchemaConstraints(z.toJSONSchema(sourceSchema));
+}
+function getCachedGeminiResponseSchema(config) {
+    const cached = responseSchemaCache.get(config);
+    if (cached) {
+        return cached;
+    }
+    const responseSchema = createGeminiResponseSchema({
+        geminiSchema: config.geminiSchema,
+        resultSchema: config.resultSchema,
+    });
+    responseSchemaCache.set(config, responseSchema);
+    return responseSchema;
+}
+function parseToolInput(input, fullInputSchema) {
+    return fullInputSchema.parse(input);
+}
+function extractResponseKeyOrdering(responseSchema) {
+    const schemaType = responseSchema.type;
+    if (schemaType !== 'object') {
+        return undefined;
+    }
+    const { properties } = responseSchema;
+    if (typeof properties !== 'object' || properties === null) {
+        return undefined;
+    }
+    return Object.keys(properties);
+}
+export function summarizeSchemaValidationErrorForRetry(errorMessage) {
+    const maxChars = Math.max(200, schemaRetryErrorCharsConfig.get());
+    const compact = errorMessage.replace(/\s+/g, ' ').trim();
+    if (compact.length <= maxChars) {
+        return compact;
+    }
+    return `${compact.slice(0, maxChars - 3)}...`;
+}
+function createSchemaRetryPrompt(prompt, errorMessage, deterministicJson) {
+    const summarizedError = summarizeSchemaValidationErrorForRetry(errorMessage);
+    const deterministicNote = deterministicJson
+        ? `\n${DETERMINISTIC_JSON_RETRY_NOTE}`
+        : '';
+    return {
+        summarizedError,
+        prompt: `CRITICAL: The previous response failed schema validation. Error: ${summarizedError}${deterministicNote}\n\n${prompt}`,
+    };
+}
+function isRetryableSchemaError(error) {
+    const isZodError = error instanceof z.ZodError;
+    return isZodError || JSON_PARSE_ERROR_PATTERN.test(getErrorMessage(error));
+}
+function createGenerationRequest(config, promptParts, responseSchema, onLog, signal) {
+    const request = {
+        systemInstruction: promptParts.systemInstruction,
+        prompt: promptParts.prompt,
+        responseSchema,
+        onLog,
+        ...(config.thinkingLevel !== undefined
+            ? { thinkingLevel: config.thinkingLevel }
+            : {}),
+        ...(config.timeoutMs !== undefined ? { timeoutMs: config.timeoutMs } : {}),
+        ...(config.maxOutputTokens !== undefined
+            ? { maxOutputTokens: config.maxOutputTokens }
+            : {}),
+        ...(config.temperature !== undefined
+            ? { temperature: config.temperature }
+            : {}),
+        ...(config.includeThoughts !== undefined
+            ? { includeThoughts: config.includeThoughts }
+            : {}),
+        ...(config.batchMode !== undefined ? { batchMode: config.batchMode } : {}),
+        ...(signal !== undefined ? { signal } : {}),
+    };
+    if (config.deterministicJson) {
+        const responseKeyOrdering = extractResponseKeyOrdering(responseSchema);
+        if (responseKeyOrdering !== undefined) {
+            request.responseKeyOrdering = responseKeyOrdering;
+        }
+    }
+    return request;
+}
+function appendStaleDiffWarning(textContent, diffSlot) {
+    if (!diffSlot) {
+        return textContent;
+    }
+    const ageMs = Date.now() - new Date(diffSlot.generatedAt).getTime();
+    if (ageMs <= diffStaleWarningMs.get()) {
+        return textContent;
+    }
+    const ageMinutes = Math.round(ageMs / 60_000);
+    const warning = `${STALE_DIFF_WARNING_PREFIX}${ageMinutes}${STALE_DIFF_WARNING_SUFFIX}`;
+    return textContent ? textContent + warning : warning;
+}
+function toLoggingLevel(level) {
+    switch (level) {
+        case 'debug':
+        case 'info':
+        case 'notice':
+        case 'warning':
+        case 'error':
+        case 'critical':
+        case 'alert':
+        case 'emergency':
+            return level;
+        default:
+            return 'error';
+    }
+}
+function asObjectRecord(value) {
+    if (typeof value === 'object' && value !== null) {
+        return value;
+    }
+    return { payload: value };
+}
+async function safeSendProgress(extra, toolName, context, current, state) {
+    try {
+        await sendSingleStepProgress(extra, toolName, context, current, state);
+    }
+    catch {
+        // Progress is best-effort; tool execution must not fail on notification errors.
+    }
+}
+export function wrapToolHandler(options, handler) {
+    return async (input, extra) => {
+        const context = normalizeProgressContext(options.progressContext?.(input));
+        await safeSendProgress(extra, options.toolName, context, 0, 'starting');
+        try {
+            const result = await handler(input, extra);
+            const outcome = result.isError ? 'failed' : 'completed';
+            await safeSendProgress(extra, options.toolName, context, 1, outcome);
+            return result;
+        }
+        catch (error) {
+            const errorMessage = getErrorMessage(error);
+            const failureMeta = classifyErrorMeta(error, errorMessage);
+            const outcome = failureMeta.kind === 'cancelled' ? 'cancelled' : 'failed';
+            await safeSendProgress(extra, options.toolName, context, 1, outcome);
+            throw error;
+        }
+    };
+}
+async function validateRequest(config, inputRecord, ctx) {
+    if (config.requiresDiff) {
+        if (!ctx.diffSlot) {
+            return createNoDiffError();
+        }
+        const budgetError = validateDiffBudget(ctx.diffSlot.diff);
+        if (budgetError) {
+            return budgetError;
+        }
+    }
+    if (config.validateInput) {
+        return await config.validateInput(inputRecord, ctx);
+    }
+    return undefined;
+}
+export class ToolExecutionRunner {
+    config;
+    signal;
+    diffSlotSnapshot;
+    hasSnapshot = false;
+    responseSchema;
+    onLog;
+    reporter;
+    constructor(config, dependencies, signal) {
+        this.config = config;
+        this.signal = signal;
+        this.responseSchema = getCachedGeminiResponseSchema(config);
+        // Initialize reporter with placeholder context; updated in run()
+        this.reporter = new RunReporter(config.name, dependencies.reportProgress, dependencies.statusReporter, DEFAULT_PROGRESS_CONTEXT);
+        this.onLog = async (level, data) => {
+            try {
+                await dependencies.onLog(level, data);
+            }
+            catch {
+                // Ignore logging failures
+            }
+            await this.handleInternalLog(data);
+        };
+    }
+    async handleInternalLog(data) {
+        const record = asObjectRecord(data);
+        if (record.event === 'gemini_retry') {
+            const details = asObjectRecord(record.details);
+            const { attempt } = details;
+            const msg = `Network error. Retrying (attempt ${String(attempt)})...`;
+            await this.reporter.reportStep(STEP_CALLING_MODEL, msg);
+        }
+        else if (record.event === 'gemini_queue_acquired') {
+            const msg = 'Model queue acquired, generating response...';
+            await this.reporter.reportStep(STEP_CALLING_MODEL, msg);
+        }
+    }
+    setResponseSchemaOverride(responseSchema) {
+        this.responseSchema = responseSchema;
+        responseSchemaCache.set(this.config, responseSchema);
+    }
+    setDiffSlotSnapshot(diffSlotSnapshot) {
+        this.diffSlotSnapshot = diffSlotSnapshot;
+        this.hasSnapshot = true;
+    }
+    async executeValidation(inputRecord, ctx) {
+        const validationError = await validateRequest(this.config, inputRecord, ctx);
+        if (validationError) {
+            const validationMessage = extractValidationMessage(validationError);
+            await this.reporter.updateStatus(validationMessage);
+            await this.reporter.reportCompletion('rejected');
+            await this.reporter.storeResultSafely('completed', validationError, this.onLog);
+            return validationError;
+        }
+        return undefined;
+    }
+    async executeModelCallAttempt(systemInstruction, prompt, attempt) {
+        const raw = await generateStructuredJson(createGenerationRequest(this.config, { systemInstruction, prompt }, this.responseSchema, this.onLog, this.signal));
+        if (attempt === 0) {
+            await this.reporter.reportStep(STEP_VALIDATING_RESPONSE, 'Verifying output structure...');
+        }
+        return this.config.resultSchema.parse(raw);
+    }
+    async executeModelCall(systemInstruction, prompt) {
+        let retryPrompt = prompt;
+        const maxRetries = this.config.schemaRetries ?? geminiSchemaRetriesConfig.get();
+        for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+            try {
+                return await this.executeModelCallAttempt(systemInstruction, retryPrompt, attempt);
+            }
+            catch (error) {
+                if (attempt >= maxRetries || !isRetryableSchemaError(error)) {
+                    throw error;
+                }
+                const errorMessage = getErrorMessage(error);
+                const schemaRetryPrompt = createSchemaRetryPrompt(prompt, errorMessage, this.config.deterministicJson === true);
+                await this.onLog('warning', {
+                    event: 'schema_validation_failed',
+                    details: {
+                        attempt,
+                        error: schemaRetryPrompt.summarizedError,
+                        originalChars: errorMessage.length,
+                    },
+                });
+                await this.reporter.reportSchemaRetry(attempt + 1, maxRetries);
+                retryPrompt = schemaRetryPrompt.prompt;
+            }
+        }
+        throw new Error('Unexpected state: execution loop exhausted');
+    }
+    createExecutionContext() {
+        return {
+            diffSlot: this.hasSnapshot ? this.diffSlotSnapshot : getDiff(),
+        };
+    }
+    applyResultTransform(inputRecord, parsed, ctx) {
+        return (this.config.transformResult
+            ? this.config.transformResult(inputRecord, parsed, ctx)
+            : parsed);
+    }
+    formatResultText(finalResult, ctx) {
+        const textContent = this.config.formatOutput
+            ? this.config.formatOutput(finalResult)
+            : undefined;
+        return appendStaleDiffWarning(textContent, ctx.diffSlot);
+    }
+    async finalizeSuccessfulRun(finalResult, textContent) {
+        const outcome = this.config.formatOutcome?.(finalResult) ?? 'completed';
+        await this.reporter.reportCompletion(outcome);
+        await this.reporter.updateStatus(`${COMPLETED_STATUS_PREFIX}${outcome}`);
+        const successResponse = createToolResponse({
+            ok: true,
+            result: finalResult,
+        }, textContent);
+        await this.reporter.storeResultSafely('completed', successResponse, this.onLog);
+        return successResponse;
+    }
+    async handleRunFailure(error) {
+        const errorMessage = getErrorMessage(error);
+        const errorMeta = classifyErrorMeta(error, errorMessage);
+        const outcome = errorMeta.kind === 'cancelled' ? 'cancelled' : 'failed';
+        await this.reporter.updateStatus(createFailureStatusMessage(outcome, errorMessage));
+        const errorResponse = createErrorToolResponse(this.config.errorCode, errorMessage, undefined, errorMeta);
+        await this.reporter.storeResultSafely('failed', errorResponse, this.onLog);
+        await this.reporter.reportCompletion(outcome);
+        return errorResponse;
+    }
+    async run(input) {
+        try {
+            await this.reporter.reportStep(STEP_STARTING, 'Initializing...');
+            const inputRecord = parseToolInput(input, this.config.fullInputSchema);
+            const newContext = normalizeProgressContext(this.config.progressContext?.(inputRecord));
+            this.reporter.updateContext(newContext);
+            const ctx = this.createExecutionContext();
+            await this.reporter.reportStep(STEP_VALIDATING, 'Validating request parameters...');
+            const validationError = await this.executeValidation(inputRecord, ctx);
+            if (validationError) {
+                return validationError;
+            }
+            await this.reporter.reportStep(STEP_BUILDING_PROMPT, 'Constructing analysis context...');
+            const promptParts = this.config.buildPrompt(inputRecord, ctx);
+            const { prompt, systemInstruction } = promptParts;
+            await this.reporter.reportStep(STEP_CALLING_MODEL, 'Querying Gemini model...');
+            const parsed = await this.executeModelCall(systemInstruction, prompt);
+            await this.reporter.reportStep(STEP_FINALIZING, 'Processing results...');
+            const finalResult = this.applyResultTransform(inputRecord, parsed, ctx);
+            const textContent = this.formatResultText(finalResult, ctx);
+            return await this.finalizeSuccessfulRun(finalResult, textContent);
+        }
+        catch (error) {
+            return await this.handleRunFailure(error);
+        }
+    }
+}
+function createGeminiLogger(server) {
+    return async (level, data) => {
+        try {
+            await server.sendLoggingMessage({
+                level: toLoggingLevel(level),
+                logger: 'gemini',
+                data: asObjectRecord(data),
+            });
+        }
+        catch {
+            // Fallback if logging fails
+        }
+    };
+}
+function createTaskStatusReporter(taskId, extra, extendedStore) {
+    return {
+        updateStatus: async (message) => {
+            await extendedStore.updateTaskStatus(taskId, 'working', message);
+        },
+        storeResult: async (status, result) => {
+            await extra.taskStore.storeTaskResult(taskId, status, result);
+        },
+    };
+}
+function runToolTaskInBackground(runner, input, taskId, extendedStore, signal) {
+    runner.run(input).catch(async (error) => {
+        const isAbort = error != null &&
+            typeof error === 'object' &&
+            'name' in error &&
+            error.name === 'AbortError';
+        const isCancelled = (signal?.aborted ?? false) || isAbort;
+        try {
+            await extendedStore.updateTaskStatus(taskId, isCancelled ? 'cancelled' : 'failed', getErrorMessage(error));
+        }
+        catch {
+            // Status update failed — nothing more we can do
+        }
+    });
+}
+export function registerStructuredToolTask(server, config) {
+    const responseSchema = createGeminiResponseSchema({
+        geminiSchema: config.geminiSchema,
+        resultSchema: config.resultSchema,
+    });
+    responseSchemaCache.set(config, responseSchema);
+    server.experimental.tasks.registerToolTask(config.name, {
+        title: config.title,
+        description: config.description,
+        inputSchema: config.inputSchema,
+        outputSchema: DefaultOutputSchema,
+        annotations: buildToolAnnotations(config.annotations),
+        execution: {
+            taskSupport: 'optional',
+        },
+    }, {
+        createTask: async (input, extra) => {
+            const task = await extra.taskStore.createTask({
+                ttl: taskTtlMsConfig.get(),
+            });
+            const extendedStore = extra.taskStore;
+            const runner = new ToolExecutionRunner(config, {
+                onLog: createGeminiLogger(server),
+                reportProgress: getOrCreateProgressReporter(extra),
+                statusReporter: createTaskStatusReporter(task.taskId, extra, extendedStore),
+            }, extra.signal);
+            runToolTaskInBackground(runner, input, task.taskId, extendedStore, extra.signal);
+            return { task };
+        },
+        getTask: async (input, extra) => {
+            return await extra.taskStore.getTask(extra.taskId);
+        },
+        getTaskResult: async (input, extra) => {
+            return (await extra.taskStore.getTaskResult(extra.taskId));
+        },
+    });
+}
+const EMPTY_PARSED_FILES = [];
+export function getDiffContextSnapshot(ctx) {
+    const slot = ctx.diffSlot;
+    if (!slot) {
+        return {
+            diff: '',
+            parsedFiles: EMPTY_PARSED_FILES,
+            stats: EMPTY_DIFF_STATS,
+        };
+    }
+    return {
+        diff: slot.diff,
+        parsedFiles: slot.parsedFiles,
+        stats: slot.stats,
+    };
+}

package/dist/prompts/index.d.ts

@@ -0,0 +1,11 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare const PROMPT_DEFINITIONS: readonly [{
+    readonly name: "get-help";
+    readonly title: "Get Help";
+    readonly description: "Server instructions.";
+}, {
+    readonly name: "review-guide";
+    readonly title: "Review Guide";
+    readonly description: "Workflow guide for tool/focus area.";
+}];
+export declare function registerAllPrompts(server: McpServer, instructions: string): void;