@agent-platform/ui 0.0.12 → 0.0.13

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

@@ -1,148 +0,0 @@
-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

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

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

@@ -1,72 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,106 +0,0 @@
-'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

@@ -1,26 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

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

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

@@ -1,91 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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>;