@agent-platform/ui 0.0.6 → 0.0.7

package/dist/modules/agent/domain/chat-state.js

@@ -0,0 +1,148 @@
+function buildAssistantContent(text, toolCalls) {
+    const content = [];
+    if (text) {
+        content.push({ type: 'text', text });
+    }
+    for (const toolCall of toolCalls) {
+        content.push({ type: 'tool-call', toolCall });
+    }
+    return content;
+}
+function updateAssistantMessage(messages, assistantMessageId, update) {
+    const updated = [...messages];
+    const targetIndex = updated.findIndex((message) => message.id === assistantMessageId);
+    const existing = targetIndex >= 0 ? updated[targetIndex] : undefined;
+    if (!existing) {
+        return updated;
+    }
+    updated[targetIndex] = update(existing);
+    return updated;
+}
+function createUserMessage(id, text) {
+    return {
+        id,
+        role: 'user',
+        content: [{ type: 'text', text }],
+    };
+}
+function createAssistantStreamingMessage(id) {
+    return {
+        id,
+        role: 'assistant',
+        content: [],
+        isStreaming: true,
+    };
+}
+export function createInitialChatState() {
+    return {
+        messages: [],
+        threadId: null,
+        isLoading: false,
+        error: null,
+        pendingToolCalls: new Map(),
+    };
+}
+export function appendIntentText(current, intentMessage) {
+    if (!intentMessage.trim()) {
+        return current;
+    }
+    return current ? `${current}\n${intentMessage}` : intentMessage;
+}
+export function selectPendingToolCalls(state) {
+    return Array.from(state.pendingToolCalls.values());
+}
+export function chatStateReducer(state, action) {
+    switch (action.type) {
+        case 'START_CHAT': {
+            return {
+                ...state,
+                messages: [
+                    ...state.messages,
+                    createUserMessage(action.payload.userMessageId, action.payload.text),
+                    createAssistantStreamingMessage(action.payload.assistantMessageId),
+                ],
+                isLoading: true,
+                error: null,
+            };
+        }
+        case 'START_ASSISTANT_MESSAGE': {
+            return {
+                ...state,
+                messages: [
+                    ...state.messages,
+                    createAssistantStreamingMessage(action.payload.assistantMessageId),
+                ],
+            };
+        }
+        case 'UPDATE_ASSISTANT_PROGRESS': {
+            return {
+                ...state,
+                messages: updateAssistantMessage(state.messages, action.payload.assistantMessageId, (message) => ({
+                    id: message.id,
+                    role: message.role,
+                    content: buildAssistantContent(action.payload.text, action.payload.toolCalls),
+                    isStreaming: true,
+                })),
+            };
+        }
+        case 'FINISH_ASSISTANT_MESSAGE': {
+            return {
+                ...state,
+                messages: updateAssistantMessage(state.messages, action.payload.assistantMessageId, (message) => ({
+                    id: message.id,
+                    role: message.role,
+                    content: message.content,
+                    isStreaming: false,
+                })),
+            };
+        }
+        case 'UPSERT_TOOL_CALL_STATE': {
+            const nextPendingToolCalls = new Map(state.pendingToolCalls);
+            const current = nextPendingToolCalls.get(action.payload.toolCall.toolCallId);
+            if (current) {
+                nextPendingToolCalls.set(action.payload.toolCall.toolCallId, {
+                    ...current,
+                    status: action.payload.status,
+                    result: action.payload.result,
+                    error: action.payload.error,
+                });
+            }
+            else {
+                nextPendingToolCalls.set(action.payload.toolCall.toolCallId, {
+                    toolCall: action.payload.toolCall,
+                    status: action.payload.status,
+                    result: action.payload.result,
+                    error: action.payload.error,
+                });
+            }
+            return {
+                ...state,
+                pendingToolCalls: nextPendingToolCalls,
+            };
+        }
+        case 'SET_LOADING': {
+            return {
+                ...state,
+                isLoading: action.payload.isLoading,
+            };
+        }
+        case 'SET_ERROR': {
+            return {
+                ...state,
+                error: action.payload.error,
+            };
+        }
+        case 'SET_THREAD_ID': {
+            return {
+                ...state,
+                threadId: action.payload.threadId,
+            };
+        }
+        case 'RESET_CHAT': {
+            return createInitialChatState();
+        }
+        default: {
+            return state;
+        }
+    }
+}

