@jsonstudio/rcc 0.89.611 → 0.89.683

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/response-validate.js

@@ -1,76 +0,0 @@
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-export function validateResponsePayload(payload, _config) {
-    const errors = [];
-    if (!payload.id || typeof payload.id !== 'string') {
-        errors.push('响应缺少有效的id字段');
-    }
-    if (!payload.created || typeof payload.created !== 'number') {
-        errors.push('响应缺少有效的created字段');
-    }
-    if (!payload.model || typeof payload.model !== 'string') {
-        errors.push('响应缺少有效的model字段');
-    }
-    if (!Array.isArray(payload.choices) || payload.choices.length === 0) {
-        errors.push('choices数组不能为空');
-    }
-    else {
-        payload.choices.forEach((choice, idx) => {
-            if (!isRecord(choice)) {
-                errors.push(`choices[${idx}]必须是对象`);
-                return;
-            }
-            if (!choice.message || typeof choice.message !== 'object') {
-                errors.push(`choices[${idx}].message字段必须是对象`);
-            }
-            else if (Array.isArray(choice.message.tool_calls)) {
-                choice.message.tool_calls.forEach((toolCall, tIdx) => {
-                    if (!isRecord(toolCall)) {
-                        errors.push(`choices[${idx}].message.tool_calls[${tIdx}]必须是对象`);
-                        return;
-                    }
-                    if (!toolCall.function || typeof toolCall.function !== 'object') {
-                        errors.push(`choices[${idx}].message.tool_calls[${tIdx}].function字段必须是对象`);
-                        return;
-                    }
-                    const fn = toolCall.function;
-                    if (typeof fn.name !== 'string') {
-                        errors.push(`choices[${idx}].message.tool_calls[${tIdx}].function.name字段必须是字符串`);
-                    }
-                    if (typeof fn.arguments !== 'string') {
-                        errors.push(`choices[${idx}].message.tool_calls[${tIdx}].function.arguments字段必须是字符串`);
-                    }
-                    else {
-                        try {
-                            JSON.parse(fn.arguments);
-                        }
-                        catch {
-                            errors.push(`choices[${idx}].message.tool_calls[${tIdx}].function.arguments必须是有效JSON`);
-                        }
-                    }
-                });
-            }
-        });
-    }
-    if (payload.usage && typeof payload.usage === 'object') {
-        const usage = payload.usage;
-        const promptTokens = usage.prompt_tokens;
-        const completionTokens = usage.completion_tokens;
-        const totalTokens = usage.total_tokens;
-        if (!isNonNegativeNumber(promptTokens) ||
-            !isNonNegativeNumber(completionTokens) ||
-            !isNonNegativeNumber(totalTokens)) {
-            errors.push('usage字段的token必须是非负数');
-        }
-        else if (promptTokens + completionTokens !== totalTokens) {
-            errors.push('usage.total_tokens 应等于 prompt_tokens 与 completion_tokens 之和');
-        }
-    }
-    if (errors.length) {
-        const error = new Error(`GLM响应校验失败:\n${errors.join('\n')}`);
-        error.code = 'compat_response_validation_failed';
-        throw error;
-    }
-}
-function isNonNegativeNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
-}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/snapshot.d.ts

@@ -1,8 +0,0 @@
-type Phase = 'compat-pre' | 'compat-post';
-export declare function writeCompatSnapshot(options: {
-    phase: Phase;
-    requestId?: string;
-    entryEndpoint?: string;
-    data: unknown;
-}): Promise<void>;
-export {};

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/snapshot.js

@@ -1,21 +0,0 @@
-import { writeSnapshotViaHooks } from '../../shared/snapshot-hooks.js';
-const SNAPSHOT_FLAG = String(process.env.ROUTECODEX_SNAPSHOT ?? '').toLowerCase();
-const SNAPSHOT_ENABLED = SNAPSHOT_FLAG === '1' || SNAPSHOT_FLAG === 'true';
-export async function writeCompatSnapshot(options) {
-    if (!SNAPSHOT_ENABLED) {
-        return;
-    }
-    try {
-        const endpoint = options.entryEndpoint || '/v1/chat/completions';
-        await writeSnapshotViaHooks({
-            endpoint,
-            stage: options.phase,
-            requestId: options.requestId || 'unknown',
-            data: options.data,
-            verbosity: 'verbose'
-        });
-    }
-    catch {
-        // snapshots are best-effort
-    }
-}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/tool-schema.d.ts

