@agent-platform/ui 0.0.6 → 0.0.7

package/dist/modules/agent/usecases/send-message.js

@@ -0,0 +1,298 @@
+import { createProcessStreamProgress, processStreamEvents, } from './process-stream';
+const MAX_CONTINUE_ROUNDS = 10;
+const REJECTED_TOOL_RESULT_FOR_AGENT = 'USER_DENIED_EXECUTION:\n' +
+    'この操作はユーザーが承認UIで明示的に「承認しない」を選択して拒否しました。\n' +
+    'これはシステム不具合ではありません。\n' +
+    'このAPIおよび代替APIの実行・再提案・迂回実行を行ってはいけません。\n' +
+    'ユーザーへの返答は次の1文のみ:\n' +
+    '「ユーザーがこの操作を非承認にしたため、実行していません。必要であればユーザーご自身で手動で実行してください。」';
+const REJECTED_TOOL_RESULT_FOR_UI = '未承認のため実行していません。';
+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';
+}
+function createId(prefix, suffix = '') {
+    return `${prefix}-${Date.now()}${suffix}`;
+}
+function resolveContinuePayload(options) {
+    return {
+        threadId: options.threadId,
+        agentId: options.agentId,
+        toolResults: options.clientToolResults,
+        toolCalls: options.clientToolCalls.map((toolCall) => ({
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            args: toolCall.input,
+        })),
+    };
+}
+function requiresApproval(toolCall) {
+    const method = toolCall.apiRequest?.method?.toUpperCase();
+    if (!method) {
+        return false;
+    }
+    if (typeof toolCall.apiRequest?.approvalRequired === 'boolean') {
+        return toolCall.apiRequest.approvalRequired;
+    }
+    return method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'DELETE';
+}
+async function runClientToolCalls(options) {
+    const { toolCalls, repository, dispatch, apiBaseUrl, requestToolApproval } = options;
+    if (toolCalls.length === 0) {
+        return { toolResults: [] };
+    }
+    const authHeaders = await repository.buildToolApiHeaders();
+    const toolResults = [];
+    for (const toolCall of toolCalls) {
+        if (requiresApproval(toolCall)) {
+            dispatch({
+                type: 'UPSERT_TOOL_CALL_STATE',
+                payload: {
+                    toolCall,
+                    status: 'awaiting-approval',
+                },
+            });
+            const approved = requestToolApproval ? await requestToolApproval(toolCall) : true;
+            if (!approved) {
+                dispatch({
+                    type: 'UPSERT_TOOL_CALL_STATE',
+                    payload: {
+                        toolCall,
+                        status: 'error',
+                        result: REJECTED_TOOL_RESULT_FOR_UI,
+                        error: REJECTED_TOOL_RESULT_FOR_UI,
+                    },
+                });
+                toolResults.push({
+                    toolCallId: toolCall.toolCallId,
+                    result: REJECTED_TOOL_RESULT_FOR_AGENT,
+                    isError: true,
+                });
+                continue;
+            }
+        }
+        dispatch({
+            type: 'UPSERT_TOOL_CALL_STATE',
+            payload: {
+                toolCall,
+                status: 'executing',
+            },
+        });
+        try {
+            const executionResult = await repository.executeToolCall({
+                toolCall,
+                apiBaseUrl,
+                authHeaders,
+            });
+            const isError = executionResult.isError ?? false;
+            const error = isError ? normalizeErrorMessage(executionResult.output) : undefined;
+            dispatch({
+                type: 'UPSERT_TOOL_CALL_STATE',
+                payload: {
+                    toolCall,
+                    status: isError ? 'error' : 'completed',
+                    result: executionResult.output,
+                    error,
+                },
+            });
+            toolResults.push({
+                toolCallId: toolCall.toolCallId,
+                result: executionResult.output,
+                isError,
+            });
+        }
+        catch (error) {
+            const errorMessage = normalizeErrorMessage(error);
+            dispatch({
+                type: 'UPSERT_TOOL_CALL_STATE',
+                payload: {
+                    toolCall,
+                    status: 'error',
+                    error: errorMessage,
+                },
+            });
+            toolResults.push({
+                toolCallId: toolCall.toolCallId,
+                result: errorMessage,
+                isError: true,
+            });
+        }
+    }
+    return { toolResults };
+}
+async function collectAndProcessStream(options) {
+    let progress = createProcessStreamProgress();
+    let latestResult = {
+        clientToolCalls: [],
+        clientToolResults: [],
+        progress,
+    };
+    let processedBatchCount = 0;
+    const processEvents = (events) => {
+        if (events.length === 0) {
+            return;
+        }
+        processedBatchCount += 1;
+        const result = processStreamEvents({
+            events,
+            assistantMessageId: options.assistantMessageId,
+            baseState: options.getState(),
+            dispatch: options.dispatch,
+            onError: options.onError,
+            progress,
+        });
+        progress = result.progress;
+        latestResult = result;
+        for (const event of events) {
+            if (event.type === 'thread-id') {
+                options.onThreadId(event.payload.threadId);
+            }
+        }
+    };
+    const allEvents = await options.repository.collectStreamEvents(options.response, {
+        onEvents: processEvents,
+    });
+    if (allEvents.length > 0 && processedBatchCount === 0) {
+        processEvents(allEvents);
+    }
+    return {
+        clientToolCalls: latestResult.clientToolCalls,
+    };
+}
+export async function sendMessageUseCase(input) {
+    const state = input.getState();
+    const trimmedMessage = input.message.trim();
+    if (!trimmedMessage || state.isLoading) {
+        return;
+    }
+    const userMessageId = createId('user');
+    const assistantMessageId = createId('assistant');
+    const agentId = input.config.agentId ?? 'assistant';
+    let activeThreadId = state.threadId;
+    const handleError = (error) => {
+        const errorMessage = normalizeErrorMessage(error);
+        input.dispatch({ type: 'SET_ERROR', payload: { error: errorMessage } });
+        input.onError?.(errorMessage);
+    };
+    input.dispatch({
+        type: 'START_CHAT',
+        payload: {
+            userMessageId,
+            text: trimmedMessage,
+            assistantMessageId,
+        },
+    });
+    try {
+        const headers = await input.repository.buildAgentHeaders(input.config.getAgentHeaders);
+        const response = await input.repository.sendChat({
+            endpoint: input.config.endpoint,
+            threadId: state.threadId,
+            message: trimmedMessage,
+            agentId,
+            headers,
+            signal: input.signal,
+        });
+        if (!response.ok) {
+            const errorMessage = await input.repository.parseErrorResponse(response, 'Failed to send message');
+            throw new Error(errorMessage);
+        }
+        const firstResult = await collectAndProcessStream({
+            response,
+            repository: input.repository,
+            assistantMessageId,
+            getState: input.getState,
+            dispatch: input.dispatch,
+            onError: input.onError,
+            onThreadId: (threadId) => {
+                activeThreadId = threadId;
+            },
+        });
+        let currentToolCalls = firstResult.clientToolCalls;
+        let { toolResults } = await runClientToolCalls({
+            toolCalls: currentToolCalls,
+            repository: input.repository,
+            dispatch: input.dispatch,
+            apiBaseUrl: input.config.apiBaseUrl,
+            requestToolApproval: input.requestToolApproval,
+        });
+        let continueRound = 0;
+        let shouldContinue = toolResults.length > 0;
+        while (shouldContinue) {
+            continueRound += 1;
+            if (continueRound > MAX_CONTINUE_ROUNDS) {
+                handleError(`Tool execution loop exceeded maximum rounds (${MAX_CONTINUE_ROUNDS}).`);
+                break;
+            }
+            const continueMessageId = createId('assistant', `-${continueRound}`);
+            input.dispatch({
+                type: 'START_ASSISTANT_MESSAGE',
+                payload: { assistantMessageId: continueMessageId },
+            });
+            const continueHeaders = await input.repository.buildAgentHeaders(input.config.getAgentHeaders);
+            const continuePayload = resolveContinuePayload({
+                threadId: activeThreadId,
+                agentId,
+                clientToolResults: toolResults,
+                clientToolCalls: currentToolCalls,
+            });
+            const continueResponse = await input.repository.continueChat({
+                endpoint: input.config.endpoint,
+                payload: continuePayload,
+                headers: continueHeaders,
+                signal: input.signal,
+            });
+            if (!continueResponse.ok) {
+                const continueErrorText = await continueResponse
+                    .text()
+                    .catch(() => continueResponse.statusText);
+                throw new Error(`Failed to continue agent after tool execution: ${continueErrorText}`);
+            }
+            const continueResult = await collectAndProcessStream({
+                response: continueResponse,
+                repository: input.repository,
+                assistantMessageId: continueMessageId,
+                getState: input.getState,
+                dispatch: input.dispatch,
+                onError: input.onError,
+                onThreadId: (threadId) => {
+                    activeThreadId = threadId;
+                },
+            });
+            const toolExecution = await runClientToolCalls({
+                toolCalls: continueResult.clientToolCalls,
+                repository: input.repository,
+                dispatch: input.dispatch,
+                apiBaseUrl: input.config.apiBaseUrl,
+                requestToolApproval: input.requestToolApproval,
+            });
+            currentToolCalls = continueResult.clientToolCalls;
+            toolResults = toolExecution.toolResults;
+            shouldContinue = toolResults.length > 0;
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            return;
+        }
+        handleError(error);
+    }
+    finally {
+        input.dispatch({ type: 'SET_LOADING', payload: { isLoading: false } });
+    }
+}

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

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

