/**

* @license

* Copyright 2025 Google LLC

* SPDX-License-Identifier: Apache-2.0

*/

import {

type Config,

type GeminiChat,

type ToolResult,

type ToolCallConfirmationDetails,

type FilterFilesOptions,

type ConversationRecord,

CoreToolCallStatus,

AuthType,

logToolCall,

convertToFunctionResponse,

ToolConfirmationOutcome,

clearCachedCredentialFile,

isNodeError,

getErrorMessage,

isWithinRoot,

getErrorStatus,

MCPServerConfig,

DiscoveredMCPTool,

StreamEventType,

ToolCallEvent,

debugLogger,

ReadManyFilesTool,

REFERENCE_CONTENT_START,

type RoutingContext,

createWorkingStdio,

startupProfiler,

Kind,

partListUnionToString,

LlmRole,

ApprovalMode,

getVersion,

convertSessionToClientHistory,

DEFAULT_GEMINI_MODEL,

DEFAULT_GEMINI_FLASH_MODEL,

DEFAULT_GEMINI_FLASH_LITE_MODEL,

PREVIEW_GEMINI_MODEL,

PREVIEW_GEMINI_3_1_MODEL,

PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL,

PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL,

PREVIEW_GEMINI_FLASH_MODEL,

DEFAULT_GEMINI_MODEL_AUTO,

PREVIEW_GEMINI_MODEL_AUTO,

getDisplayString,

processSingleFileContent,

InvalidStreamError,

type AgentLoopContext,

updatePolicy,

} from '@google/gemini-cli-core';

import * as acp from '@agentclientprotocol/sdk';

import { AcpFileSystemService } from './fileSystemService.js';

import { getAcpErrorMessage } from './acpErrors.js';

import { Readable, Writable } from 'node:stream';

function hasMeta(obj: unknown): obj is { _meta?: Record<string, unknown> } {

return typeof obj === 'object' && obj !== null && '_meta' in obj;

}

import type { Content, Part, FunctionCall } from '@google/genai';

import {

SettingScope,

loadSettings,

type LoadedSettings,

} from '../config/settings.js';

import { createPolicyUpdater } from '../config/policy.js';

import * as fs from 'node:fs/promises';

import * as path from 'node:path';

import { z } from 'zod';

import { randomUUID } from 'node:crypto';

import { loadCliConfig, type CliArgs } from '../config/config.js';

import { runExitCleanup } from '../utils/cleanup.js';

import { SessionSelector } from '../utils/sessionUtils.js';

import { CommandHandler } from './commandHandler.js';

const RequestPermissionResponseSchema = z.object({

outcome: z.discriminatedUnion('outcome', [

z.object({ outcome: z.literal('cancelled') }),

z.object({

outcome: z.literal('selected'),

optionId: z.string(),

}),

]),

});

export async function runAcpClient(

config: Config,

settings: LoadedSettings,

argv: CliArgs,

) {

// ... (skip unchanged lines) ...

const { stdout: workingStdout } = createWorkingStdio();

const stdout = Writable.toWeb(workingStdout) as WritableStream;

// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion

const stdin = Readable.toWeb(process.stdin) as ReadableStream<Uint8Array>;

const stream = acp.ndJsonStream(stdout, stdin);

const connection = new acp.AgentSideConnection(

(connection) => new GeminiAgent(config, settings, argv, connection),

stream,

);

// SIGTERM/SIGINT handlers (in sdk.ts) don't fire when stdin closes.

// We must explicitly await the connection close to flush telemetry.

// Use finally() to ensure cleanup runs even on stream errors.

await connection.closed.finally(runExitCleanup);

}