@@ -1,6 +0,0 @@
-import type { JsonObject } from '../../hub/types/json.js';
-type UnknownRecord = Record<string, unknown>;
-export declare const sanitizeGLMToolsSchema: (data: UnknownRecord) => UnknownRecord;
-export declare const sanitizeGLMToolsSchemaInPlace: (data: UnknownRecord) => void;
-export declare function sanitizeToolSchema(payload: JsonObject, mode?: 'glm_shell'): JsonObject;
-export {};

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/tool-schema.js

@@ -1,91 +0,0 @@
-const SHELL_COMMAND_DESCRIPTION = 'Shell command argv tokens. Use ["bash","-lc","<cmd>"] form.';
-const isRecord = (value) => typeof value === 'object' && value !== null;
-const ensureStringArray = (value) => {
-    if (Array.isArray(value) && value.every(item => typeof item === 'string')) {
-        return [...value];
-    }
-    return [];
-};
-const sanitizeShellCommandProperty = (properties) => {
-    const candidate = properties.command;
-    if (isRecord(candidate)) {
-        const command = { ...candidate };
-        delete command.oneOf;
-        command.type = 'array';
-        command.items = { type: 'string' };
-        if (typeof command.description !== 'string' || command.description.length === 0) {
-            command.description = SHELL_COMMAND_DESCRIPTION;
-        }
-        properties.command = command;
-        return;
-    }
-    properties.command = {
-        description: SHELL_COMMAND_DESCRIPTION,
-        type: 'array',
-        items: { type: 'string' }
-    };
-};
-const sanitizeToolFunction = (toolFn, isShell) => {
-    const fn = { ...toolFn };
-    if ('strict' in fn) {
-        delete fn.strict;
-    }
-    if (!fn.parameters || !isRecord(fn.parameters)) {
-        return fn;
-    }
-    const params = { ...fn.parameters };
-    if (isShell) {
-        if (params.properties && isRecord(params.properties)) {
-            params.properties = { ...params.properties };
-        }
-        else {
-            params.properties = {};
-        }
-        sanitizeShellCommandProperty(params.properties);
-        const required = ensureStringArray(params.required);
-        if (!required.includes('command')) {
-            required.push('command');
-        }
-        params.required = required;
-        params.type = typeof params.type === 'string' ? params.type : 'object';
-        params.additionalProperties = typeof params.additionalProperties === 'boolean'
-            ? params.additionalProperties
-            : false;
-    }
-    fn.parameters = params;
-    return fn;
-};
-const sanitizeToolDefinition = (tool) => {
-    const sanitized = { ...tool };
-    if (!sanitized.function || !isRecord(sanitized.function)) {
-        return sanitized;
-    }
-    const fn = sanitizeToolFunction(sanitized.function, sanitized.function.name === 'shell');
-    sanitized.function = fn;
-    return sanitized;
-};
-export const sanitizeGLMToolsSchema = (data) => {
-    const toolsValue = data.tools;
-    if (!Array.isArray(toolsValue)) {
-        return data;
-    }
-    const sanitizedTools = toolsValue.map(tool => (isRecord(tool) ? sanitizeToolDefinition(tool) : tool));
-    return {
-        ...data,
-        tools: sanitizedTools
-    };
-};
-export const sanitizeGLMToolsSchemaInPlace = (data) => {
-    const toolsValue = data.tools;
-    if (!Array.isArray(toolsValue)) {
-        return;
-    }
-    const sanitized = sanitizeGLMToolsSchema(data);
-    data.tools = sanitized.tools;
-};
-export function sanitizeToolSchema(payload, mode = 'glm_shell') {
-    if (mode === 'glm_shell') {
-        return sanitizeGLMToolsSchema(payload);
-    }
-    return payload;
-}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/universal-shape-filter.d.ts