package/dist/modules/agent/usecases/send-message.test.js

@@ -0,0 +1,257 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createInitialChatState } from '../domain/chat-state';
+import { sendMessageUseCase } from './send-message';
+function buildToolCall(id) {
+    return {
+        toolCallId: id,
+        toolName: 'searchCandidates',
+        input: { keyword: 'alice' },
+        apiRequest: {
+            method: 'GET',
+            path: '/candidates',
+            pathParams: [],
+            queryParams: ['keyword'],
+            bodyFields: [],
+            requiresAuth: true,
+            approvalRequired: false,
+            riskLevel: 'read',
+            actionLabel: '候補者検索',
+        },
+    };
+}
+function buildCreateScoutToolCall(id) {
+    return {
+        toolCallId: id,
+        toolName: 'createScout',
+        input: { candidateId: 'c-1', subject: 'ご提案', body: 'ご興味ありますか？' },
+        apiRequest: {
+            method: 'POST',
+            path: '/scouts',
+            pathParams: [],
+            queryParams: [],
+            bodyFields: ['candidateId', 'subject', 'body'],
+            requiresAuth: true,
+            approvalRequired: true,
+            riskLevel: 'write',
+            actionLabel: 'スカウト送信',
+        },
+    };
+}
+describe('sendMessageUseCase', () => {
+    it('MAX_CONTINUE_ROUNDSを超えるとonErrorを呼ぶ', async () => {
+        const toolCall = buildToolCall('tc-1');
+        const firstEvents = [
+            { type: 'tool-call', payload: toolCall },
+            { type: 'finish', payload: {} },
+        ];
+        const continueEvents = [
+            { type: 'tool-call', payload: toolCall },
+            { type: 'finish', payload: {} },
+        ];
+        const repository = {
+            sendChat: vi.fn().mockResolvedValue(new Response('ok')),
+            continueChat: vi.fn().mockResolvedValue(new Response('ok')),
+            collectStreamEvents: vi
+                .fn()
+                .mockResolvedValueOnce(firstEvents)
+                .mockResolvedValue(continueEvents),
+            executeToolCall: vi.fn().mockResolvedValue({ output: { ok: true } }),
+            parseErrorResponse: vi.fn().mockResolvedValue('error'),
+            buildAgentHeaders: vi.fn().mockResolvedValue({ 'Content-Type': 'application/json' }),
+            buildToolApiHeaders: vi.fn().mockReturnValue({}),
+        };
+        const onError = vi.fn();
+        const dispatch = vi.fn();
+        await sendMessageUseCase({
+            message: 'hello',
+            repository,
+            dispatch,
+            getState: () => createInitialChatState(),
+            config: {
+                endpoint: 'http://localhost:3002/api/agent',
+                apiBaseUrl: 'http://localhost:3001/api',
+                agentId: 'assistant',
+                disableToolApiAuthHeader: false,
+            },
+            onError,
+        });
+        expect(onError).toHaveBeenCalledWith(expect.stringContaining('Tool execution loop exceeded maximum rounds'));
+    });
+    it('collectStreamEvents完了前でも受信イベントをdispatchして進捗反映する', async () => {
+        const progressEvent = { type: 'text-delta', payload: { text: 'hi' } };
+        const finishEvent = { type: 'finish', payload: {} };
+        let resolveCollect = null;
+        const repository = {
+            sendChat: vi.fn().mockResolvedValue(new Response('ok')),
+            continueChat: vi.fn(),
+            collectStreamEvents: vi.fn().mockImplementation((_response, options) => {
+                options?.onEvents?.([progressEvent]);
+                return new Promise((resolve) => {
+                    resolveCollect = () => {
+                        options?.onEvents?.([finishEvent]);
+                        resolve([progressEvent, finishEvent]);
+                    };
+                });
+            }),
+            executeToolCall: vi.fn(),
+            parseErrorResponse: vi.fn(),
+            buildAgentHeaders: vi.fn().mockResolvedValue({ 'Content-Type': 'application/json' }),
+            buildToolApiHeaders: vi.fn().mockReturnValue({}),
+        };
+        const dispatch = vi.fn();
+        const runPromise = sendMessageUseCase({
+            message: 'hello',
+            repository,
+            dispatch,
+            getState: () => createInitialChatState(),
+            config: {
+                endpoint: 'http://localhost:3002/api/agent',
+                apiBaseUrl: 'http://localhost:3001/api',
+            },
+        });
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        const progressAction = dispatch.mock.calls
+            .map(([action]) => action)
+            .find((action) => action.type === 'UPDATE_ASSISTANT_PROGRESS');
+        expect(progressAction).toBeDefined();
+        if (!progressAction) {
+            throw new Error('Expected UPDATE_ASSISTANT_PROGRESS action');
+        }
+        expect(progressAction.payload.text).toBe('hi');
+        resolveCollect?.();
+        await runPromise;
+    });
+    it('変更系tool-callは承認後に実行される', async () => {
+        const toolCall = buildCreateScoutToolCall('tc-approval-1');
+        const firstEvents = [
+            { type: 'tool-call', payload: toolCall },
+            { type: 'finish', payload: {} },
+        ];
+        const continueEvents = [{ type: 'finish', payload: {} }];
+        const repository = {
+            sendChat: vi.fn().mockResolvedValue(new Response('ok')),
+            continueChat: vi.fn().mockResolvedValue(new Response('ok')),
+            collectStreamEvents: vi
+                .fn()
+                .mockResolvedValueOnce(firstEvents)
+                .mockResolvedValueOnce(continueEvents),
+            executeToolCall: vi.fn().mockResolvedValue({ output: { ok: true } }),
+            parseErrorResponse: vi.fn().mockResolvedValue('error'),
+            buildAgentHeaders: vi.fn().mockResolvedValue({ 'Content-Type': 'application/json' }),
+            buildToolApiHeaders: vi.fn().mockReturnValue({}),
+        };
+        const requestToolApproval = vi.fn().mockResolvedValue(true);
+        await sendMessageUseCase({
+            message: '送って',
+            repository,
+            dispatch: vi.fn(),
+            getState: () => createInitialChatState(),
+            config: {
+                endpoint: 'http://localhost:3002/api/agent',
+                apiBaseUrl: 'http://localhost:3001/api',
+            },
+            requestToolApproval,
+        });
+        expect(requestToolApproval).toHaveBeenCalledWith(toolCall);
+        expect(repository.executeToolCall).toHaveBeenCalledTimes(1);
+    });
+    it('変更系tool-callを拒否した場合は未実行で固定文言を返す', async () => {
+        const toolCall = buildCreateScoutToolCall('tc-approval-2');
+        const firstEvents = [
+            { type: 'tool-call', payload: toolCall },
+            { type: 'finish', payload: {} },
+        ];
+        const continueEvents = [{ type: 'finish', payload: {} }];
+        const continueChat = vi.fn().mockResolvedValue(new Response('ok'));
+        const repository = {
+            sendChat: vi.fn().mockResolvedValue(new Response('ok')),
+            continueChat,
+            collectStreamEvents: vi
+                .fn()
+                .mockResolvedValueOnce(firstEvents)
+                .mockResolvedValueOnce(continueEvents),
+            executeToolCall: vi.fn().mockResolvedValue({ output: { ok: true } }),
+            parseErrorResponse: vi.fn().mockResolvedValue('error'),
+            buildAgentHeaders: vi.fn().mockResolvedValue({ 'Content-Type': 'application/json' }),
+            buildToolApiHeaders: vi.fn().mockReturnValue({}),
+        };
+        await sendMessageUseCase({
+            message: '送って',
+            repository,
+            dispatch: vi.fn(),
+            getState: () => createInitialChatState(),
+            config: {
+                endpoint: 'http://localhost:3002/api/agent',
+                apiBaseUrl: 'http://localhost:3001/api',
+            },
+            requestToolApproval: vi.fn().mockResolvedValue(false),
+        });
+        expect(repository.executeToolCall).not.toHaveBeenCalled();
+        expect(continueChat).toHaveBeenCalledWith(expect.objectContaining({
+            payload: expect.objectContaining({
+                toolResults: [
+                    expect.objectContaining({
+                        toolCallId: 'tc-approval-2',
+                        isError: true,
+                        result: expect.stringContaining('USER_DENIED_EXECUTION'),
+                    }),
+                ],
+            }),
+        }));
+    });
+    it('同一ラウンドで一部拒否されても他のtool-callは続行する', async () => {
+        const rejectToolCall = buildCreateScoutToolCall('tc-approval-3');
+        const approveToolCall = buildCreateScoutToolCall('tc-approval-4');
+        approveToolCall.input = { candidateId: 'c-2', subject: '件名2', body: '本文2' };
+        const firstEvents = [
+            { type: 'tool-call', payload: rejectToolCall },
+            { type: 'tool-call', payload: approveToolCall },
+            { type: 'finish', payload: {} },
+        ];
+        const continueEvents = [{ type: 'finish', payload: {} }];
+        const continueChat = vi.fn().mockResolvedValue(new Response('ok'));
+        const executeToolCall = vi.fn().mockResolvedValue({ output: { ok: true } });
+        const repository = {
+            sendChat: vi.fn().mockResolvedValue(new Response('ok')),
+            continueChat,
+            collectStreamEvents: vi
+                .fn()
+                .mockResolvedValueOnce(firstEvents)
+                .mockResolvedValueOnce(continueEvents),
+            executeToolCall,
+            parseErrorResponse: vi.fn().mockResolvedValue('error'),
+            buildAgentHeaders: vi.fn().mockResolvedValue({ 'Content-Type': 'application/json' }),
+            buildToolApiHeaders: vi.fn().mockReturnValue({}),
+        };
+        const requestToolApproval = vi
+            .fn()
+            .mockResolvedValueOnce(false)
+            .mockResolvedValueOnce(true);
+        await sendMessageUseCase({
+            message: '送って',
+            repository,
+            dispatch: vi.fn(),
+            getState: () => createInitialChatState(),
+            config: {
+                endpoint: 'http://localhost:3002/api/agent',
+                apiBaseUrl: 'http://localhost:3001/api',
+            },
+            requestToolApproval,
+        });
+        expect(executeToolCall).toHaveBeenCalledTimes(1);
+        expect(continueChat).toHaveBeenCalledWith(expect.objectContaining({
+            payload: expect.objectContaining({
+                toolResults: expect.arrayContaining([
+                    expect.objectContaining({
+                        toolCallId: 'tc-approval-3',
+                        isError: true,
+                    }),
+                    expect.objectContaining({
+                        toolCallId: 'tc-approval-4',
+                        isError: false,
+                    }),
+                ]),
+            }),
+        }));
+    });
+});

