/**
 * @license
 * Copyright 2026 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */
// Import factories
import { createToolMaskingProcessor } from '../processors/toolMaskingProcessor.js';
import { createBlobDegradationProcessor } from '../processors/blobDegradationProcessor.js';
import { createNodeTruncationProcessor } from '../processors/nodeTruncationProcessor.js';
import { createNodeDistillationProcessor } from '../processors/nodeDistillationProcessor.js';
import { createStateSnapshotProcessor } from '../processors/stateSnapshotProcessor.js';
import { createStateSnapshotAsyncProcessor } from '../processors/stateSnapshotAsyncProcessor.js';
/**
 * Helper to safely merge static default options with dynamically loaded
 * JSON overrides from the SidecarConfig.
 *
 * Why the unsafe cast is acceptable here:
 * Before the \`config\` object ever reaches this function, \`SidecarLoader.ts\`
 * passes the raw JSON through \`SchemaValidator\`. The schema dynamically generates
 * a \`oneOf\` map linking every \`type\` discriminator to its corresponding processor
 * schema definition. By the time we access \`options\` here, its shape has been
 * strictly validated against the corresponding Zod/JSONSchema definition at runtime,
 * making the generic cast to \`<T>\` structurally safe.
 */
function resolveProcessorOptions(config, id, defaultOptions) {
    if (config?.processorOptions && config.processorOptions[id]) {
        return {
            ...defaultOptions,
            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
            ...config.processorOptions[id].options,
        };
    }
    return defaultOptions;
}
/**
 * The standard default context management profile.
 * Optimized for safety, precision, and reliable summarization.
 */
export const generalistProfile = {
    name: 'Generalist (Default)',
    sentinels: {
        continuation: '[Continuing from previous AI thoughts...]',
        lostToolResponse: 'The tool execution result was lost due to context management truncation.',
    },
    config: {
        budget: {
            retainedTokens: 65000,
            maxTokens: 150000,
            coalescingThresholdTokens: 5000,
        },
    },
    buildPipelines: (env, config) => 
    // Helper to merge default options with dynamically loaded processorOptions by ID
    [
        {
            name: 'Immediate Sanitization',
            triggers: ['new_message'],
            processors: [
                createToolMaskingProcessor('ToolMasking', env, resolveProcessorOptions(config, 'ToolMasking', {
                    stringLengthThresholdTokens: 8000,
                })),
                createBlobDegradationProcessor('BlobDegradation', env), // No options
                // Automatically distill extremely large blocks (e.g. huge source files pasted by the user)
                createNodeDistillationProcessor('ImmediateNodeDistillation', env, resolveProcessorOptions(config, 'ImmediateNodeDistillation', {
                    nodeThresholdTokens: 15000,
                })),
            ],
        },
        {
            name: 'Normalization',
            triggers: ['retained_exceeded'],
            processors: [
                createNodeDistillationProcessor('NodeDistillation', env, resolveProcessorOptions(config, 'NodeDistillation', {
                    nodeThresholdTokens: 3000,
                })),
                createNodeTruncationProcessor('NodeTruncation', env, resolveProcessorOptions(config, 'NodeTruncation', {
                    maxTokensPerNode: 4000,
                })),
            ],
        },
        {
            name: 'Emergency Backstop',
            triggers: ['gc_backstop'],
            processors: [
                createStateSnapshotProcessor('StateSnapshotSync', env, resolveProcessorOptions(config, 'StateSnapshotSync', {
                    target: 'max',
                    maxStateTokens: 4000,
                    maxSummaryTurns: 5,
                })),
            ],
        },
    ],
    buildAsyncPipelines: (env, config) => [
        {
            name: 'Async Background GC',
            triggers: ['nodes_aged_out'],
            processors: [
                createStateSnapshotAsyncProcessor('StateSnapshotAsync', env, resolveProcessorOptions(config, 'StateSnapshotAsync', {
                    type: 'accumulate',
                    maxStateTokens: 4000,
                    maxSummaryTurns: 5,
                })),
            ],
        },
    ],
};
/**
 * A highly aggressive profile designed exclusively for testing Context Management.
 * Lowers token limits dramatically to force garbage collection and distillation loops
 * within a few conversational turns.
 */