@@ -1,74 +0,0 @@
-import type { AdapterContext } from '../../hub/types/chat-envelope.js';
-import type { JsonObject } from '../../hub/types/json.js';
-type RequestMessagesRule = {
-    when?: {
-        role?: 'system' | 'user' | 'assistant' | 'tool';
-        hasToolCalls?: boolean;
-    };
-    action: 'drop' | 'keep' | 'set';
-    set?: Record<string, unknown>;
-};
-export interface FilterConfig {
-    request: {
-        allowTopLevel: string[];
-        messages: {
-            allowedRoles: string[];
-            assistantWithToolCallsContentNull?: boolean;
-            toolContentStringify?: boolean;
-            suppressAssistantToolCalls?: boolean;
-        };
-        tools?: {
-            normalize?: boolean;
-            forceToolChoiceAuto?: boolean;
-        };
-        assistantToolCalls?: {
-            functionArgumentsType?: 'object' | 'string';
-        };
-        messagesRules?: RequestMessagesRule[];
-    };
-    response: {
-        allowTopLevel: string[];
-        choices: {
-            required?: boolean;
-            message: {
-                allow: string[];
-                roleDefault?: string;
-                contentNullWhenToolCalls?: boolean;
-                tool_calls?: {
-                    function?: {
-                        nameRequired?: boolean;
-                        argumentsType?: 'object' | 'string';
-                    };
-                };
-            };
-            finish_reason?: string[];
-        };
-        usage?: {
-            allow: string[];
-        };
-    };
-}
-export declare class UniversalShapeFilter {
-    private readonly cfg;
-    constructor(config: FilterConfig);
-    applyRequestFilter(payload: JsonObject): JsonObject;
-    applyResponseFilter(payload: JsonObject, ctx?: AdapterContext): JsonObject;
-    private shallowPick;
-    private toObjectArgs;
-    private toStringArgs;
-    private normalizeToolContent;
-    private normalizeRequestMessages;
-    private normalizeSingleMessage;
-    private normalizeAssistantToolCalls;
-    private applyMessageRules;
-    private pairToolResults;
-    private normalizeTools;
-    private normalizeSingleTool;
-    private normalizeToolParameters;
-    private enforceShellSchema;
-    private cleanupToolChoice;
-    private normalizeResponseChoice;
-    private normalizeResponseMessage;
-    private normalizeResponseToolCalls;
-}
-export {};

package/node_modules/@jsonstudio/llms/dist/conversion/compat/actions/universal-shape-filter.js