package/dist/styles/globals.css

@@ -3,53 +3,6 @@
  * 消費側で @import "@agent-platform/ui/styles/globals.css" として使用
  * 注意: @import "tailwindcss" は消費側で行う
  */
-
-@custom-variant dark (&:is(.dark *));
-
-@theme inline {
-  --color-background: var(--background);
-  --color-foreground: var(--foreground);
-  --font-sans: var(--font-sans);
-  --font-mono: var(--font-geist-mono);
-  --color-sidebar-ring: var(--sidebar-ring);
-  --color-sidebar-border: var(--sidebar-border);
-  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
-  --color-sidebar-accent: var(--sidebar-accent);
-  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
-  --color-sidebar-primary: var(--sidebar-primary);
-  --color-sidebar-foreground: var(--sidebar-foreground);
-  --color-sidebar: var(--sidebar);
-  --color-chart-5: var(--chart-5);
-  --color-chart-4: var(--chart-4);
-  --color-chart-3: var(--chart-3);
-  --color-chart-2: var(--chart-2);
-  --color-chart-1: var(--chart-1);
-  --color-ring: var(--ring);
-  --color-input: var(--input);
-  --color-border: var(--border);
-  --color-destructive: var(--destructive);
-  --color-accent-foreground: var(--accent-foreground);
-  --color-accent: var(--accent);
-  --color-muted-foreground: var(--muted-foreground);
-  --color-muted: var(--muted);
-  --color-placeholder: var(--placeholder);
-  --color-secondary-foreground: var(--secondary-foreground);
-  --color-secondary: var(--secondary);
-  --color-primary-foreground: var(--primary-foreground);
-  --color-primary: var(--primary);
-  --color-popover-foreground: var(--popover-foreground);
-  --color-popover: var(--popover);
-  --color-card-foreground: var(--card-foreground);
-  --color-card: var(--card);
-  --radius-sm: calc(var(--radius) - 4px);
-  --radius-md: calc(var(--radius) - 2px);
-  --radius-lg: var(--radius);
-  --radius-xl: calc(var(--radius) + 4px);
-  --radius-2xl: calc(var(--radius) + 8px);
-  --radius-3xl: calc(var(--radius) + 12px);
-  --radius-4xl: calc(var(--radius) + 16px);
-}
-
 :root {
   --background: oklch(1 0 0);
   --foreground: oklch(0.145 0 0);
@@ -121,15 +74,6 @@
   --sidebar-ring: oklch(0.556 0 0);
 }
 