package/dist/modules/agent/domain/chat-state.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/agent/domain/chat-state.test.js

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import { appendIntentText, chatStateReducer, createInitialChatState, selectPendingToolCalls, } from './chat-state';
+function buildToolCall(id) {
+    return {
+        toolCallId: id,
+        toolName: 'search',
+        input: { keyword: 'alice' },
+    };
+}
+describe('chatStateReducer', () => {
+    it('START_CHATでユーザーメッセージと空のassistantメッセージを追加する', () => {
+        const state = createInitialChatState();
+        const next = chatStateReducer(state, {
+            type: 'START_CHAT',
+            payload: {
+                userMessageId: 'user-1',
+                text: 'hello',
+                assistantMessageId: 'assistant-1',
+            },
+        });
+        expect(next.isLoading).toBe(true);
+        expect(next.error).toBeNull();
+        expect(next.messages).toHaveLength(2);
+        expect(next.messages[0]).toMatchObject({ id: 'user-1', role: 'user' });
+        expect(next.messages[1]).toMatchObject({ id: 'assistant-1', role: 'assistant', isStreaming: true });
+    });
+    it('UPSERT_TOOL_CALL_STATEでawaiting-approvalを含む状態遷移を更新できる', () => {
+        const toolCall = buildToolCall('tc-1');
+        const pending = chatStateReducer(createInitialChatState(), {
+            type: 'UPSERT_TOOL_CALL_STATE',
+            payload: { toolCall, status: 'pending' },
+        });
+        const awaitingApproval = chatStateReducer(pending, {
+            type: 'UPSERT_TOOL_CALL_STATE',
+            payload: { toolCall, status: 'awaiting-approval' },
+        });
+        const awaitingState = selectPendingToolCalls(awaitingApproval)[0];
+        expect(awaitingState?.status).toBe('awaiting-approval');
+        const executing = chatStateReducer(awaitingApproval, {
+            type: 'UPSERT_TOOL_CALL_STATE',
+            payload: { toolCall, status: 'executing' },
+        });
+        const completed = chatStateReducer(executing, {
+            type: 'UPSERT_TOOL_CALL_STATE',
+            payload: { toolCall, status: 'completed', result: { ok: true } },
+        });
+        const toolCallState = selectPendingToolCalls(completed)[0];
+        expect(toolCallState).toBeDefined();
+        expect(toolCallState?.status).toBe('completed');
+        expect(toolCallState?.result).toEqual({ ok: true });
+    });
+    it('RESET_CHATでSSOTを初期化する', () => {
+        const started = chatStateReducer(createInitialChatState(), {
+            type: 'START_CHAT',
+            payload: {
+                userMessageId: 'user-1',
+                text: 'hello',
+                assistantMessageId: 'assistant-1',
+            },
+        });
+        const next = chatStateReducer(started, { type: 'RESET_CHAT' });
+        expect(next).toEqual(createInitialChatState());
+    });
+});
+describe('appendIntentText', () => {
+    it('既存テキストの末尾にintentを改行付きで連結する', () => {
+        expect(appendIntentText('line1', 'line2')).toBe('line1\nline2');
+    });
+    it('intentが空文字の場合は既存テキストを返す', () => {
+        expect(appendIntentText('line1', '   ')).toBe('line1');
+    });
+});

package/dist/modules/agent/use-agent-chat.d.ts

@@ -0,0 +1,6 @@
+import type { AgentContextValue, ResolvedAgentRuntimeConfig } from '../../components/agent/provider/types';
+interface UseAgentChatOptions {
+    config: ResolvedAgentRuntimeConfig;
+}
+export declare function useAgentChat(options: UseAgentChatOptions): AgentContextValue;
+export {};

package/dist/modules/agent/use-agent-chat.js