@@ -1,393 +0,0 @@
-const DEFAULT_TOOL_OUTPUT = 'Command succeeded (no output).';
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function toRecord(value) {
-    return isRecord(value) ? value : {};
-}
-function toArray(value) {
-    return Array.isArray(value) ? value : [];
-}
-function hasArrayItems(value) {
-    return Array.isArray(value) && value.length > 0;
-}
-export class UniversalShapeFilter {
-    cfg;
-    constructor(config) {
-        this.cfg = config;
-    }
-    applyRequestFilter(payload) {
-        const cfg = this.cfg;
-        const allow = new Set(cfg.request.allowTopLevel);
-        const src = toRecord(payload);
-        const out = {};
-        for (const key of Object.keys(src)) {
-            if (allow.has(key)) {
-                out[key] = src[key];
-            }
-        }
-        const normalizedMessages = this.normalizeRequestMessages(out.messages, cfg.request);
-        out.messages = normalizedMessages;
-        this.normalizeTools(out, cfg.request);
-        this.cleanupToolChoice(out);
-        return out;
-    }
-    applyResponseFilter(payload, ctx) {
-        const envFlag = String(process.env.RCC_COMPAT_FILTER_OFF_RESPONSES || '1').toLowerCase();
-        const envBypass = !(envFlag === '0' || envFlag === 'false' || envFlag === 'off');
-        const entryEndpoint = ctx?.entryEndpoint ?? ctx?.endpoint;
-        const entry = typeof entryEndpoint === 'string' ? entryEndpoint.toLowerCase() : '';
-        if (entry === '/v1/responses' || envBypass) {
-            return payload;
-        }
-        const cfg = this.cfg;
-        const src = toRecord(payload);
-        const out = this.shallowPick(src, cfg.response.allowTopLevel);
-        const choices = Array.isArray(src.choices) ? src.choices : [];
-        out.choices = choices.map((choice, idx) => this.normalizeResponseChoice(choice, idx, cfg.response));
-        if (src.usage && typeof src.usage === 'object') {
-            out.usage = this.shallowPick(src.usage, cfg.response.usage?.allow || []);
-        }
-        return out;
-    }
-    shallowPick(obj, allow) {
-        if (!isRecord(obj)) {
-            return {};
-        }
-        const out = {};
-        for (const key of allow) {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                out[key] = obj[key];
-            }
-        }
-        return out;
-    }
-    toObjectArgs(value) {
-        if (value === null || value === undefined) {
-            return {};
-        }
-        if (isRecord(value)) {
-            return value;
-        }
-        if (typeof value === 'string') {
-            try {
-                return JSON.parse(value);
-            }
-            catch {
-                return { raw: value };
-            }
-        }
-        return {};
-    }
-    toStringArgs(value) {
-        if (typeof value === 'string') {
-            return value;
-        }
-        try {
-            return JSON.stringify(value ?? {});
-        }
-        catch {
-            return '{}';
-        }
-    }
-    normalizeToolContent(value) {
-        if (typeof value === 'string') {
-            return value.trim().length ? value : DEFAULT_TOOL_OUTPUT;
-        }
-        if (value === null || value === undefined) {
-            return DEFAULT_TOOL_OUTPUT;
-        }
-        try {
-            const text = JSON.stringify(value);
-            return text && text.length ? text : DEFAULT_TOOL_OUTPUT;
-        }
-        catch {
-            return DEFAULT_TOOL_OUTPUT;
-        }
-    }
-    normalizeRequestMessages(messages, requestCfg) {
-        const entries = toArray(messages);
-        const normalized = entries.map(entry => this.normalizeSingleMessage(entry, requestCfg));
-        const withRules = this.applyMessageRules(normalized, requestCfg);
-        this.pairToolResults(withRules);
-        return withRules;
-    }
-    normalizeSingleMessage(message, requestCfg) {
-        const msg = toRecord(message);
-        const allowedRoles = requestCfg.messages.allowedRoles;
-        const requestedRole = typeof msg.role === 'string' ? msg.role : undefined;
-        const role = (requestedRole && allowedRoles.includes(requestedRole)) ? requestedRole : 'user';
-        const normalized = { role };
-        if (role === 'tool') {
-            normalized.content = this.normalizeToolContent(msg.content);
-            if (typeof msg.name === 'string') {
-                normalized.name = msg.name;
-            }
-            if (typeof msg.tool_call_id === 'string') {
-                normalized.tool_call_id = msg.tool_call_id;
-            }
-        }
-        else if (Array.isArray(msg.content)) {
-            normalized.content = msg.content.map((part) => {
-                if (typeof part === 'string') {
-                    return part;
-                }
-                if (isRecord(part)) {
-                    return { ...part };
-                }
-                return part;
-            });
-        }
-        else {
-            normalized.content = (msg.content !== null && msg.content !== undefined) ? String(msg.content) : '';
-        }
-        if (role === 'assistant' && hasArrayItems(msg.tool_calls)) {
-            normalized.tool_calls = this.normalizeAssistantToolCalls(msg.tool_calls, requestCfg);
-            if (requestCfg.messages.assistantWithToolCallsContentNull) {
-                normalized.content = null;
-            }
-        }
-        return normalized;
-    }
-    normalizeAssistantToolCalls(toolCalls, requestCfg) {
-        const entries = toArray(toolCalls);
-        return entries.map(call => {
-            const tc = toRecord(call);
-            const fn = toRecord(tc.function);
-            const name = typeof fn.name === 'string' ? fn.name : undefined;
-            const argsValue = requestCfg.assistantToolCalls?.functionArgumentsType === 'string'
-                ? this.toStringArgs(fn.arguments)
-                : this.toObjectArgs(fn.arguments);
-            const normalized = {
-                type: typeof tc.type === 'string' ? tc.type : 'function',
-                function: { ...(name ? { name } : {}), arguments: argsValue }
-            };
-            if (typeof tc.id === 'string') {
-                normalized.id = tc.id;
-            }
-            return normalized;
-        });
-    }
-    applyMessageRules(messages, requestCfg) {
-        const rules = Array.isArray(requestCfg.messagesRules) ? requestCfg.messagesRules : [];
-        if (!rules.length) {
-            if (requestCfg.messages.suppressAssistantToolCalls) {
-                return messages.filter(msg => !(msg.role === 'assistant' && hasArrayItems(msg.tool_calls)));
-            }
-            return messages;
-        }
-        const result = [];
-        for (const message of messages) {
-            let dropped = false;
-            for (const rule of rules) {
-                const when = rule.when || {};
-                const matchRole = when.role ? message.role === when.role : true;
-                const hasTools = hasArrayItems(message.tool_calls);
-                const matchTools = typeof when.hasToolCalls === 'boolean' ? hasTools === when.hasToolCalls : true;
-                if (matchRole && matchTools) {
-                    if (rule.action === 'drop') {
-                        dropped = true;
-                        break;
-                    }
-                    if (rule.action === 'set' && rule.set && typeof rule.set === 'object') {
-                        Object.assign(message, rule.set);
-                    }
-                }
-            }
-            if (!dropped) {
-                result.push(message);
-            }
-        }
-        return result;
-    }
-    pairToolResults(messages) {
-        const nameById = new Map();
-        for (const message of messages) {
-            if (message.role === 'assistant' && hasArrayItems(message.tool_calls)) {
-                for (const call of message.tool_calls) {
-                    const toolCall = toRecord(call);
-                    if (typeof toolCall.id !== 'string') {
-                        continue;
-                    }
-                    const fn = toRecord(toolCall.function);
-                    if (typeof fn.name === 'string') {
-                        nameById.set(toolCall.id, fn.name);
-                    }
-                }
-            }
-        }
-        for (const message of messages) {
-            if (message.role !== 'tool') {
-                continue;
-            }
-            const name = typeof message.name === 'string' ? message.name.trim() : '';
-            if (name) {
-                continue;
-            }
-            const toolCallId = typeof message.tool_call_id === 'string' ? message.tool_call_id : undefined;
-            if (toolCallId && nameById.has(toolCallId)) {
-                message.name = nameById.get(toolCallId);
-            }
-        }
-    }
-    normalizeTools(container, requestCfg) {
-        if (!Array.isArray(container.tools)) {
-            return;
-        }
-        if (!requestCfg.tools?.normalize) {
-            if (requestCfg.tools?.forceToolChoiceAuto) {
-                container.tool_choice = 'auto';
-            }
-            return;
-        }
-        const normalized = [];
-        for (const toolEntry of container.tools) {
-            const normalizedTool = this.normalizeSingleTool(toolEntry);
-            normalized.push(normalizedTool);
-        }
-        container.tools = normalized;
-        if (requestCfg.tools?.forceToolChoiceAuto) {
-            container.tool_choice = 'auto';
-        }
-    }
-    normalizeSingleTool(toolEntry) {
-        const tool = toRecord(toolEntry);
-        const fnTop = {
-            name: typeof tool.name === 'string' ? tool.name : undefined,
-            description: typeof tool.description === 'string' ? tool.description : undefined,
-            parameters: tool.parameters
-        };
-        const fn = toRecord(tool.function);
-        const name = typeof fn.name === 'string' ? fn.name : fnTop.name;
-        const description = typeof fn.description === 'string' ? fn.description : fnTop.description;
-        let parameters = fn.parameters !== undefined ? fn.parameters : fnTop.parameters;
-        parameters = this.normalizeToolParameters(parameters, name);
-        const normalizedFn = {
-            ...(name ? { name } : {}),
-            ...(description ? { description } : {})
-        };
-        if (parameters !== undefined) {
-            normalizedFn.parameters = parameters;
-        }
-        return {
-            type: 'function',
-            function: normalizedFn
-        };
-    }
-    normalizeToolParameters(input, name) {
-        if (input === null || input === undefined) {
-            return undefined;
-        }
-        let params;
-        if (typeof input === 'string') {
-            try {
-                params = JSON.parse(input);
-            }
-            catch {
-                params = undefined;
-            }
-        }
-        else if (isRecord(input)) {
-            params = input;
-        }
-        if (!params) {
-            return undefined;
-        }
-        if (name && name.trim().toLowerCase() === 'shell') {
-            return this.enforceShellSchema(params);
-        }
-        return params;
-    }
-    enforceShellSchema(schema) {
-        const next = { ...schema };
-        if (typeof next.type !== 'string') {
-            next.type = 'object';
-        }
-        if (!isRecord(next.properties)) {
-            next.properties = {};
-        }
-        const props = next.properties;
-        const command = toRecord(props.command);
-        const hasOneOf = Array.isArray(command.oneOf);
-        if (!hasOneOf) {
-            const descText = typeof command.description === 'string'
-                ? command.description
-                : 'Shell command. Prefer a single string; an array of argv tokens is also accepted.';
-            props.command = {
-                description: descText,
-                oneOf: [
-                    { type: 'string' },
-                    { type: 'array', items: { type: 'string' } }
-                ]
-            };
-            const requiredList = Array.isArray(next.required)
-                ? next.required.filter((item) => typeof item === 'string')
-                : [];
-            if (!requiredList.includes('command')) {
-                requiredList.push('command');
-            }
-            next.required = requiredList;
-            if (typeof next.additionalProperties !== 'boolean') {
-                next.additionalProperties = false;
-            }
-        }
-        return next;
-    }
-    cleanupToolChoice(container) {
-        const toolsArray = Array.isArray(container.tools) ? container.tools : [];
-        if (!toolsArray.length && Object.prototype.hasOwnProperty.call(container, 'tool_choice')) {
-            delete container.tool_choice;
-        }
-    }
-    normalizeResponseChoice(choice, idx, responseCfg) {
-        const choiceRecord = toRecord(choice);
-        const normalized = {
-            index: typeof choiceRecord.index === 'number' ? choiceRecord.index : idx
-        };
-        const message = toRecord(choiceRecord.message);
-        normalized.message = this.normalizeResponseMessage(message, responseCfg);
-        const hasToolCalls = hasArrayItems(normalized.message.tool_calls);
-        normalized.finish_reason = choiceRecord.finish_reason ?? (hasToolCalls ? 'tool_calls' : null);
-        return normalized;
-    }
-    normalizeResponseMessage(message, responseCfg) {
-        const normalized = {};
-        normalized.role = typeof message.role === 'string'
-            ? message.role
-            : (responseCfg.choices.message.roleDefault || 'assistant');
-        if (hasArrayItems(message.tool_calls)) {
-            normalized.tool_calls = this.normalizeResponseToolCalls(message.tool_calls, responseCfg);
-            normalized.content = responseCfg.choices.message.contentNullWhenToolCalls ? null : message.content ?? '';
-        }
-        else {
-            normalized.content = message.content ?? '';
-        }
-        if (typeof message.reasoning_content === 'string') {
-            normalized.reasoning_content = message.reasoning_content;
-        }
-        if (message.audio) {
-            normalized.audio = message.audio;
-        }
-        return normalized;
-    }
-    normalizeResponseToolCalls(toolCalls, responseCfg) {
-        const entries = toArray(toolCalls);
-        return entries.map(call => {
-            const tc = toRecord(call);
-            const fn = toRecord(tc.function);
-            const name = typeof fn.name === 'string' ? fn.name : undefined;
-            const argsObject = this.toObjectArgs(fn.arguments);
-            const argsValue = responseCfg.choices.message.tool_calls?.function?.argumentsType === 'string'
-                ? this.toStringArgs(argsObject)
-                : argsObject;
-            const normalized = {
-                type: typeof tc.type === 'string' ? tc.type : 'function',
-                function: { ...(name ? { name } : {}), arguments: argsValue }
-            };
-            if (typeof tc.id === 'string') {
-                normalized.id = tc.id;
-            }
-            return normalized;
-        });
-    }
-}

package/node_modules/@jsonstudio/llms/dist/conversion/compat/profiles/chat-gemini.json

@@ -1,16 +0,0 @@
-{
-    "id": "chat:gemini",
-    "protocol": "gemini-chat",
-    "request": {
-        "mappings": [
-            { "action": "snapshot", "phase": "compat-pre" },
-            {
-                "action": "gemini_web_search_request"
-            },
-            { "action": "snapshot", "phase": "compat-post" }
-        ]
-    },
-    "response": {
-        "mappings": []
-    }
-}