-@layer base {
-  * {
-    @apply border-border outline-ring/50;
-  }
-  body {
-    @apply bg-background text-foreground;
-  }
-}
-
 /* Custom animations for agent loading states */
 @layer utilities {
   @keyframes dot-fade {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-platform/ui",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "private": false,
   "type": "module",
   "sideEffects": false,
@@ -26,14 +26,12 @@
     "react-dom": "^19.0.0"
   },
   "dependencies": {
-    "@base-ui/react": "^1.0.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "radix-ui": "^1.4.3",
     "react-markdown": "^10.1.0",
     "remark-gfm": "^4.0.1",
-    "tailwind-merge": "^3.4.0",
-    "tw-animate-css": "^1.0.0"
+    "tailwind-merge": "^3.4.0"
   },
   "devDependencies": {
     "@phosphor-icons/react": "^2.1.10",
@@ -41,7 +39,6 @@
     "@types/react-dom": "^19",
     "react": "19.2.3",
     "react-dom": "19.2.3",
-    "shadcn": "^2.0.0",
     "typescript": "^5",
     "@agent-platform/server": "0.0.1"
   },
@@ -49,6 +46,7 @@
     "build": "pnpm run build:types && pnpm run build:styles",
     "build:types": "tsc -p tsconfig.build.json",
     "build:styles": "mkdir -p dist/styles && cp src/styles/globals.css dist/styles/globals.css",
+    "test": "pnpm -C ../server exec vitest --root ../ui",
     "typecheck": "tsc --noEmit",
     "pack:check": "pnpm pack",
     "publish:check-auth": "node ./scripts/check-publish-auth.mjs",