AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents
TypeScript ai-agentai-agent-toolsai-agentsai-agents-frameworkmcpmcp-servermcp-toolsmcpsn8n-alternativeno-code-automationworkflowworkflow-automationworkflows
import { DynamicToolUIPart, UIMessageChunk } from 'ai';
import { chatDebug } from '@/lib/chat-debug-logger';
import { ChatUIMessage } from './chat-types';
function createStreamingState({
messageId,
initialParts,
}: {
messageId?: string;
initialParts?: ChatUIMessage['parts'];
} = {}): StreamingState {
return {
message: {
id: messageId ?? `stream-${Date.now()}`,
role: 'assistant',
parts: initialParts ? [...initialParts] : [],
},
activeTextParts: {},
activeReasoningParts: {},
partialToolCalls: {},
seenToolCallIds: new Set(),
};
}
function findToolPartIndex({
state,
toolCallId,
}: {
state: StreamingState;
toolCallId: string;
}): number {
return state.message.parts.findIndex(
(p) =>
p.type === 'dynamic-tool' &&
'toolCallId' in p &&
p.toolCallId === toolCallId,
);
}
function updateToolPartFields({
state,
idx,
fields,
}: {
state: StreamingState;
idx: number;
fields: Partial<
Pick<MutableToolPart, 'state' | 'input' | 'output' | 'errorText'>
>;
}): void {
const part = state.message.parts[idx] as MutableToolPart;
if (fields.state !== undefined) part.state = fields.state;
if ('input' in fields) part.input = fields.input;
if ('output' in fields) part.output = fields.output;
if ('errorText' in fields) part.errorText = fields.errorText;
}
function applyChunk({
state,
chunk,
}: {
state: StreamingState;
chunk: UIMessageChunk;
}): void {
chatDebug.debug({ chunk: { type: chunk.type } }, 'applied stream chunk');
switch (chunk.type) {
case 'start': {
if (chunk.messageId) {
state.message.id = chunk.messageId;
}
break;
}
case 'text-start': {
const partIndex = state.message.parts.length;
state.message.parts.push({ type: 'text', text: '' });
state.activeTextParts[chunk.id] = partIndex;
break;
}
case 'text-delta': {
const idx = state.activeTextParts[chunk.id];
if (idx === undefined) break;
const part = state.message.parts[idx];
if (part?.type === 'text') {
part.text += chunk.delta;
}
break;
}
case 'text-end': {
delete state.activeTextParts[chunk.id];
break;
}
case 'reasoning-start': {
const partIndex = state.message.parts.length;
state.message.parts.push({ type: 'reasoning', text: '' });
state.activeReasoningParts[chunk.id] = partIndex;
break;
}
case 'reasoning-delta': {
const idx = state.activeReasoningParts[chunk.id];
if (idx === undefined) break;
const part = state.message.parts[idx];
if (part?.type === 'reasoning') {
part.text += chunk.delta;
}
break;
}
case 'reasoning-end': {
delete state.activeReasoningParts[chunk.id];
break;
}
case 'tool-input-start': {
if (state.seenToolCallIds.has(chunk.toolCallId)) break;
state.seenToolCallIds.add(chunk.toolCallId);
state.message.parts.push({
type: 'dynamic-tool',
toolCallId: chunk.toolCallId,
toolName: chunk.toolName,
title: chunk.title ?? chunk.toolName,
state: 'input-streaming',
input: undefined,
});
state.partialToolCalls[chunk.toolCallId] = {
toolName: chunk.toolName,
inputText: '',
};
break;
}
case 'tool-input-delta': {
const partial = state.partialToolCalls[chunk.toolCallId];
if (!partial) break;
partial.inputText += chunk.inputTextDelta;
break;
}
case 'tool-input-available': {
const idx = findToolPartIndex({ state, toolCallId: chunk.toolCallId });
if (idx === -1) {
if (state.seenToolCallIds.has(chunk.toolCallId)) break;
state.seenToolCallIds.add(chunk.toolCallId);
state.message.parts.push({
type: 'dynamic-tool',
toolCallId: chunk.toolCallId,
toolName: chunk.toolName,
title: chunk.title ?? chunk.toolName,
state: 'input-available',
input: chunk.input,
});
} else {
updateToolPartFields({
state,
idx,
fields: { state: 'input-available', input: chunk.input },
});
}
delete state.partialToolCalls[chunk.toolCallId];
break;
}
case 'tool-input-error': {
const idx = findToolPartIndex({ state, toolCallId: chunk.toolCallId });
if (idx === -1) {
state.message.parts.push({
type: 'dynamic-tool',
toolCallId: chunk.toolCallId,
toolName: chunk.toolName,
title: chunk.title ?? chunk.toolName,
state: 'output-error',
input: chunk.input,
errorText: chunk.errorText,
});
state.seenToolCallIds.add(chunk.toolCallId);
} else {
updateToolPartFields({
state,
idx,
fields: {
state: 'output-error',
input: chunk.input,
errorText: chunk.errorText,
},
});
}
delete state.partialToolCalls[chunk.toolCallId];
break;
}
case 'tool-output-available': {
const idx = findToolPartIndex({ state, toolCallId: chunk.toolCallId });
if (idx === -1) break;
updateToolPartFields({
state,
idx,
fields: { state: 'output-available', output: chunk.output },
});
break;
}
case 'tool-output-error': {
const idx = findToolPartIndex({ state, toolCallId: chunk.toolCallId });
if (idx === -1) break;
updateToolPartFields({
state,
idx,
fields: { state: 'output-error', errorText: chunk.errorText },
});
break;
}
case 'tool-output-denied': {
const idx = findToolPartIndex({ state, toolCallId: chunk.toolCallId });
if (idx === -1) break;
updateToolPartFields({ state, idx, fields: { state: 'output-denied' } });
break;
}
case 'start-step': {
state.message.parts.push({ type: 'step-start' });
break;
}
case 'finish-step': {
state.activeTextParts = {};
state.activeReasoningParts = {};
break;
}
case 'source-url': {
state.message.parts.push({
type: 'source-url',
sourceId: chunk.sourceId,
url: chunk.url,
title: chunk.title,
});
break;
}
case 'source-document': {
state.message.parts.push({
type: 'source-document',
sourceId: chunk.sourceId,
mediaType: chunk.mediaType,
title: chunk.title,
filename: chunk.filename,
});
break;
}
case 'file': {
state.message.parts.push({
type: 'file',
mediaType: chunk.mediaType,
url: chunk.url,
});
break;
}
case 'finish':
case 'error':
case 'abort':
case 'message-metadata':
case 'tool-approval-request':
break;
default:
break;
}
}
function applyChunks({
state,
chunks,
}: {
state: StreamingState;
chunks: UIMessageChunk[];
}): void {
for (const chunk of chunks) {
applyChunk({ state, chunk });
}
}
function snapshotMessage({ state }: { state: StreamingState }): ChatUIMessage {
return {
...state.message,
parts: state.message.parts.map((part) => ({ ...part })),
};
}
export const chunkReducer = {
createStreamingState,
applyChunk,
applyChunks,
snapshotMessage,
};
type MutableToolPart = Pick<
DynamicToolUIPart,
'type' | 'toolCallId' | 'toolName' | 'title'
> & {
state: string;
input: unknown;
output?: unknown;
errorText?: string;
};
type StreamingState = {
message: ChatUIMessage;
activeTextParts: Record<string, number>;
activeReasoningParts: Record<string, number>;
partialToolCalls: Record<string, { toolName: string; inputText: string }>;
seenToolCallIds: Set<string>;
};
export type { StreamingState };