export class GeminiAgent {

private static callIdCounter = 0;

static generateCallId(name: string): string {

return `${name}-${Date.now()}-${++GeminiAgent.callIdCounter}`;

}

private sessions: Map<string, Session> = new Map();

private clientCapabilities: acp.ClientCapabilities | undefined;

private apiKey: string | undefined;

private baseUrl: string | undefined;

private customHeaders: Record<string, string> | undefined;

constructor(

private context: AgentLoopContext,

private settings: LoadedSettings,

private argv: CliArgs,

private connection: acp.AgentSideConnection,

) {}

async initialize(

args: acp.InitializeRequest,

): Promise<acp.InitializeResponse> {

this.clientCapabilities = args.clientCapabilities;

const authMethods = [

{

id: AuthType.LOGIN_WITH_GOOGLE,

name: 'Log in with Google',

description: 'Log in with your Google account',

},

{

id: AuthType.USE_GEMINI,

name: 'Gemini API key',

description: 'Use an API key with Gemini Developer API',

_meta: {

'api-key': {

provider: 'google',

},

},

},

{

id: AuthType.USE_VERTEX_AI,

name: 'Vertex AI',

description: 'Use an API key with Vertex AI GenAI API',

},

{

id: AuthType.GATEWAY,

name: 'AI API Gateway',

description: 'Use a custom AI API Gateway',

_meta: {

gateway: {

protocol: 'google',

restartRequired: 'false',

},

},

},

];

await this.context.config.initialize();

const version = await getVersion();

return {

protocolVersion: acp.PROTOCOL_VERSION,

authMethods,

agentInfo: {

name: 'gemini-cli',

title: 'Gemini CLI',

version,

},

agentCapabilities: {

loadSession: true,

promptCapabilities: {

image: true,

audio: true,

embeddedContext: true,

},

mcpCapabilities: {

http: true,

sse: true,

},

},

};

}

async authenticate(req: acp.AuthenticateRequest): Promise<void> {

const { methodId } = req;

const method = z.nativeEnum(AuthType).parse(methodId);

const selectedAuthType = this.settings.merged.security.auth.selectedType;

// Only clear credentials when switching to a different auth method

if (selectedAuthType && selectedAuthType !== method) {

await clearCachedCredentialFile();

}

// Check for api-key in _meta

const meta = hasMeta(req) ? req._meta : undefined;

const apiKey =

typeof meta?.['api-key'] === 'string' ? meta['api-key'] : undefined;

// Refresh auth with the requested method

// This will reuse existing credentials if they're valid,

// or perform new authentication if needed

try {

if (apiKey) {

this.apiKey = apiKey;

}

// Extract gateway details if present

const gatewaySchema = z.object({

baseUrl: z.string().optional(),

headers: z.record(z.string()).optional(),

});

let baseUrl: string | undefined;

let headers: Record<string, string> | undefined;

if (meta?.['gateway']) {

const result = gatewaySchema.safeParse(meta['gateway']);

if (result.success) {

baseUrl = result.data.baseUrl;

headers = result.data.headers;

} else {

throw new acp.RequestError(

-32602,

`Malformed gateway payload: ${result.error.message}`,

);

}

}

this.baseUrl = baseUrl;

this.customHeaders = headers;

await this.context.config.refreshAuth(

method,

apiKey ?? this.apiKey,

baseUrl,

headers,

);

} catch (e) {

throw new acp.RequestError(-32000, getAcpErrorMessage(e));

}

this.settings.setValue(

SettingScope.User,

'security.auth.selectedType',

method,

);

}

async newSession({

cwd,

mcpServers,

}: acp.NewSessionRequest): Promise<acp.NewSessionResponse> {

const sessionId = randomUUID();

const loadedSettings = loadSettings(cwd);

const config = await this.newSessionConfig(

sessionId,

cwd,

mcpServers,

loadedSettings,

);

const authType =

loadedSettings.merged.security.auth.selectedType || AuthType.USE_GEMINI;

let isAuthenticated = false;

let authErrorMessage = '';

try {

await config.refreshAuth(

authType,

this.apiKey,

this.baseUrl,

this.customHeaders,

);

isAuthenticated = true;

// Extra validation for Gemini API key

const contentGeneratorConfig = config.getContentGeneratorConfig();

if (

authType === AuthType.USE_GEMINI &&

(!contentGeneratorConfig || !contentGeneratorConfig.apiKey)

) {

isAuthenticated = false;

authErrorMessage = 'Gemini API key is missing or not configured.';

}

} catch (e) {

isAuthenticated = false;

authErrorMessage = getAcpErrorMessage(e);

debugLogger.error(

`Authentication failed: ${e instanceof Error ? e.stack : e}`,

);

}

if (!isAuthenticated) {

throw new acp.RequestError(

-32000,

authErrorMessage || 'Authentication required.',

);

}

if (this.clientCapabilities?.fs) {

const acpFileSystemService = new AcpFileSystemService(

this.connection,

sessionId,

this.clientCapabilities.fs,

config.getFileSystemService(),

cwd,

);

config.setFileSystemService(acpFileSystemService);

}

await config.initialize();

startupProfiler.flush(config);

const geminiClient = config.getGeminiClient();

const chat = await geminiClient.startChat();

const session = new Session(

sessionId,

chat,

config,

this.connection,

this.settings,

);

this.sessions.set(sessionId, session);

setTimeout(() => {

// eslint-disable-next-line @typescript-eslint/no-floating-promises

session.sendAvailableCommands();

}, 0);

const { availableModels, currentModelId } = buildAvailableModels(

config,

loadedSettings,

);

const response = {

sessionId,

modes: {

availableModes: buildAvailableModes(config.isPlanEnabled()),

currentModeId: config.getApprovalMode(),

},

models: {

availableModels,

currentModelId,

},

};

return response;

}

async loadSession({

sessionId,

cwd,

mcpServers,

}: acp.LoadSessionRequest): Promise<acp.LoadSessionResponse> {

const config = await this.initializeSessionConfig(

sessionId,

cwd,

mcpServers,

);

const sessionSelector = new SessionSelector(config.storage);

const { sessionData, sessionPath } =

await sessionSelector.resolveSession(sessionId);

const clientHistory = convertSessionToClientHistory(sessionData.messages);

const geminiClient = config.getGeminiClient();

await geminiClient.initialize();

await geminiClient.resumeChat(clientHistory, {

conversation: sessionData,

filePath: sessionPath,

});

const session = new Session(

sessionId,

geminiClient.getChat(),

config,

this.connection,

this.settings,

);

this.sessions.set(sessionId, session);

// Stream history back to client

// eslint-disable-next-line @typescript-eslint/no-floating-promises

session.streamHistory(sessionData.messages);

setTimeout(() => {

// eslint-disable-next-line @typescript-eslint/no-floating-promises

session.sendAvailableCommands();

}, 0);

const { availableModels, currentModelId } = buildAvailableModels(

config,

this.settings,

);

const response = {

modes: {

availableModes: buildAvailableModes(config.isPlanEnabled()),

currentModeId: config.getApprovalMode(),

},

models: {

availableModels,

currentModelId,

},

};

return response;

}

private async initializeSessionConfig(

sessionId: string,

cwd: string,

mcpServers: acp.McpServer[],

): Promise<Config> {

const selectedAuthType = this.settings.merged.security.auth.selectedType;

if (!selectedAuthType) {

throw acp.RequestError.authRequired();

}

// 1. Create config WITHOUT initializing it (no MCP servers started yet)

const config = await this.newSessionConfig(sessionId, cwd, mcpServers);

// 2. Authenticate BEFORE initializing configuration or starting MCP servers.

// This satisfies the security requirement to verify the user before executing

// potentially unsafe server definitions.

try {

await config.refreshAuth(

selectedAuthType,

this.apiKey,

this.baseUrl,

this.customHeaders,

);

} catch (e) {

debugLogger.error(`Authentication failed: ${e}`);

throw acp.RequestError.authRequired();

}

// 3. Set the ACP FileSystemService (if supported) before config initialization

if (this.clientCapabilities?.fs) {

const acpFileSystemService = new AcpFileSystemService(

this.connection,

sessionId,

this.clientCapabilities.fs,

config.getFileSystemService(),

cwd,

);

config.setFileSystemService(acpFileSystemService);

}

// 4. Now that we are authenticated, it is safe to initialize the config

// which starts the MCP servers and other heavy resources.

await config.initialize();

startupProfiler.flush(config);

return config;

}

async newSessionConfig(

sessionId: string,

cwd: string,

mcpServers: acp.McpServer[],

loadedSettings?: LoadedSettings,

): Promise<Config> {

const currentSettings = loadedSettings || this.settings;

const mergedMcpServers = { ...currentSettings.merged.mcpServers };

for (const server of mcpServers) {

if (

'type' in server &&

(server.type === 'sse' || server.type === 'http')

) {

// HTTP or SSE MCP server

const headers = Object.fromEntries(

server.headers.map(({ name, value }) => [name, value]),

);

mergedMcpServers[server.name] = new MCPServerConfig(

undefined, // command

undefined, // args

undefined, // env

undefined, // cwd

server.type === 'sse' ? server.url : undefined, // url (sse)

server.type === 'http' ? server.url : undefined, // httpUrl

headers,

);

} else if ('command' in server) {

// Stdio MCP server

const env: Record<string, string> = {};

for (const { name: envName, value } of server.env) {

env[envName] = value;

}

mergedMcpServers[server.name] = new MCPServerConfig(

server.command,

server.args,

env,

cwd,

);

}

}

const settings = {

...currentSettings.merged,

mcpServers: mergedMcpServers,

};

const config = await loadCliConfig(settings, sessionId, this.argv, { cwd });

createPolicyUpdater(

config.getPolicyEngine(),

config.messageBus,

config.storage,

);

return config;

}

async cancel(params: acp.CancelNotification): Promise<void> {

const session = this.sessions.get(params.sessionId);

if (!session) {

throw new Error(`Session not found: ${params.sessionId}`);

}

await session.cancelPendingPrompt();

}

async prompt(params: acp.PromptRequest): Promise<acp.PromptResponse> {

const session = this.sessions.get(params.sessionId);

if (!session) {

throw new Error(`Session not found: ${params.sessionId}`);

}

return session.prompt(params);

}

async setSessionMode(

params: acp.SetSessionModeRequest,

): Promise<acp.SetSessionModeResponse> {

const session = this.sessions.get(params.sessionId);

if (!session) {

throw new Error(`Session not found: ${params.sessionId}`);

}

return session.setMode(params.modeId);

}

async unstable_setSessionModel(

params: acp.SetSessionModelRequest,

): Promise<acp.SetSessionModelResponse> {

const session = this.sessions.get(params.sessionId);

if (!session) {

throw new Error(`Session not found: ${params.sessionId}`);

}

return session.setModel(params.modelId);

}

}