@@ -0,0 +1,106 @@
+'use client';
+import { useCallback, useMemo, useReducer, useRef, useState } from 'react';
+import { createAgentRepository } from './agent.repository';
+import { chatStateReducer, createInitialChatState, selectPendingToolCalls, } from './domain/chat-state';
+import { sendMessageUseCase } from './usecases/send-message';
+export function useAgentChat(options) {
+    const { config } = options;
+    const { endpoint, apiBaseUrl, agentId, onError, authToken, getAuthToken, getAgentHeaders, disableToolApiAuthHeader, } = config;
+    const [state, dispatch] = useReducer(chatStateReducer, undefined, createInitialChatState);
+    const [activeApprovalRequest, setActiveApprovalRequest] = useState(null);
+    const abortControllerRef = useRef(null);
+    const approvalResolverRef = useRef(null);
+    const stateRef = useRef(state);
+    stateRef.current = state;
+    const settleApproval = useCallback((approved) => {
+        const resolver = approvalResolverRef.current;
+        if (!resolver) {
+            return;
+        }
+        approvalResolverRef.current = null;
+        setActiveApprovalRequest(null);
+        resolver(approved);
+    }, []);
+    const requestToolApproval = useCallback((toolCall) => {
+        if (approvalResolverRef.current) {
+            settleApproval(false);
+        }
+        const actionLabel = toolCall.apiRequest?.actionLabel?.trim() ||
+            `${toolCall.apiRequest?.method ?? ''} ${toolCall.apiRequest?.path ?? ''}`.trim() ||
+            toolCall.toolName;
+        const riskLevel = toolCall.apiRequest?.riskLevel ?? 'write';
+        setActiveApprovalRequest({
+            toolCall,
+            actionLabel,
+            riskLevel,
+        });
+        return new Promise((resolve) => {
+            approvalResolverRef.current = resolve;
+        });
+    }, [settleApproval]);
+    const approveToolCall = useCallback(() => {
+        settleApproval(true);
+    }, [settleApproval]);
+    const rejectToolCall = useCallback(() => {
+        settleApproval(false);
+    }, [settleApproval]);
+    const repository = useMemo(() => createAgentRepository({
+        authToken,
+        getAuthToken,
+        disableToolApiAuthHeader,
+    }), [authToken, getAuthToken, disableToolApiAuthHeader]);
+    const sendMessage = useCallback(async (message) => {
+        abortControllerRef.current = new AbortController();
+        try {
+            await sendMessageUseCase({
+                message,
+                repository,
+                dispatch,
+                getState: () => stateRef.current,
+                config: {
+                    endpoint,
+                    apiBaseUrl,
+                    agentId,
+                    getAgentHeaders,
+                    disableToolApiAuthHeader,
+                },
+                onError,
+                signal: abortControllerRef.current.signal,
+                requestToolApproval,
+            });
+        }
+        finally {
+            abortControllerRef.current = null;
+        }
+    }, [
+        repository,
+        endpoint,
+        apiBaseUrl,
+        agentId,
+        getAgentHeaders,
+        disableToolApiAuthHeader,
+        onError,
+        requestToolApproval,
+    ]);
+    const clearChat = useCallback(() => {
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+        }
+        settleApproval(false);
+        dispatch({ type: 'RESET_CHAT' });
+    }, [settleApproval]);
+    const pendingToolCalls = useMemo(() => selectPendingToolCalls(state), [state.pendingToolCalls, state]);
+    return {
+        messages: state.messages,
+        threadId: state.threadId,
+        isLoading: state.isLoading,
+        error: state.error,
+        pendingToolCalls,
+        activeApprovalRequest,
+        approveToolCall,
+        rejectToolCall,
+        sendMessage,
+        clearChat,
+        config,
+    };
+}

package/dist/modules/agent/usecases/process-stream.d.ts

@@ -0,0 +1,26 @@
+import type { AgentStreamEvent, ToolCallData } from '../../../components/agent/provider/types';
+import { type AgentChatAction, type AgentChatState } from '../domain/chat-state';
+export interface ProcessStreamEventsResult {
+    clientToolCalls: ToolCallData[];
+    clientToolResults: {
+        toolCallId: string;
+        result: unknown;
+        isError?: boolean;
+    }[];
+    progress: ProcessStreamProgress;
+}
+export interface ProcessStreamProgress {
+    accumulatedText: string;
+    toolCalls: ToolCallData[];
+    serverResolvedToolCallIds: Set<string>;
+}
+export interface ProcessStreamEventsInput {
+    events: AgentStreamEvent[];
+    assistantMessageId: string;
+    baseState: AgentChatState;
+    dispatch: (action: AgentChatAction) => void;
+    progress?: ProcessStreamProgress;
+    onError?: (errorMessage: string) => void;
+}
+export declare function createProcessStreamProgress(): ProcessStreamProgress;
+export declare function processStreamEvents(input: ProcessStreamEventsInput): ProcessStreamEventsResult;

