@stack-spot/portal-network 1.0.0-dev.1769537511491 → 1.0.0-dev.1769793051111

package/dist/client/ai.js

@@ -1,12 +1,10 @@
-import { findLast, isArray, isNil, last } from 'lodash';
+import { isArray } from 'lodash';
 import { getApiAddresses } from '../api-addresses.js';
 import { addFavoriteV1AiStacksStackIdFavoritePost, addFavoriteV1QuickCommandsSlugFavoritePost, calculateNextStepV1QuickCommandsSlugStepsStepSlugCalculateNextStepPost, callbackV1QuickCommandsCallbackExecutionIdGet, checkQuickCommandExistsV1QuickCommandsSlugExistsGet, conversationHistoryV1ConversationsConversationIdGet, createAnswerForReviewV1ResourcesResourceTypeSlugResourceSlugReviewsReviewIdAnswersPost, createExecutionV1QuickCommandsCreateExecutionSlugPost, createQuickCommandV1QuickCommandsPost, createResourceReviewV1ResourcesResourceTypeSlugResourceSlugReviewsPost, currentV1TokensUsageCurrentGet, defaults, deleteConversationV1ConversationsConversationIdDelete, deleteFavoriteV1AiStacksStackIdFavoriteDelete, deleteFavoriteV1QuickCommandsSlugFavoriteDelete, deleteKnowledgeObjectByCustomIdV1KnowledgeSourcesSlugObjectsCustomIdDelete, deleteKnowledgeSourceV1KnowledgeSourcesSlugDelete, deleteQuickCommandV1QuickCommandsSlugDelete, deleteResourceReviewV1ResourcesResourceTypeSlugResourceSlugReviewsReviewIdDelete, deleteReviewCommentV1ResourcesResourceTypeSlugResourceSlugReviewsReviewIdAnswersAnswerIdDelete, downloadConversationV1ConversationsConversationIdDownloadGet, findKnowledgeObjectByCustomIdV1KnowledgeSourcesSlugObjectsCustomIdGet, findKnowledgeSourceDependenciesV1KnowledgeSourcesSlugDependenciesGet, findKnowledgeSourceV1KnowledgeSourcesSlugGet, forkV1QuickCommandsSlugForkPost, formatFetchStepV1QuickCommandsSlugStepsStepSlugFetchFormatPost, formatResultV1QuickCommandsSlugResultFormatPost, getContentDependenciesV1ContentContentTypeContentIdDependenciesGet, getFlagsV1FlagsGet, getQuickCommandV1QuickCommandsSlugGet, getReviewsByResourceV1ResourcesResourceTypeSlugResourceSlugReviewsGet, getScriptExecutionStatusV1QuickCommandsScriptExecutionsScriptExecutionIdGet, getUploadFormV1FileUploadFormPost, listAiStacksV1AiStacksGet, listAllV1QuickCommandsAllGet, listAllV2QuickCommandsAllGet, listAllV3QuickCommandsGet, listAssociationV1WorkspaceWorkspaceIdGet, listConversationsV1ConversationsGet, listKnowledgeSourcesV1KnowledgeSourcesGet, postEventV1EventsPost, publishV1QuickCommandsSlugPublishPost, quickActionsV1QuickActionsPost, quickCommandsRunV2V2QuickCommandsSlugStepsStepSlugRunPost, resetKnowledgeObjectsV1KnowledgeSourcesSlugObjectsDelete, runFetchStepV1QuickCommandsSlugStepsStepSlugFetchRunPost, searchKnowledgeSourcesV1KnowledgeSourcesSearchPost, startScriptStepV1QuickCommandsSlugStepsStepSlugStartScriptPost, tokensByUserV1AnalyticsTokensByUserGet, tokensDailyUsageV1AnalyticsTokensDailyUsageGet, totalV1TokensUsageTotalGet, updateQuickCommandV1QuickCommandsSlugPatch, updateResourceReviewV1ResourcesResourceTypeSlugResourceSlugReviewsReviewIdPatch, updateReviewCommentV1ResourcesResourceTypeSlugResourceSlugReviewsReviewIdAnswersAnswerIdPatch, updateTitleV1ConversationsConversationIdPatch, vectorizeCustomKnowledgeSourceV1KnowledgeSourcesSlugCustomPost, } from '../api/ai.js';
 import { StackspotAPIError } from '../error/StackspotAPIError.js';
 import { ReactQueryNetworkClient } from '../network/ReactQueryNetworkClient.js';
 import { removeAuthorizationParam } from '../utils/remove-authorization-param.js';
 import { StreamedJson } from '../utils/StreamedJson.js';
