fix(web-ui): harden streamed params and pet activity

Author: limityan

src/web-ui/src/flow_chat/services/AgentCompanionActivityBridge.test.ts

@@ -0,0 +1,65 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { AgentCompanionActivityPayload } from '../utils/agentCompanionActivity';
+import { emitAgentCompanionActivity } from './AgentCompanionActivityBridge';
+
+const tauriEvent = vi.hoisted(() => ({
+  emit: vi.fn(),
+}));
+
+vi.mock('@tauri-apps/api/event', () => ({
+  emit: tauriEvent.emit,
+}));
+
+vi.mock('@/infrastructure/runtime', () => ({
+  isTauriRuntime: () => true,
+}));
+
+function hasLoneSurrogate(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 0xdc00 && next <= 0xdfff)) {
+        return true;
+      }
+      index += 1;
+      continue;
+    }
+    if (code >= 0xdc00 && code <= 0xdfff) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+describe('emitAgentCompanionActivity', () => {
+  afterEach(() => {
+    tauriEvent.emit.mockReset();
+  });
+
+  it('normalizes activity strings before crossing the desktop event boundary', async () => {
+    await emitAgentCompanionActivity({
+      mood: 'working',
+      tasks: [{
+        sessionId: 'session-\uD800',
+        title: 'Broken \uD800 title',
+        mood: 'working',
+        state: 'running',
+        labelKey: 'agentCompanion.activity.working',
+        defaultLabel: 'Working \uDC00',
+        latestOutput: 'Output \uD800',
+        startedAt: 1000,
+        updatedAt: 1200,
+      }],
+    });
+
+    const emittedActivity = tauriEvent.emit.mock.calls[0]?.[1] as AgentCompanionActivityPayload;
+
+    expect(tauriEvent.emit).toHaveBeenCalledWith('agent-companion://activity-updated', expect.any(Object));
+    expect(hasLoneSurrogate(emittedActivity.tasks[0].sessionId)).toBe(false);
+    expect(hasLoneSurrogate(emittedActivity.tasks[0].title)).toBe(false);
+    expect(hasLoneSurrogate(emittedActivity.tasks[0].defaultLabel)).toBe(false);
+    expect(hasLoneSurrogate(emittedActivity.tasks[0].latestOutput!)).toBe(false);
+  });
+});

src/web-ui/src/flow_chat/services/AgentCompanionActivityBridge.ts

@@ -1,17 +1,36 @@
 import { isTauriRuntime } from '@/infrastructure/runtime';
 import { createLogger } from '@/shared/utils/logger';
-import type { AgentCompanionActivityPayload } from '../utils/agentCompanionActivity';
+import { toWellFormedText } from '@/shared/utils/wellFormedText';
+import type { AgentCompanionActivityPayload, AgentCompanionTaskStatus } from '../utils/agentCompanionActivity';
 
 const log = createLogger('AgentCompanionActivityBridge');
 let activitySequence = 0;
 
+function sanitizeTaskForEmit(task: AgentCompanionTaskStatus): AgentCompanionTaskStatus {
+  return {
+    ...task,
+    sessionId: toWellFormedText(task.sessionId),
+    title: toWellFormedText(task.title),
+    labelKey: toWellFormedText(task.labelKey),
+    defaultLabel: toWellFormedText(task.defaultLabel),
+    latestOutput: task.latestOutput === undefined ? undefined : toWellFormedText(task.latestOutput),
+  };
+}
+
+function sanitizeActivityForEmit(activity: AgentCompanionActivityPayload): AgentCompanionActivityPayload {
+  return {
+    ...activity,
+    tasks: activity.tasks.map(sanitizeTaskForEmit),
+  };
+}
+
 export async function emitAgentCompanionActivity(
   activity: AgentCompanionActivityPayload,
 ): Promise<void> {
   if (!isTauriRuntime()) return;
 
   const sequencedActivity: AgentCompanionActivityPayload = {
-    ...activity,
+    ...sanitizeActivityForEmit(activity),
     sequence: activitySequence += 1,
     emittedAt: Date.now(),
   };

src/web-ui/src/flow_chat/services/EventBatcher.ts

@@ -214,6 +214,10 @@ export interface ParamsPartialToolEvent extends BaseToolEvent<'ParamsPartial'> {
   params: string;
 }
 
+export function normalizeParamsPartialFragment(params: unknown): string {
+  return typeof params === 'string' ? params : '';
+}
+
 export interface QueuedToolEvent extends BaseToolEvent<'Queued'> {
   position: number;
 }

src/web-ui/src/flow_chat/services/flow-chat-manager/EventHandlerModule.ts

@@ -10,6 +10,7 @@ import { agenticEventListener, type AgenticEventCallbacks } from '../AgenticEven
 import { 
   generateTextChunkKey, 
   generateToolEventKey,
+  normalizeParamsPartialFragment,
   parseEventKey,
   type FlowToolEvent,
   type SubagentParentInfo,
@@ -1573,8 +1574,8 @@ function handleToolEvent(
           toolEvent: {
             ...(existing.toolEvent as ParamsPartialToolEvent),
             params:
-              (existing.toolEvent as ParamsPartialToolEvent).params +
-              (incoming.toolEvent as ParamsPartialToolEvent).params
+              normalizeParamsPartialFragment((existing.toolEvent as ParamsPartialToolEvent).params) +
+              normalizeParamsPartialFragment((incoming.toolEvent as ParamsPartialToolEvent).params)
           }
         })
       );