package/dist/modules/agent/usecases/process-stream.js

@@ -0,0 +1,112 @@
+import { appendIntentText } from '../domain/chat-state';
+export function createProcessStreamProgress() {
+    return {
+        accumulatedText: '',
+        toolCalls: [],
+        serverResolvedToolCallIds: new Set(),
+    };
+}
+function normalizeErrorMessage(error) {
+    if (typeof error === 'string' && error.trim().length > 0) {
+        return error;
+    }
+    if (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof error.message === 'string') {
+        return error.message;
+    }
+    if (error !== undefined) {
+        try {
+            return JSON.stringify(error);
+        }
+        catch {
+            return String(error);
+        }
+    }
+    return 'Unknown error';
+}
+export function processStreamEvents(input) {
+    const { events, assistantMessageId, dispatch, onError } = input;
+    let accumulatedText = input.progress?.accumulatedText ?? '';
+    const toolCalls = input.progress ? [...input.progress.toolCalls] : [];
+    const serverResolvedToolCallIds = input.progress
+        ? new Set(input.progress.serverResolvedToolCallIds)
+        : new Set();
+    for (const event of events) {
+        switch (event.type) {
+            case 'thread-id': {
+                dispatch({ type: 'SET_THREAD_ID', payload: { threadId: event.payload.threadId } });
+                break;
+            }
+            case 'text-delta': {
+                accumulatedText += event.payload.text;
+                dispatch({
+                    type: 'UPDATE_ASSISTANT_PROGRESS',
+                    payload: { assistantMessageId, text: accumulatedText, toolCalls },
+                });
+                break;
+            }
+            case 'tool-intent': {
+                accumulatedText = appendIntentText(accumulatedText, event.payload.message);
+                dispatch({
+                    type: 'UPDATE_ASSISTANT_PROGRESS',
+                    payload: { assistantMessageId, text: accumulatedText, toolCalls },
+                });
+                break;
+            }
+            case 'tool-call': {
+                toolCalls.push(event.payload);
+                dispatch({
+                    type: 'UPSERT_TOOL_CALL_STATE',
+                    payload: {
+                        toolCall: event.payload,
+                        status: 'pending',
+                    },
+                });
+                dispatch({
+                    type: 'UPDATE_ASSISTANT_PROGRESS',
+                    payload: { assistantMessageId, text: accumulatedText, toolCalls },
+                });
+                break;
+            }
+            case 'tool-result': {
+                serverResolvedToolCallIds.add(event.payload.toolCallId);
+                const resolvedToolCall = toolCalls.find((toolCall) => toolCall.toolCallId === event.payload.toolCallId) ??
+                    input.baseState.pendingToolCalls.get(event.payload.toolCallId)?.toolCall;
+                if (!resolvedToolCall) {
+                    break;
+                }
+                dispatch({
+                    type: 'UPSERT_TOOL_CALL_STATE',
+                    payload: {
+                        toolCall: resolvedToolCall,
+                        status: event.payload.isError ? 'error' : 'completed',
+                        result: event.payload.result,
+                        error: event.payload.isError ? normalizeErrorMessage(event.payload.result) : undefined,
+                    },
+                });
+                break;
+            }
+            case 'finish': {
+                dispatch({ type: 'FINISH_ASSISTANT_MESSAGE', payload: { assistantMessageId } });
+                break;
+            }
+            case 'error': {
+                const errorMessage = normalizeErrorMessage(event.payload.error);
+                dispatch({ type: 'SET_ERROR', payload: { error: errorMessage } });
+                onError?.(errorMessage);
+                break;
+            }
+        }
+    }
+    return {
+        clientToolCalls: toolCalls.filter((toolCall) => !serverResolvedToolCallIds.has(toolCall.toolCallId)),
+        clientToolResults: [],
+        progress: {
+            accumulatedText,
+            toolCalls,
+            serverResolvedToolCallIds,
+        },
+    };
+}