-import { formatJson, getSizeOfString } from '../utils/string.js';
-import { agentToolsClient } from './agent-tools.js';
 const listQAV3WithoutAuthorization = removeAuthorizationParam(listAllV3QuickCommandsGet);
 class AIClient extends ReactQueryNetworkClient {
     constructor() {
@@ -540,563 +538,6 @@ class AIClient extends ReactQueryNetworkClient {
             minChangeIntervalMS,
         });
     }
-    static async toolsOfAgent(agentId, agent_version_number) {
-        try {
-            const agent = agentId ? await agentToolsClient.agentV2.query({
-                agentCoreId: agentId, versionNumber: agent_version_number
-            }) : undefined;
-            if (!agent)
-                return [];
-            const tools = [];
-            agent.version?.toolkits?.builtin_toolkits?.forEach(kit => kit.tools?.forEach(({ id, name, description }) => {
-                if (id)
-                    tools.push({ image: kit.image_url, id, name: name || id, description });
-            }));
-            agent.version?.toolkits?.custom_toolkits?.forEach(kit => kit.tools?.forEach(({ id, name, description }) => {
-                if (id)
-                    tools.push({ image: kit.avatar ?? undefined, id, name: name || id, description });
-            }));
-            return tools;
-        }
-        catch {
-            return [];
-        }
-    }
-    /**
-     * Runs an Router step of a quick command.
-     */
-    async runRouterStep(ctx, stepIndex, iteration, progress) {
-        const { qc: { slug, steps }, code, resultMap, customInputs } = ctx;
-        const step = steps[stepIndex];
-        const inputData = Object.keys(customInputs).length > 0 && code ? { ...customInputs, [code]: code } : code ?? customInputs;
-        try {
-            progress?.onStepChange?.({ step: step.slug, ...resultMap, ...{ statusResult: 'START' } });
-            if (step.slug in iteration) {
-                iteration[step.slug] = iteration[step.slug] + 1;
-            }
-            else {
-                iteration[step.slug] = 1;
-            }
-            const { next_step_slug } = await aiClient.calculateNextStep.mutate({
-                stepSlug: step.slug,
-                slug: slug,
-                quickCommandEvaluateStepRouterRequest: {
-                    executions_count: iteration[step.slug],
-                    input_data: inputData,
-                    slugs_executions: resultMap,
-                },
-            });
-            progress?.onStepChange?.({ step: step.slug, ...resultMap, ...{ statusResult: 'END' } });
-            if (next_step_slug === step.slug) {
-                return aiClient.runStepsRecursively(stepIndex, ctx, iteration, progress);
-            }
-            const nextStepIndex = steps?.findIndex((step) => step.slug === next_step_slug);
-            if (isNil(nextStepIndex) || nextStepIndex === -1)
-                return;
-            return aiClient.runStepsRecursively(nextStepIndex, ctx, iteration, progress);
-        }
-        catch (error) {
-            progress?.onStepChange?.({
-                step: step.slug, error: error, answer: JSON.stringify(error.message), statusResult: 'ERROR', ...resultMap,
-            });
-            // eslint-disable-next-line no-console
-            console.error('Error executing QC step', error);
-        }
-    }
-    async getScriptStepStatus(scriptExecutionId, interval = 5000, maxAttempts = 500, currentAttempt = 0) {
-        if (currentAttempt >= maxAttempts) {
-            throw new Error('Max attempts reached in verify script status');
-        }
-        await aiClient.getStatusScriptStep.invalidate({ scriptExecutionId });
-        const response = await aiClient.getStatusScriptStep.query({ scriptExecutionId });
-        if (response.status === 'success') {
-            return response;
-        }
-        if (response.status === 'failure') {
-            throw response;
-        }
-        await new Promise(resolve => { setTimeout(resolve, interval); });
-        return aiClient.getScriptStepStatus(scriptExecutionId, interval, maxAttempts, currentAttempt + 1);
-    }
-    /**
-     * Runs a fetch step of a quick command and puts the result in the `resultMap` of the context passed as parameter.
-     */
-    async runFetchStep(ctx, stepIndex, progress) {
-        const { qc: { slug, steps }, code, context, resultMap, customInputs, executionId, signal } = ctx;
-        const step = steps[stepIndex];
-        progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: undefined, statusResult: 'START' });
-        //If is_remote we call backend to execute for us and we only have the response
-        if (step.is_remote) {
-            ctx.isRemote = true;
-            try {
-                const { data } = await aiClient.fetchStepOfQuickCommandRemotely.mutate({
-                    slug, stepSlug: step.slug,
-                    quickCommandsExecutionRequest: {
-                        code_selection: code, context, qc_execution_id: executionId,
-                        slugs_executions: { ...resultMap, ...customInputs },
-                    },
-                }, signal);
-                //data is the return of the request in the QC so we do not have full control over the response
-                //We handle the usual format with body, status_code and headers, but we might also handle other formats
-                const responseData = data;
-                progress?.onStepChange?.({
-                    step: step.slug, ...resultMap, answer: JSON.stringify(responseData.body) ?? JSON.stringify(responseData), statusResult: 'END'
-                });
-                resultMap[step.slug] = {
-                    status: responseData.status_code || 200,
-                    data: JSON.stringify(responseData.body) ?? JSON.stringify(responseData),
-                    headers: responseData.headers ?? {},
-                };
-                return;
-            }
-            catch (error) {
-                const errorMessage = `${error}, Failed to execute step "${step.slug}" of quick command "${slug}".`;
-                progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: errorMessage, error: errorMessage, statusResult: 'ERROR' });
-                throw new Error(errorMessage);
-            }
-        }
-        const { headers, data, method, url } = await aiClient.fetchStepOfQuickCommand.mutate({
-            slug,
-            stepSlug: step.slug,
-            quickCommandsExecutionRequest: {
-                input_data: code, context, qc_execution_id: executionId,
-                slugs_executions: { ...resultMap, ...customInputs },
-            },
-        }, signal);
-        const body = ['get', 'head'].includes(method.toLowerCase()) ? undefined : data;
-        try {
-            //Local execution
-            const response = await fetch(url, { headers: headers || undefined, body, method, signal });
-            const responseData = await response.text();
-            if (!response.ok)
-                throw new Error(`Failed to execute step "${step.slug}" of quick command "${slug}". Status ${response.status}.`);
-            progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: responseData, statusResult: 'END' });
-            resultMap[step.slug] = {
-                status: response.status,
-                data: responseData,
-                headers: Object.fromEntries(response.headers.entries()),
-            };
-        }
-        catch (error) {
-            const errorMessage = `${error}, Failed to execute step "${step.slug}" of quick command "${slug}".`;
-            progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: errorMessage, error: errorMessage, statusResult: 'ERROR' });
-            throw new Error(errorMessage);
-        }
-    }
-    /**
-     * Runs an LLM step of a quick command and puts the result in the `resultMap` of the context passed as parameter.
-     */
-    async runLLMStep({ qc: { slug, steps }, code, customInputs, context, executionId, resultMap, signal }, stepIndex, progress) {
-        const step = steps[stepIndex];
-        let stepContext = context;
-        if (!step.use_uploaded_files) {
-            const { upload_ids: _upload_ids, ...contextDataProps } = context;
-            stepContext = { ...contextDataProps };
-        }
-        // eslint-disable-next-line no-async-promise-executor
-        return new Promise(async (resolve) => {
-            progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: undefined, statusResult: 'START' });
-            const stream = aiClient.streamLlmStepOfQuickCommand(slug, step.slug, {
-                input_data: code,
-                context: stepContext,
-                qc_execution_id: executionId,
-                slugs_executions: { ...resultMap, ...customInputs },
-            });
-            signal.addEventListener('abort', () => stream.cancel());
-            stream.onChange(item => {
-                if (item?.sources?.length) {
-                    progress?.onStepChange?.({ step: step.slug, ...resultMap, sources: JSON.stringify(item.sources) });
-                }
-                else {
-                    item.answer !== undefined && progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: item.answer });
-                }
-            });
-            try {
-                const finalValue = await stream.getValue();
-                resultMap[step.slug] = finalValue;
-                progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: finalValue.answer,
-                    sources: finalValue.sources ? JSON.stringify(finalValue.sources) : '', statusResult: 'END' });
-                resolve(finalValue);
-            }
-            catch (error) {
-                // eslint-disable-next-line no-console
-                console.error('Error executing QC step', error);
-                const errorStep = `Failed to execute step "${step.slug}" of quick command "${slug}". Reason: ${error.message}`;
-                progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: errorStep, error: errorStep, statusResult: 'ERROR' });
-                throw error;
-            }
-        });
-    }
-    async runScriptStep({ qc: { slug, steps }, code, context, resultMap, customInputs, signal }, stepIndex, progress) {
-        const step = steps[stepIndex];
-        let stepContext = context;
-        progress?.onStepChange?.({ step: step.slug, ...resultMap, ...{ statusResult: 'START' } });
-        if (!step.use_uploaded_files) {
-            const { upload_ids: _upload_ids, ...contextDataProps } = context;
-            stepContext = { ...contextDataProps };
-        }
-        try {
-            const { script_execution_id } = await aiClient.startScriptStep.mutate({
-                stepSlug: step.slug,
-                slug: slug,
-                quickCommandStartScriptRequest: {
-                    input_data: code,
-                    custom_inputs: customInputs,
-                    context: stepContext,
-                    slugs_executions: resultMap,
-                },
-            }, signal);
-            const scriptResult = await aiClient.getScriptStepStatus(script_execution_id);
-            progress?.onStepChange?.({ step: step.slug, ...scriptResult, ...{ statusResult: 'END' } });
-            resultMap[step.slug] = scriptResult;
-        }
-        catch (error) {
-            progress?.onStepChange?.({ step: step.slug, ...error, statusResult: 'ERROR', ...resultMap });
-            let message = error.result?.error ?? error.message ?? `${error}`;
-            if (error instanceof StackspotAPIError)
-                message = error.translate();
-            throw new Error(`Failed to execute step "${step.slug}" of quick command "${slug}". Error ${message}.`);
-        }
-    }
-    async runStepsRecursively(currentIndex, ctx, iteration, progress) {
-        const { qc, resultMap } = ctx;
-        if (!qc.steps || currentIndex >= qc.steps?.length)
-            return;
-        progress?.update?.(currentIndex);
-        const currentStep = qc.steps[currentIndex];
-        if (currentStep.type === 'ROUTER') {
-            await aiClient.runRouterStep(ctx, currentIndex, iteration, progress);
-            return;
-        }
-        const parsedStep = currentStep;
-        let nextIndex = currentIndex + 1;
-        let nextStepSlug = parsedStep.next_step_slug;
-        if (currentStep.type === 'SCRIPT') {
-            await aiClient.runScriptStep(ctx, currentIndex, progress);
-        }
-        else if (currentStep.type === 'FETCH') {
-            await aiClient.runFetchStep(ctx, currentIndex, progress);
-        }
-        else {
-            try {
-                await aiClient.runLLMStep(ctx, currentIndex, progress);
-            }
-            catch (error) {
-                progress?.onStepChange?.({ step: currentStep.slug,
-                    error: error, answer: JSON.stringify(error), statusResult: 'ERROR', ...resultMap });
-            }
-            const stepResult = resultMap[currentStep.slug];
-            //When we have an error but there is an error path defined
-            if (typeof stepResult !== 'string' && stepResult.answer_status?.next_step_slug) {
-                nextStepSlug = stepResult?.answer_status?.next_step_slug;
-            }
-            else if (!stepResult?.answer_status?.success) { //When we have an error but no error path defined we should fail the execution
-                progress?.onStepChange?.({
-                    step: currentStep.slug, error: stepResult?.answer_status,
-                    answer: JSON.stringify(stepResult?.answer_status?.failure_message), statusResult: 'ERROR', ...resultMap
-                });
-                throw new Error();
-            }
-        }
-        const stepResult = ctx.resultMap[currentStep.slug];
-        if (stepResult && typeof stepResult !== 'string' && 'answer_status' in stepResult && !!stepResult.answer_status?.next_step_slug) {
-            nextStepSlug = stepResult.answer_status.next_step_slug;
-        }
-        if (nextStepSlug) {
-            nextIndex = nextStepSlug === 'end' ?
-                qc.steps.length : qc.steps?.findIndex((step) => step.slug === nextStepSlug);
-        }
-        await aiClient.runStepsRecursively(nextIndex, ctx, iteration, progress);
-    }
-    async formatResult({ qc, code, executionId, context, resultMap, customInputs, signal }) {
-        const formatted = await aiClient.formatResultOfQuickCommand.mutate({
-            slug: qc.slug,
-            quickCommandsExecutionRequest: {
-                input_data: code,
-                context,
-                qc_execution_id: executionId,
-                slugs_executions: { ...resultMap, ...customInputs },
-            },
-        }, signal);
-        return formatted.result;
-    }
-    /**
-     * This registers a quick command event in the backend (analytics).
-     */
-    async registerQCAnalyticsEvent({ qc, isRemote, executionId, code = '', context }, status, start) {
-        const now = new Date().getTime();
-        try {
-            await aiClient.createEvent.mutate({
-                body: [{
-                        type: 'custom_quick_command_execution',
-                        quick_command_event: {
-                            type: qc.type || '',
-                            duration_execution: now - start,
-                            status_execution: status,
-                            slug: qc.slug,
-                            qc_execution_id: executionId,
-                            id: qc.id,
-                            is_remote: isRemote,
-                        },
-                        code,
-                        context,
-                        knowledge_sources: [],
-                        size: getSizeOfString(code),
-                        generated_at: now,
-                    }],
-            });
-        }
-        catch (error) {
-            // eslint-disable-next-line no-console
-            console.warn('Failed to register event: quick command.');
-        }
-    }
-    async runQuickCommand(ctx, progress) {
-        const start = new Date().getTime();
-        const { slug } = ctx;
-        const qc = await aiClient.quickCommand.query({ slug });
-        const ctxExecution = { ...ctx, qc };
-        try {
-            await aiClient.runStepsRecursively(0, ctxExecution, {}, progress);
-            progress?.remove?.();
-            const result = await aiClient.formatResult(ctxExecution);
-            await aiClient.registerQCAnalyticsEvent(ctxExecution, '200', start);
-            return result;
-        }
-        catch (error) {
-            let message = error.message || `${error}`;
-            if (error instanceof StackspotAPIError)
-                message = error.translate();
-            await aiClient.registerQCAnalyticsEvent(ctxExecution, message, start);
-            throw error;
-        }
-    }
-    sendChatMessage(request, minChangeIntervalMS) {
-        const abortController = new AbortController();
-        const headers = {
-            'Content-Type': 'application/json',
-            'Accept': 'text/event-stream',
-        };
-        const events = this.stream(this.resolveURL('v3/chat'), { method: 'post', body: JSON.stringify(request), headers, signal: abortController.signal });
-        const DYNAMIC_TOOL_ID = 'dynamic';
-        function isDynamicTool(info) {
-            return info.type === 'tool' && info.id === DYNAMIC_TOOL_ID;
-        }
-        /**
-         * This function treats events in the streaming that deals with the execution of tools. Since these events are not concatenated like
-         * normal streamings of data, we need this separate function to deal with them. It transforms the internal data model of the
-         * StreamedJson object whenever an event is triggered.
-         */
-        async function transform(event, data) {
-            const info = event.agent_info;
-            if (!info)
-                return;
-            const tools = await AIClient.toolsOfAgent(request.context?.agent_id, request.agent_version_number ?? undefined);
-            data.steps = data.steps ? [...data.steps] : [];
-            if (info.type === 'planning' && info.action === 'end') {
-                data.steps.push({
-                    id: 'planning',
-                    type: 'planning',
-                    status: 'success',
-                    duration: info.duration || 0,
-                    steps: info.data?.steps?.map(s => s.goal) ?? [],
-                    goal: info.data?.plan_goal ?? '',
-                });
-                info.data?.steps.forEach(s => data.steps?.push({
-                    id: s.id,
-                    type: 'step',
-                    status: 'pending',
-                    input: s.goal,
-                    attempts: [{
-                            tools: s.tools?.map(t => ({
-                                ...(tools.find(({ id }) => id === t.tool_id) ?? { id: t.tool_id, name: t.tool_id }),
-                                executionId: t.tool_execution_id,
-                                goal: t.goal,
-                            })),
-                        }],
-                }));
-                data.steps.push({ id: 'answer', type: 'answer', status: 'pending' });
-            }
-            if (info.type === 'planning' && info.action === 'awaiting_approval') {
-                data.steps.push({
-                    id: 'planning',
-                    type: 'planning',
-                    status: 'awaiting_approval',
-                    user_question: info.data?.user_question,
-                    duration: info.duration || 0,
-                    steps: info.data?.steps?.map(s => s.goal) ?? [],
-                    goal: info.data?.plan_goal ?? '',
-                });
-                info.data?.steps.forEach(s => data.steps?.push({
-                    id: s.id,
-                    type: 'step',
-                    status: 'pending',
-                    input: s.goal,
-                    attempts: [{
-                            tools: s.tools?.map(t => ({
-                                ...(tools.find(({ id }) => id === t.tool_id) ?? { id: t.tool_id, name: t.tool_id }),
-                                executionId: t.tool_execution_id,
-                                goal: t.goal,
-                            })),
-                        }],
-                }));
-                data.steps.push({ id: 'answer', type: 'answer', status: 'pending' });
-            }
-            if (info.type === 'step' && info.action === 'start') {
-                const step = data.steps.find(s => s.id === info.id);
-                if (step)
-                    step.status = 'running';
-            }
-            if (info.type === 'step' && info.action === 'end') {
-                const step = data.steps.find(s => s.id === info.id);
-                if (step) {
-                    step.status = 'success';
-                    step.duration = info.duration;
-                    const lastToolId = last(step.attempts[0].tools)?.id;
-                    const lastAttemptOfLastTool = findLast(step.attempts.map(a => a.tools).flat(), t => t?.id === lastToolId);
-                    step.output = lastAttemptOfLastTool?.output;
-                }
-            }
-            if (info.type === 'tool_calls' && info.action === 'start') {
-                const hasPlanning = data.steps.find(s => s.type === 'planning');
-                // On the first tool_calls:start, create the synthetic planning ("dynamic") step.
-                if (!hasPlanning) {
-                    const userPrompt = request.user_prompt === 'string' ? request.user_prompt : JSON.stringify(request.user_prompt);
-                    data.steps.push({
-                        id: 'dynamic',
-                        type: 'planning',
-                        status: 'success',
-                        steps: [],
-                        goal: userPrompt,
-                        user_question: userPrompt,
-                    });
-                }
-                const toolsStepId = data.steps.filter(s => s.id === 'tools' || s.id.startsWith('tools-')).length + 1;
-                data.steps.push({
-                    id: `tools-${toolsStepId.toString()}`,
-                    type: 'step',
-                    status: 'running',
-                    attempts: [{ tools: [] }],
-                });
-            }
-            if (info.type === 'tool_calls' && info.action === 'end') {
-                const lastStep = findLast(data.steps, s => s.id === 'tools' || s.id.startsWith('tools-'));
-                if (lastStep) {
-                    lastStep.status = 'success';
-                    lastStep.duration = info.duration;
-                    const lastAttemptOfLastTool = last(lastStep.attempts.map(a => a.tools).flat());
-                    lastStep.output = lastAttemptOfLastTool?.output;
-                }
-            }
-            if (info.type === 'tool' && info.action === 'awaiting_approval') {
-                const tool = tools.find(({ id }) => id === info.data?.tool_id);
-                data.steps.push({
-                    id: info.id,
-                    type: 'tool',
-                    status: 'awaiting_approval',
-                    duration: info.duration || 0,
-                    input: info.data?.input,
-                    user_question: info.data?.user_question,
-                    attempts: [{
-                            tools: [{
-                                    executionId: info.id,
-                                    id: info.data?.tool_id ?? '',
-                                    name: tool?.name ?? '',
-                                    goal: tool?.goal,
-                                    ...tool,
-                                }],
-                        }],
-                });
-                data.steps.push({ id: 'answer', type: 'answer', status: 'pending' });
-            }
-            if (info.type === 'tool' && info.action === 'start') {
-                if (!info.data)
-                    return;
-                const input = formatJson(info.data.input);
-                const tool = findLast(tools, ({ id }) => id === info.data?.tool_id) ?? { id: info.data?.tool_id, name: info.data?.tool_id };
-                const currentStep = findLast(data.steps, s => s.status === 'running');
-                //There might be a tool with status awaiting_approval, so we want to inform tool has already started
-                if (!currentStep || !currentStep?.attempts?.[0]?.tools) {
-                    data.steps.push({
-                        id: info.id,
-                        type: 'tool',
-                        status: 'running',
-                        duration: info.duration || 0,
-                        input: info.data?.input,
-                        user_question: info.data?.user_question,
-                        attempts: [{
-                                tools: [{ ...tool, executionId: info.id, input }],
-                            }],
-                    });
-                }
-                else {
-                    const toolInFirstAttempt = findLast(currentStep?.attempts?.[0]?.tools, t => t.executionId === info.id);
-                    //One step might have multiple tools. When in an approval mode, we might not have all the tools in the array yet.
-                    //For dynamic tools (id === 'dynamic'), we always push a new tool, since dynamic executions can trigger
-                    //multiple tool runs in the same step and do not follow the planned tool structure.
-                    //So we make sure to add any tools that are not in there, or always add for dynamic tools.
-                    if (!toolInFirstAttempt || isDynamicTool(info)) {
-                        currentStep.attempts?.[0].tools?.push({
-                            ...tool,
-                            executionId: info.id,
-                            input,
-                            status: 'running',
-                        });
-                    }
-                    else {
-                        const input = formatJson(info.data.input);
-                        if (info.data.attempt === 1) {
-                            toolInFirstAttempt.input = input;
-                        }
-                        else {
-                            currentStep.attempts[info.data.attempt - 1] ??= { tools: [] };
-                            currentStep.attempts[info.data.attempt - 1].tools?.push({
-                                ...tool,
-                                executionId: info.id,
-                                input,
-                            });
-                        }
-                    }
-                }
-            }
-            if (info.type === 'tool' && info.action === 'end') {
-                const currentStep = data.steps.find(s => s.status === 'running');
-                if (!currentStep || !info.data)
-                    return;
-                // attempt index for tool execution starts at 0 for dynamically executed tools,while for planned tools it starts at 1
-                const attempt = isDynamicTool(info) ? info.data.attempt : info.data.attempt - 1;
-                const tool = last(currentStep?.attempts?.[attempt]?.tools);
-                if (tool) {
-                    tool.output = formatJson(info.data.output);
-                    tool.duration = info.duration;
-                    tool.status = 'success';
-                }
-            }
-            if (info.type === 'final_answer' && info.action === 'start') {
-                const answerStep = last(data.steps);
-                if (answerStep)
-                    answerStep.status = 'running';
-            }
-            if (info.type === 'chat' && info.action === 'end') {
-                const lastStep = last(data.steps);
-                if (lastStep?.type === 'answer') {
-                    lastStep.status = 'success';
-                    lastStep.duration = info.duration;
-                }
-                else {
-                    data.steps.push({ id: 'answer', type: 'answer', status: 'success' });
-                }
-            }
-        }
-        return new StreamedJson({
-            eventsPromise: events,
-            abortController,
-            minChangeIntervalMS,
-            ignoreKeys: ['agent_info'],
-            transform,
-            textFromErrorEvent: data => data.answer ?? 'Unknown error',
-        });
-    }
 }
 export const aiClient = new AIClient();
 //# sourceMappingURL=ai.js.map