src/web-ui/src/flow_chat/services/flow-chat-manager/ToolEventModule.test.ts

@@ -0,0 +1,92 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { FlowChatStore } from '../../store/FlowChatStore';
+import type { DialogTurn, FlowToolItem, ModelRound, Session } from '../../types/flow-chat';
+import { processToolParamsPartialInternal } from './ToolEventModule';
+
+function resetStore(): void {
+  FlowChatStore.getInstance().setState(() => ({
+    sessions: new Map(),
+    activeSessionId: null,
+  }));
+}
+
+function createSessionWithTool(tool: FlowToolItem): Session {
+  const round: ModelRound = {
+    id: 'round-1',
+    index: 0,
+    items: [tool],
+    isStreaming: true,
+    isComplete: false,
+    status: 'streaming',
+    startTime: 1000,
+  };
+  const turn: DialogTurn = {
+    id: 'turn-1',
+    sessionId: 'session-1',
+    userMessage: {
+      id: 'user-1',
+      content: 'Inspect this file',
+      timestamp: 900,
+    },
+    modelRounds: [round],
+    status: 'processing',
+    startTime: 900,
+  };
+
+  return {
+    sessionId: 'session-1',
+    title: 'Session 1',
+    dialogTurns: [turn],
+    status: 'active',
+    config: { agentType: 'agentic' },
+    createdAt: 800,
+    lastActiveAt: 1000,
+    error: null,
+    sessionKind: 'normal',
+  };
+}
+
+describe('processToolParamsPartialInternal', () => {
+  afterEach(() => {
+    resetStore();
+  });
+
+  it('drops malformed non-string params fragments without replacing existing preview state', () => {
+    const existingParams = { file_path: 'src/main.rs' };
+    const tool: FlowToolItem = {
+      id: 'tool-1',
+      type: 'tool',
+      toolName: 'Read',
+      timestamp: 1001,
+      status: 'streaming',
+      toolCall: {
+        id: 'tool-1',
+        input: existingParams,
+      },
+      isParamsStreaming: true,
+      partialParams: existingParams,
+      _paramsBuffer: '{"file_path":"src/main.rs"}',
+    };
+
+    FlowChatStore.getInstance().setState(() => ({
+      sessions: new Map([['session-1', createSessionWithTool(tool)]]),
+      activeSessionId: 'session-1',
+    }));
+
+    expect(() => {
+      processToolParamsPartialInternal('session-1', 'turn-1', {
+        event_type: 'ParamsPartial',
+        tool_id: 'tool-1',
+        tool_name: 'Read',
+        params: { file_path: 'src/lib.rs' } as any,
+      });
+    }).not.toThrow();
+
+    const updatedTool = FlowChatStore.getInstance()
+      .findToolItem('session-1', 'turn-1', 'tool-1') as FlowToolItem;
+
+    expect(updatedTool._paramsBuffer).toBe('{"file_path":"src/main.rs"}');
+    expect(updatedTool.partialParams).toEqual(existingParams);
+    expect(updatedTool.toolCall.input).toEqual(existingParams);
+  });
+});

src/web-ui/src/flow_chat/services/flow-chat-manager/ToolEventModule.ts

@@ -9,6 +9,7 @@ import { createLogger } from '@/shared/utils/logger';
 import type { FlowChatContext, FlowToolItem, ToolEventOptions, DialogTurn } from './types';
 import { immediateSaveDialogTurn } from './PersistenceModule';
 import { applyPendingAcpPermissionForTool } from './AcpPermissionToolCardModule';
