@runtypelabs/persona 3.21.3 → 3.22.0

package/src/session.test.ts

@@ -794,3 +794,261 @@ describe('AgentWidgetSession.resolveApproval', () => {
     expect(errors.length).toBe(1);
   });
 });
+
+describe('AgentWidgetSession - dispatch error fallback', () => {
+  const originalFetch = global.fetch;
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    vi.restoreAllMocks();
+  });
+
+  // Make fetch reject so client.dispatch throws and the session falls back.
+  const failFetchWith = (error: Error) => {
+    global.fetch = vi.fn().mockRejectedValue(error);
+  };
+
+  const lastAssistantMessage = (
+    session: AgentWidgetSession
+  ): AgentWidgetMessage | undefined =>
+    [...session.getMessages()].reverse().find((m) => m.role === 'assistant');
+
+  it('shows the default message with the underlying error detail and fires onError', async () => {
+    failFetchWith(new Error('Failed to fetch'));
+    const errors: Error[] = [];
+    const session = new AgentWidgetSession(
+      { apiUrl: 'http://example.invalid/chat' },
+      {
+        onMessagesChanged: () => {},
+        onStatusChanged: () => {},
+        onStreamingChanged: () => {},
+        onError: (e) => errors.push(e),
+      }
+    );
+
+    await session.sendMessage('Hello');
+
+    const assistant = lastAssistantMessage(session);
+    expect(assistant?.content).toContain("I couldn't reach the assistant");
+    expect(assistant?.content).toContain('_Details: Failed to fetch_');
+    expect(errors).toHaveLength(1);
+    expect(errors[0].message).toBe('Failed to fetch');
+    expect(session.isStreaming()).toBe(false);
+    expect(session.getStatus()).toBe('idle');
+  });
+
+  it('uses a static errorMessage override verbatim', async () => {
+    failFetchWith(new Error('boom'));
+    const session = new AgentWidgetSession(
+      {
+        apiUrl: 'http://example.invalid/chat',
+        errorMessage: 'We are having trouble connecting.',
+      },
+      {
+        onMessagesChanged: () => {},
+        onStatusChanged: () => {},
+        onStreamingChanged: () => {},
+      }
+    );
+
+    await session.sendMessage('Hello');
+
+    const assistant = lastAssistantMessage(session);
+    expect(assistant?.content).toBe('We are having trouble connecting.');
+    expect(assistant?.content).not.toContain('Details');
+  });
+
+  it('passes the error to a function errorMessage override', async () => {
+    failFetchWith(new Error('Failed to fetch'));
+    const seen: Error[] = [];
+    const session = new AgentWidgetSession(
+      {
+        apiUrl: 'http://example.invalid/chat',
+        errorMessage: (error) => {
+          seen.push(error);
+          return error.message.includes('Failed to fetch')
+            ? 'You appear to be offline.'
+            : 'Something went wrong.';
+        },
+      },
+      {
+        onMessagesChanged: () => {},
+        onStatusChanged: () => {},
+        onStreamingChanged: () => {},
+      }
+    );
+
+    await session.sendMessage('Hello');
+
+    expect(seen).toHaveLength(1);
+    expect(seen[0]).toBeInstanceOf(Error);
+    expect(lastAssistantMessage(session)?.content).toBe(
+      'You appear to be offline.'
+    );
+  });
+
+  it('suppresses the fallback bubble when the override returns an empty string but still fires onError', async () => {
+    failFetchWith(new Error('boom'));
+    const errors: Error[] = [];
+    const session = new AgentWidgetSession(
+      {
+        apiUrl: 'http://example.invalid/chat',
+        errorMessage: () => '',
+      },
+      {
+        onMessagesChanged: () => {},
+        onStatusChanged: () => {},
+        onStreamingChanged: () => {},
+        onError: (e) => errors.push(e),
+      }
+    );
+
+    await session.sendMessage('Hello');
+
+    expect(lastAssistantMessage(session)).toBeUndefined();
+    expect(errors).toHaveLength(1);
+    expect(session.isStreaming()).toBe(false);
+    expect(session.getStatus()).toBe('idle');
+  });
+
+  it('does NOT show a fallback bubble when the dispatch is aborted', async () => {
+    const abortErr = new Error('The operation was aborted');
+    abortErr.name = 'AbortError';
+    failFetchWith(abortErr);
+    const errors: Error[] = [];
+    const session = new AgentWidgetSession(
+      { apiUrl: 'http://example.invalid/chat' },
+      {
+        onMessagesChanged: () => {},
+        onStatusChanged: () => {},
+        onStreamingChanged: () => {},
+        onError: (e) => errors.push(e),
+      }
+    );
+
+    await session.sendMessage('Hello');
+
+    expect(lastAssistantMessage(session)).toBeUndefined();
+    expect(errors).toHaveLength(0);
+  });
+
+  it('applies the override on continueConversation failures too', async () => {
+    failFetchWith(new Error('boom'));
+    const session = new AgentWidgetSession(
+      {
+        apiUrl: 'http://example.invalid/chat',
+        errorMessage: 'Custom continue error.',
+      },
+      {
+        onMessagesChanged: () => {},
+        onStatusChanged: () => {},
+        onStreamingChanged: () => {},
+      }
+    );
+
+    await session.continueConversation();
+
+    expect(lastAssistantMessage(session)?.content).toBe('Custom continue error.');
+  });
+});
+
+describe('AgentWidgetSession - WebMCP native approval gate', () => {
+  const makeSession = (
+    webmcp?: Record<string, unknown>
+  ): { session: AgentWidgetSession; getMessages: () => AgentWidgetMessage[] } => {
+    let messages: AgentWidgetMessage[] = [];
+    const session = new AgentWidgetSession(
+      { apiUrl: 'http://localhost:8000', webmcp: { enabled: true, ...webmcp } },
+      {
+        onMessagesChanged: (msgs) => { messages = msgs; },
+        onStatusChanged: () => {},
+        onStreamingChanged: () => {},
+      }
+    );
+    return { session, getMessages: () => messages };
+  };
+
+  it('renders a pending approval bubble and resolves true on approve', async () => {
+    const { session, getMessages } = makeSession();
+    const promise = session.requestWebMcpApproval({
+      toolName: 'add_to_cart',
+      args: { sku: 'SHOE-001' },
+      reason: 'gate',
+    });
+
+    const bubble = getMessages().find((m) => m.variant === 'approval');
+    expect(bubble).toBeDefined();
+    expect(bubble?.approval?.status).toBe('pending');
+    expect(bubble?.approval?.toolType).toBe('webmcp');
+    expect(bubble?.approval?.toolName).toBe('add_to_cart');
+    expect(bubble?.approval?.parameters).toEqual({ sku: 'SHOE-001' });
+
+    session.resolveWebMcpApproval(bubble!.id, 'approved');
+    await expect(promise).resolves.toBe(true);
+
+    const resolved = getMessages().find((m) => m.variant === 'approval');
+    expect(resolved?.approval?.status).toBe('approved');
+    expect(resolved?.approval?.resolvedAt).toBeDefined();
+  });
+
+  it('resolves false on deny and marks the bubble denied', async () => {
+    const { session, getMessages } = makeSession();
+    const promise = session.requestWebMcpApproval({
+      toolName: 'add_to_cart',
+      args: { sku: 'SHOE-002' },
+      reason: 'gate',
+    });
+    const bubble = getMessages().find((m) => m.variant === 'approval');
+
+    session.resolveWebMcpApproval(bubble!.id, 'denied');
+    await expect(promise).resolves.toBe(false);
+    expect(
+      getMessages().find((m) => m.variant === 'approval')?.approval?.status
+    ).toBe('denied');
+  });
+
+  it('auto-approves (no bubble) when autoApprove returns true', async () => {
+    const { session, getMessages } = makeSession({
+      autoApprove: (info: { toolName: string }) => info.toolName !== 'add_to_cart',
+    });
+
+    await expect(
+      session.requestWebMcpApproval({
+        toolName: 'search_products',
+        args: { query: 'shoes' },
+        reason: 'gate',
+      })
+    ).resolves.toBe(true);
+    // No approval bubble for an auto-approved (read-only) call.
+    expect(getMessages().some((m) => m.variant === 'approval')).toBe(false);
+  });
+
+  it('still gates a mutating tool when autoApprove excludes it', () => {
+    const { session, getMessages } = makeSession({
+      autoApprove: (info: { toolName: string }) => info.toolName !== 'add_to_cart',
+    });
+    void session.requestWebMcpApproval({
+      toolName: 'add_to_cart',
+      args: { sku: 'SHOE-001' },
+      reason: 'gate',
+    });
+    expect(getMessages().some((m) => m.variant === 'approval')).toBe(true);
+  });
+
+  it('treats a second resolve as a no-op', async () => {
+    const { session, getMessages } = makeSession();
+    const promise = session.requestWebMcpApproval({
+      toolName: 'add_to_cart',
+      args: {},
+      reason: 'gate',
+    });
+    const bubble = getMessages().find((m) => m.variant === 'approval');
+    session.resolveWebMcpApproval(bubble!.id, 'approved');
+    // Second call must not throw or flip the resolved status.
+    expect(() => session.resolveWebMcpApproval(bubble!.id, 'denied')).not.toThrow();
+    await expect(promise).resolves.toBe(true);
+    expect(
+      getMessages().find((m) => m.variant === 'approval')?.approval?.status
+    ).toBe('approved');
+  });
+});