export class Session {

private pendingPrompt: AbortController | null = null;

private commandHandler = new CommandHandler();

constructor(

private readonly id: string,

private readonly chat: GeminiChat,

private readonly context: AgentLoopContext,

private readonly connection: acp.AgentSideConnection,

private readonly settings: LoadedSettings,

) {}

async cancelPendingPrompt(): Promise<void> {

if (!this.pendingPrompt) {

throw new Error('Not currently generating');

}

this.pendingPrompt.abort();

this.pendingPrompt = null;

}

setMode(modeId: acp.SessionModeId): acp.SetSessionModeResponse {

const availableModes = buildAvailableModes(

this.context.config.isPlanEnabled(),

);

const mode = availableModes.find((m) => m.id === modeId);

if (!mode) {

throw new Error(`Invalid or unavailable mode: ${modeId}`);

}

// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion

this.context.config.setApprovalMode(mode.id as ApprovalMode);

return {};

}

private getAvailableCommands() {

return this.commandHandler.getAvailableCommands();

}

async sendAvailableCommands(): Promise<void> {

const availableCommands = this.getAvailableCommands().map((command) => ({

name: command.name,

description: command.description,

}));

await this.sendUpdate({

sessionUpdate: 'available_commands_update',

availableCommands,

});

}

setModel(modelId: acp.ModelId): acp.SetSessionModelResponse {

this.context.config.setModel(modelId);

return {};

}

async streamHistory(messages: ConversationRecord['messages']): Promise<void> {

for (const msg of messages) {

const contentString = partListUnionToString(msg.content);

if (msg.type === 'user') {

if (contentString.trim()) {

await this.sendUpdate({

sessionUpdate: 'user_message_chunk',

content: { type: 'text', text: contentString },

});

}

} else if (msg.type === 'gemini') {

// Thoughts

if (msg.thoughts) {

for (const thought of msg.thoughts) {

const thoughtText = `**${thought.subject}**\n${thought.description}`;

await this.sendUpdate({

sessionUpdate: 'agent_thought_chunk',

content: { type: 'text', text: thoughtText },

});

}

}

// Message text

if (contentString.trim()) {

await this.sendUpdate({

sessionUpdate: 'agent_message_chunk',

content: { type: 'text', text: contentString },

});

}

// Tool calls

if (msg.toolCalls) {

for (const toolCall of msg.toolCalls) {

const toolCallContent: acp.ToolCallContent[] = [];

if (toolCall.resultDisplay) {

if (typeof toolCall.resultDisplay === 'string') {

toolCallContent.push({

type: 'content',

content: { type: 'text', text: toolCall.resultDisplay },

});

} else if ('fileName' in toolCall.resultDisplay) {

toolCallContent.push({

type: 'diff',

path: toolCall.resultDisplay.fileName,

oldText: toolCall.resultDisplay.originalContent,

newText: toolCall.resultDisplay.newContent,

});

}

}

const tool = this.context.toolRegistry.getTool(toolCall.name);

await this.sendUpdate({

sessionUpdate: 'tool_call',

toolCallId: toolCall.id,

status:

toolCall.status === CoreToolCallStatus.Success

? 'completed'

: 'failed',

title: toolCall.displayName || toolCall.name,

content: toolCallContent,

kind: tool ? toAcpToolKind(tool.kind) : 'other',

});

}

}

}

}

}

async prompt(params: acp.PromptRequest): Promise<acp.PromptResponse> {

this.pendingPrompt?.abort();

const pendingSend = new AbortController();

this.pendingPrompt = pendingSend;

await this.context.config.waitForMcpInit();

const promptId = Math.random().toString(16).slice(2);

const chat = this.chat;

const parts = await this.#resolvePrompt(params.prompt, pendingSend.signal);

// Command interception

let commandText = '';

for (const part of parts) {

if (typeof part === 'object' && part !== null) {

if ('text' in part) {

// It is a text part

// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-type-assertion

const text = (part as any).text;

if (typeof text === 'string') {

commandText += text;

}

} else {

// Non-text part (image, embedded resource)

// Stop looking for command

break;

}

}

}

commandText = commandText.trim();

if (

commandText &&

(commandText.startsWith('/') || commandText.startsWith('$'))

) {

// If we found a command, pass it to handleCommand

// Note: handleCommand currently expects `commandText` to be the command string

// It uses `parts` argument but effectively ignores it in current implementation

const handled = await this.handleCommand(commandText, parts);

if (handled) {

return {

stopReason: 'end_turn',

_meta: {

quota: {

token_count: { input_tokens: 0, output_tokens: 0 },

model_usage: [],

},

},

};

}

}

let totalInputTokens = 0;

let totalOutputTokens = 0;

const modelUsageMap = new Map<string, { input: number; output: number }>();

let nextMessage: Content | null = { role: 'user', parts };

while (nextMessage !== null) {

if (pendingSend.signal.aborted) {

chat.addHistory(nextMessage);

return { stopReason: CoreToolCallStatus.Cancelled };

}

const functionCalls: FunctionCall[] = [];

try {

const routingContext: RoutingContext = {

history: chat.getHistory(/*curated=*/ true),

request: nextMessage?.parts ?? [],

signal: pendingSend.signal,

requestedModel: this.context.config.getModel(),

};

const router = this.context.config.getModelRouterService();

const { model } = await router.route(routingContext);

const responseStream = await chat.sendMessageStream(

{ model },

nextMessage?.parts ?? [],

promptId,

pendingSend.signal,

LlmRole.MAIN,

);

nextMessage = null;

let turnInputTokens = 0;

let turnOutputTokens = 0;

let turnModelId = model;

for await (const resp of responseStream) {

if (pendingSend.signal.aborted) {

return { stopReason: CoreToolCallStatus.Cancelled };

}

if (resp.type === StreamEventType.CHUNK && resp.value.usageMetadata) {

turnInputTokens =

resp.value.usageMetadata.promptTokenCount ?? turnInputTokens;

turnOutputTokens =

resp.value.usageMetadata.candidatesTokenCount ?? turnOutputTokens;

if (resp.value.modelVersion) {

turnModelId = resp.value.modelVersion;

}

}

if (

resp.type === StreamEventType.CHUNK &&

resp.value.candidates &&

resp.value.candidates.length > 0

) {

const candidate = resp.value.candidates[0];

for (const part of candidate.content?.parts ?? []) {

if (!part.text) {

continue;

}

const content: acp.ContentBlock = {

type: 'text',

text: part.text,

};

// eslint-disable-next-line @typescript-eslint/no-floating-promises

this.sendUpdate({

sessionUpdate: part.thought

? 'agent_thought_chunk'

: 'agent_message_chunk',

content,

});

}

}

if (resp.type === StreamEventType.CHUNK && resp.value.functionCalls) {

functionCalls.push(...resp.value.functionCalls);

}

}

totalInputTokens += turnInputTokens;

totalOutputTokens += turnOutputTokens;

if (turnInputTokens > 0 || turnOutputTokens > 0) {

const existing = modelUsageMap.get(turnModelId) ?? {

input: 0,

output: 0,

};

existing.input += turnInputTokens;

existing.output += turnOutputTokens;

modelUsageMap.set(turnModelId, existing);

}

if (pendingSend.signal.aborted) {

return { stopReason: CoreToolCallStatus.Cancelled };

}

} catch (error) {

if (getErrorStatus(error) === 429) {

throw new acp.RequestError(

429,

'Rate limit exceeded. Try again later.',

);

}

if (

pendingSend.signal.aborted ||

(error instanceof Error && error.name === 'AbortError')

) {

return { stopReason: CoreToolCallStatus.Cancelled };

}

if (

error instanceof InvalidStreamError ||

(error &&

typeof error === 'object' &&

'type' in error &&

(error.type === 'NO_RESPONSE_TEXT' ||

error.type === 'NO_FINISH_REASON' ||

error.type === 'MALFORMED_FUNCTION_CALL' ||

error.type === 'UNEXPECTED_TOOL_CALL'))

) {

// The stream ended with an empty response or malformed tool call.

// Treat this as a graceful end to the model's turn rather than a crash.

return {

stopReason: 'end_turn',

_meta: {

quota: {

token_count: {

input_tokens: totalInputTokens,

output_tokens: totalOutputTokens,

},

model_usage: Array.from(modelUsageMap.entries()).map(

([modelName, counts]) => ({

model: modelName,

token_count: {

input_tokens: counts.input,

output_tokens: counts.output,

},

}),

),

},

},

};

}

throw new acp.RequestError(

getErrorStatus(error) || 500,

getAcpErrorMessage(error),

);

}

if (functionCalls.length > 0) {

const toolResponseParts: Part[] = [];

for (const fc of functionCalls) {

const response = await this.runTool(pendingSend.signal, promptId, fc);

toolResponseParts.push(...response);

}

nextMessage = { role: 'user', parts: toolResponseParts };

}

}

const modelUsageArray = Array.from(modelUsageMap.entries()).map(

([modelName, counts]) => ({

model: modelName,

token_count: {

input_tokens: counts.input,

output_tokens: counts.output,

},

}),

);

return {

stopReason: 'end_turn',

_meta: {

quota: {

token_count: {

input_tokens: totalInputTokens,

output_tokens: totalOutputTokens,

},

model_usage: modelUsageArray,

},

},

};

}

private async handleCommand(

commandText: string,

// eslint-disable-next-line @typescript-eslint/no-unused-vars

parts: Part[],

): Promise<boolean> {

const gitService = await this.context.config.getGitService();

const commandContext = {

agentContext: this.context,

settings: this.settings,

git: gitService,

sendMessage: async (text: string) => {

await this.sendUpdate({

sessionUpdate: 'agent_message_chunk',

content: { type: 'text', text },

});

},

};

return this.commandHandler.handleCommand(commandText, commandContext);

}

private async sendUpdate(update: acp.SessionUpdate): Promise<void> {

const params: acp.SessionNotification = {

sessionId: this.id,

update,

};

await this.connection.sessionUpdate(params);

}

private async runTool(

abortSignal: AbortSignal,

promptId: string,

fc: FunctionCall,

): Promise<Part[]> {

const callId = fc.id ?? GeminiAgent.generateCallId(fc.name || 'unknown');

const args = fc.args ?? {};

const startTime = Date.now();

const errorResponse = (error: Error) => {

const durationMs = Date.now() - startTime;

logToolCall(

this.context.config,

new ToolCallEvent(

undefined,

fc.name ?? '',

args,

durationMs,

false,

promptId,

typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool

? 'mcp'

: 'native',

error.message,

),

);

return [

{

functionResponse: {

id: callId,

name: fc.name ?? '',

response: { error: error.message },