export const stressTestProfile = {
    name: 'Stress Test',
    config: {
        budget: {
            retainedTokens: 1500,
            maxTokens: 5000,
        },
        processorOptions: {
            ToolMasking: {
                type: 'ToolMaskingProcessor',
                options: {
                    stringLengthThresholdTokens: 500,
                },
            },
            NodeTruncation: {
                type: 'NodeTruncationProcessor',
                options: {
                    maxTokensPerNode: 1000,
                },
            },
            NodeDistillation: {
                type: 'NodeDistillationProcessor',
                options: {
                    nodeThresholdTokens: 1500,
                },
            },
        },
    },
    // Re-use the generalist pipeline architecture exactly, but the `config` above
    // will be passed into `resolveProcessorOptions` to aggressively override the thresholds.
    buildPipelines: generalistProfile.buildPipelines,
    buildAsyncPipelines: generalistProfile.buildAsyncPipelines,
};
/**
 * An experimental profile for power users testing maximum context endurance.
 * Uses a three-stage pipeline (retained -> normalized -> archived) and incremental GC.
 */
export const powerUserProfile = {
    name: 'Power User (Experimental)',
    sentinels: generalistProfile.sentinels,
    config: {
        budget: {
            retainedTokens: 65000,
            normalizedTokens: 100000,
            maxTokens: 150000,
            coalescingThresholdTokens: 5000,
        },
        gcStrategy: 'incremental',
    },
    buildPipelines: (env, config) => [
        {
            name: 'Immediate Sanitization',
            triggers: ['new_message'],
            processors: [
                createToolMaskingProcessor('ToolMasking', env, resolveProcessorOptions(config, 'ToolMasking', {
                    stringLengthThresholdTokens: 8000,
                })),
                createBlobDegradationProcessor('BlobDegradation', env),
                createNodeDistillationProcessor('ImmediateNodeDistillation', env, resolveProcessorOptions(config, 'ImmediateNodeDistillation', {
                    nodeThresholdTokens: 15000,
                })),
            ],
        },
        {
            name: 'Normalization',
            triggers: ['retained_exceeded'],
            processors: [
                createNodeDistillationProcessor('NodeDistillation', env, resolveProcessorOptions(config, 'NodeDistillation', {
                    nodeThresholdTokens: 3000,
                })),
                createNodeTruncationProcessor('NodeTruncation', env, resolveProcessorOptions(config, 'NodeTruncation', {
                    maxTokensPerNode: 4000,
                })),
            ],
        },
        {
            name: 'Archiving',
            triggers: ['normalized_exceeded'],
            processors: [
                createNodeDistillationProcessor('ArchiveNodeDistillation', env, resolveProcessorOptions(config, 'ArchiveNodeDistillation', {
                    nodeThresholdTokens: 1000,
                })),
                createNodeTruncationProcessor('ArchiveNodeTruncation', env, resolveProcessorOptions(config, 'ArchiveNodeTruncation', {
                    maxTokensPerNode: 1500,
                })),
            ],
        },
        {
            name: 'Emergency Backstop',
            triggers: ['gc_backstop'],
            processors: [
                createStateSnapshotProcessor('StateSnapshotSync', env, resolveProcessorOptions(config, 'StateSnapshotSync', {
                    target: 'max',
                    maxStateTokens: 2000,
                    maxSummaryTurns: 10,
                })),
                // If we STILL exceed max tokens, aggressively truncate
                createNodeTruncationProcessor('EmergencyNodeTruncation', env, resolveProcessorOptions(config, 'EmergencyNodeTruncation', {
                    maxTokensPerNode: 500,
                })),
            ],
        },
    ],
    buildAsyncPipelines: (env, config) => [
        {
            name: 'Async Background GC',
            triggers: ['nodes_aged_out'],
            processors: [
                createStateSnapshotAsyncProcessor('StateSnapshotAsync', env, resolveProcessorOptions(config, 'StateSnapshotAsync', {
                    type: 'accumulate',
                    maxStateTokens: 4000,
                    maxSummaryTurns: 5,
                })),
            ],
        },
    ],
};
//# sourceMappingURL=profiles.js.map