+import { normalizeParamsPartialFragment } from '../EventBatcher';
 import type {
   CancelledToolEvent,
   CompletedToolEvent,
@@ -180,7 +181,10 @@ function applyParamsPartial(
       return;
     }
 
-    const incomingParams = toolEvent.params || '';
+    const incomingParams = normalizeParamsPartialFragment(toolEvent.params);
+    if (!incomingParams) {
+      return;
+    }
     const isWriteFullParamsSnapshot = isWriteTool && incomingParams.trimStart().startsWith('{');
     const newBuffer = isWriteFullParamsSnapshot ? incomingParams : prevBuffer + incomingParams;
 

src/web-ui/src/flow_chat/utils/agentCompanionActivity.test.ts

@@ -5,6 +5,25 @@ import { ProcessingPhase, SessionExecutionEvent, SessionExecutionState } from '.
 import type { DialogTurn, Session } from '../types/flow-chat';
 import { buildAgentCompanionActivity } from './agentCompanionActivity';
 
+function hasLoneSurrogate(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 0xdc00 && next <= 0xdfff)) {
+        return true;
+      }
+      index += 1;
+      continue;
+    }
+    if (code >= 0xdc00 && code <= 0xdfff) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 function resetState(): void {
   flowChatStore.setState(() => ({
     sessions: new Map(),
@@ -166,6 +185,20 @@ describe('buildAgentCompanionActivity', () => {
     expect(activity.tasks[0].latestOutput?.endsWith('...')).toBe(false);
   });
 
+  it('keeps truncated latest output well-formed for desktop pet events', async () => {
+    const content = '\uD83D\uDE00' + 'a'.repeat(511);
+    flowChatStore.setState(() => ({
+      sessions: new Map([['session-1', createStreamingSessionWithText(content)]]),
+      activeSessionId: 'session-1',
+    }));
+    await putStateMachineInStreaming();
+
+    const latestOutput = buildAgentCompanionActivity().tasks[0].latestOutput;
+
+    expect(latestOutput).toBeDefined();
+    expect(hasLoneSurrogate(latestOutput!)).toBe(false);
+  });
+
   it('keeps the final assistant output visible after completion', () => {
     const finalText = 'Final analysis summary remains visible in the companion bubble.';
     flowChatStore.setState(() => ({

src/web-ui/src/flow_chat/utils/agentCompanionActivity.ts

@@ -3,6 +3,7 @@ import { stateMachineManager } from '../state-machine/SessionStateMachineManager
 import { ProcessingPhase, type SessionStateMachine } from '../state-machine/types';
 import { deriveChatInputPetMood, type ChatInputPetMood } from './chatInputPetMood';
 import type { DialogTurn, FlowTextItem, FlowThinkingItem, Session } from '../types/flow-chat';
+import { toWellFormedText } from '@/shared/utils/wellFormedText';
 
 export type AgentCompanionTaskState =
   | 'running'
@@ -69,7 +70,7 @@ function pruneTaskOrder(activeTasks: AgentCompanionTaskStatus[]): void {
 }
 
 function sessionTitle(session: Session): string {
-  return session.title?.trim() || 'Session';
+  return toWellFormedText(session.title?.trim() || 'Session');
 }
 
 function markdownToPlainText(markdown: string): string {
@@ -89,11 +90,12 @@ function markdownToPlainText(markdown: string): string {
 }
 
 function truncateLatestOutput(text: string): string {
-  if (text.length <= LATEST_OUTPUT_MAX_CHARS) {
-    return text;
+  const wellFormedText = toWellFormedText(text);
+  if (wellFormedText.length <= LATEST_OUTPUT_MAX_CHARS) {
+    return wellFormedText;
   }
 
-  return text.slice(-LATEST_OUTPUT_MAX_CHARS);
+  return toWellFormedText(wellFormedText.slice(-LATEST_OUTPUT_MAX_CHARS));
 }
 
 function latestAssistantSnippet(turn: DialogTurn | undefined): string | undefined {

src/web-ui/src/shared/utils/partialJsonParser.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+import {
+  getFirstAvailableField,
+  isFieldComplete,
+  parsePartialJson,
+} from './partialJsonParser';
+
+describe('partialJsonParser', () => {
+  it('treats non-object partial fragments as empty params', () => {
+    const partialString = '"from';
+
+    expect(parsePartialJson(partialString)).toEqual({});
+    expect(isFieldComplete(partialString, 'content')).toBe(false);
+    expect(getFirstAvailableField(partialString, ['content', 'contents'])).toBeUndefined();
+  });
+
+  it('treats valid non-object JSON values as empty params', () => {
+    expect(parsePartialJson('["content"]')).toEqual({});
+    expect(parsePartialJson('true')).toEqual({});
+    expect(parsePartialJson('42')).toEqual({});
+  });
+
+  it('treats non-string parser input as empty params', () => {
+    expect(parsePartialJson({ content: 'not a JSON string' } as any)).toEqual({});
+  });
+});