package/dist/modules/agent/usecases/process-stream.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/agent/usecases/process-stream.test.js

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+import { createInitialChatState } from '../domain/chat-state';
+import { createProcessStreamProgress, processStreamEvents } from './process-stream';
+function buildToolCall(id) {
+    return {
+        toolCallId: id,
+        toolName: 'searchCandidates',
+        input: { keyword: 'alice' },
+    };
+}
+describe('processStreamEvents', () => {
+    it('tool-result未到達のtool-callをclientToolCallsとして返す', () => {
+        const toolCall = buildToolCall('tc-1');
+        const events = [
+            { type: 'text-delta', payload: { text: 'hello' } },
+            { type: 'tool-call', payload: toolCall },
+            { type: 'finish', payload: {} },
+        ];
+        const state = createInitialChatState();
+        const actions = [];
+        const result = processStreamEvents({
+            events,
+            assistantMessageId: 'assistant-1',
+            baseState: state,
+            dispatch: (action) => actions.push(action),
+        });
+        expect(actions.length).toBeGreaterThan(0);
+        expect(result.clientToolCalls).toEqual([toolCall]);
+        expect(result.clientToolResults).toEqual([]);
+    });
+    it('tool-result受領済みIDはclientToolCallsから除外する', () => {
+        const toolCall = buildToolCall('tc-1');
+        const events = [
+            { type: 'tool-call', payload: toolCall },
+            { type: 'tool-result', payload: { toolCallId: 'tc-1', result: { ok: true } } },
+            { type: 'finish', payload: {} },
+        ];
+        const result = processStreamEvents({
+            events,
+            assistantMessageId: 'assistant-1',
+            baseState: createInitialChatState(),
+            dispatch: () => undefined,
+        });
+        expect(result.clientToolCalls).toEqual([]);
+    });
+    it('progressを引き継いで複数チャンクのtext/tool-callを累積する', () => {
+        const toolCall = buildToolCall('tc-2');
+        const state = createInitialChatState();
+        const first = processStreamEvents({
+            events: [
+                { type: 'text-delta', payload: { text: 'hel' } },
+                { type: 'tool-call', payload: toolCall },
+            ],
+            assistantMessageId: 'assistant-1',
+            baseState: state,
+            dispatch: () => undefined,
+            progress: createProcessStreamProgress(),
+        });
+        const second = processStreamEvents({
+            events: [
+                { type: 'text-delta', payload: { text: 'lo' } },
+                { type: 'finish', payload: {} },
+            ],
+            assistantMessageId: 'assistant-1',
+            baseState: state,
+            dispatch: () => undefined,
+            progress: first.progress,
+        });
+        expect(second.progress.accumulatedText).toBe('hello');
+        expect(second.clientToolCalls).toEqual([toolCall]);
+    });
+    it('progressを引き継いだtool-result受領でclientToolCallsから除外される', () => {
+        const toolCall = buildToolCall('tc-3');
+        const state = createInitialChatState();
+        const first = processStreamEvents({
+            events: [{ type: 'tool-call', payload: toolCall }],
+            assistantMessageId: 'assistant-1',
+            baseState: state,
+            dispatch: () => undefined,
+            progress: createProcessStreamProgress(),
+        });
+        const second = processStreamEvents({
+            events: [{ type: 'tool-result', payload: { toolCallId: 'tc-3', result: { ok: true } } }],
+            assistantMessageId: 'assistant-1',
+            baseState: state,
+            dispatch: () => undefined,
+            progress: first.progress,
+        });
+        expect(second.clientToolCalls).toEqual([]);
+    });
+});

package/dist/modules/agent/usecases/send-message.d.ts

@@ -0,0 +1,21 @@
+import type { AgentHeadersProvider, ToolCallData } from '../../../components/agent/provider/types';
+import type { AgentRepository } from '../agent.repository';
+import type { AgentChatAction, AgentChatState } from '../domain/chat-state';
+export interface SendMessageUseCaseConfig {
+    endpoint: string;
+    apiBaseUrl: string;
+    agentId?: string;
+    disableToolApiAuthHeader?: boolean;
+    getAgentHeaders?: AgentHeadersProvider;
+}
+export interface SendMessageUseCaseInput {
+    message: string;
+    repository: AgentRepository;
+    dispatch: (action: AgentChatAction) => void;
+    getState: () => AgentChatState;
+    config: SendMessageUseCaseConfig;
+    onError?: (errorMessage: string) => void;
+    signal?: AbortSignal;
+    requestToolApproval?: (toolCall: ToolCallData) => Promise<boolean>;
+}
+export declare function sendMessageUseCase(input: SendMessageUseCaseInput): Promise<void>;