@puredesktop/puredesktop-ui-bridge 1.0.0-beta.1 → 1.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@puredesktop/puredesktop-ui-bridge",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.2",
   "description": "PureScience plugin SDK — bridge client, theme, and shared UI",
   "type": "module",
   "repository": {
@@ -20,6 +20,7 @@
     "./bridge/client": "./src/bridge/client.mjs",
     "./bridge/events": "./src/bridge/events.mjs",
     "./bridge/methods": "./src/bridge/methods.mjs",
+    "./bridge/vision": "./src/bridge/vision.mjs",
     "./bridge/react/usePlatformBridge": "./src/bridge/react/usePlatformBridge.tsx",
     "./bridge/react/useIpc": "./src/bridge/react/useIpc.tsx",
     "./bridge/react/usePlatformViewportResource": "./src/bridge/react/usePlatformViewportResource.tsx",
@@ -75,12 +76,13 @@
   },
   "dependencies": {
     "@ant-design/icons": "^6.0.0",
+    "@lobehub/icons-static-svg": "^1.91.0",
     "d3": "^7.9.0",
     "katex": "^0.16.22",
     "lucide-react": "^0.511.0",
     "mermaid": "^11.15.0",
     "styled-components": "^6.1.18",
-    "@puredesktop/platform-editor": "1.0.0-beta.1"
+    "@puredesktop/platform-editor": "1.0.0-beta.2"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/agents/appAgentConnectors.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+import {
+  PURE_APP_AGENT_CONNECTOR_HANDLES,
+  findPureAppAgentConnector,
+} from './appAgentConnectors.js'
+
+describe('Pure app agent connectors', () => {
+  it('includes the app handles PureTeams can route to', () => {
+    expect(PURE_APP_AGENT_CONNECTOR_HANDLES).toEqual(
+      expect.arrayContaining([
+        'assistant',
+        'teams',
+        'knowledge',
+        'know',
+        'research',
+        'writer',
+        'review',
+        'tasks',
+        'files',
+        'people',
+        'plan',
+        'pages',
+        'chart',
+        'reports',
+        'slides',
+        'book',
+        'manuscript',
+      ]),
+    )
+  })
+
+  it('resolves aliases to the same connector', () => {
+    expect(findPureAppAgentConnector('know')?.appSlug).toBe('knowledge')
+    expect(findPureAppAgentConnector('purefiles')?.handle).toBe('files')
+    expect(findPureAppAgentConnector('slides2')?.handle).toBe('slides')
+  })
+})

package/src/agents/appAgentConnectors.ts

@@ -0,0 +1,138 @@
+export interface PureAppAgentConnector {
+  handle: string
+  appSlug: string
+  label: string
+  description: string
+  aliases?: readonly string[]
+}
+
+export const PURE_APP_AGENT_CONNECTORS: readonly PureAppAgentConnector[] = [
+  {
+    handle: 'assistant',
+    appSlug: 'assistant',
+    label: 'PureDesktop assistant',
+    description: 'Default desktop assistant requests and general follow-up.',
+  },
+  {
+    handle: 'teams',
+    appSlug: 'teams',
+    label: 'Teams',
+    description: 'Coordination, requests, handoffs, and team knowledge.',
+  },
+  {
+    handle: 'knowledge',
+    appSlug: 'knowledge',
+    label: 'Knowledge',
+    description: 'Knowledge-base, wiki, and reusable memory requests.',
+    aliases: ['know'],
+  },
+  {
+    handle: 'research',
+    appSlug: 'research',
+    label: 'Research',
+    description: 'Dossiers, evidence gathering, and research passes.',
+  },
+  {
+    handle: 'writer',
+    appSlug: 'writer',
+    label: 'Writer',
+    description: 'Drafting, editing, and document-writing requests.',
+  },
+  {
+    handle: 'review',
+    appSlug: 'review',
+    label: 'Review',
+    description: 'Review, proofing, and suggested-change requests.',
+  },
+  {
+    handle: 'tasks',
+    appSlug: 'tasks',
+    label: 'Tasks',
+    description: 'Task boards, task updates, and project follow-up.',
+  },
+  {
+    handle: 'files',
+    appSlug: 'purefiles',
+    label: 'Files',
+    description: 'File lookup, file organization, and document handoff.',
+    aliases: ['purefiles'],
+  },
+  {
+    handle: 'people',
+    appSlug: 'people',
+    label: 'People',
+    description: 'Contacts, relationships, and people-memory requests.',
+  },
+  {
+    handle: 'plan',
+    appSlug: 'plan',
+    label: 'Plan',
+    description: 'Plans, briefs, and planning activity.',
+  },
+  {
+    handle: 'pages',
+    appSlug: 'pages',
+    label: 'Pages',
+    description: 'Page layout and publishing requests.',
+  },
+  {
+    handle: 'chart',
+    appSlug: 'chart',
+    label: 'Chart',
+    description: 'Charts, data visualization, and chart annotations.',
+  },
+  {
+    handle: 'reports',
+    appSlug: 'reports',
+    label: 'Reports',
+    description: 'Reports, sources, and structured report blocks.',
+  },
+  {
+    handle: 'slides',
+    appSlug: 'slides',
+    label: 'Slides',
+    description: 'Deck reading, slide edits, and presentation writing.',
+    aliases: ['slides2'],
+  },
+  {
+    handle: 'book',
+    appSlug: 'book',
+    label: 'Book',
+    description: 'Books, chapters, accessibility review, and print styles.',
+  },
+  {
+    handle: 'manuscript',
+    appSlug: 'manuscript',
+    label: 'Manuscript',
+    description: 'Manuscripts, references, authors, and export readiness.',
+  },
+  {
+    handle: 'chat',
+    appSlug: 'chat',
+    label: 'Chat',
+    description: 'Conversation and message-context requests.',
+  },
+  {
+    handle: 'vibes',
+    appSlug: 'vibes',
+    label: 'Vibes',
+    description: 'Vibe and presentation-context requests.',
+  },
+] as const
+
+export const PURE_APP_AGENT_CONNECTOR_HANDLES =
+  PURE_APP_AGENT_CONNECTORS.flatMap(connector => [
+    connector.handle,
+    ...(connector.aliases ?? []),
+  ]).sort((left, right) => left.localeCompare(right))
+
+export function findPureAppAgentConnector(
+  handle: string,
+): PureAppAgentConnector | undefined {
+  const normalized = handle.trim().toLowerCase()
+  return PURE_APP_AGENT_CONNECTORS.find(
+    connector =>
+      connector.handle === normalized ||
+      Boolean(connector.aliases?.includes(normalized)),
+  )
+}

package/src/agents/runtime/agentLiveReducer.test.ts

@@ -1,72 +1,72 @@
-import { describe, expect, it } from 'vitest'
-import { AgentLivePhase } from '../../components/agents/agentTypes.js'
-import { AgentRunEventType } from './agentRunEventTypes.js'
-import { createIdleLiveTurn, reduceAgentLiveTurn } from './agentLiveReducer.js'
-
-describe('reduceAgentLiveTurn', () => {
-  it('accumulates thinking and text deltas', () => {
-    let state = createIdleLiveTurn()
-
-    state = reduceAgentLiveTurn(state, {
-      type: AgentRunEventType.TurnStarted,
-      runId: 'run-1',
-      seq: 1,
-      turn: 1,
-    })
-    state = reduceAgentLiveTurn(state, {
-      type: AgentRunEventType.ThinkingDelta,
-      runId: 'run-1',
-      seq: 2,
-      delta: 'hmm',
-    })
-    state = reduceAgentLiveTurn(state, {
-      type: AgentRunEventType.TextDelta,
-      runId: 'run-1',
-      seq: 3,
-      delta: 'Hi',
-    })
-
-    expect(state.phase).toBe(AgentLivePhase.Responding)
-    expect(state.thinking).toBe('hmm')
-    expect(state.text).toBe('Hi')
-  })
-
-  it('enters tools pending when a turn ends with tool calls', () => {
-    const state = reduceAgentLiveTurn(createIdleLiveTurn(), {
-      type: AgentRunEventType.TurnEnded,
-      runId: 'run-1',
-      seq: 1,
-      toolCallCount: 2,
-    })
-    expect(state.phase).toBe(AgentLivePhase.ToolsPending)
-  })
-
-  it('tracks context compaction from run events', () => {
-    let state = createIdleLiveTurn()
-    state = reduceAgentLiveTurn(state, {
-      type: AgentRunEventType.ContextCompactionStarted,
-      runId: 'run-1',
-      seq: 1,
-      archivedMessageCount: 4,
-    })
-    expect(state.contextCompaction).toBe('summarizing')
-
-    state = reduceAgentLiveTurn(state, {
-      type: AgentRunEventType.ContextCompactionCompleted,
-      runId: 'run-1',
-      seq: 2,
-      activeFromIndex: 8,
-      summaryChars: 1200,
-    })
-    expect(state.contextCompaction).toBe('summarized')
-
-    state = reduceAgentLiveTurn(state, {
-      type: AgentRunEventType.TurnStarted,
-      runId: 'run-1',
-      seq: 3,
-      turn: 1,
-    })
-    expect(state.contextCompaction).toBeUndefined()
-    expect(state.phase).toBe(AgentLivePhase.Thinking)
-  })
-})
+import { describe, expect, it } from 'vitest'
+import { AgentLivePhase } from '../../components/agents/agentTypes.js'
+import { AgentRunEventType } from './agentRunEventTypes.js'
+import { createIdleLiveTurn, reduceAgentLiveTurn } from './agentLiveReducer.js'
+
+describe('reduceAgentLiveTurn', () => {
+  it('accumulates thinking and text deltas', () => {
+    let state = createIdleLiveTurn()
+
+    state = reduceAgentLiveTurn(state, {
+      type: AgentRunEventType.TurnStarted,
+      runId: 'run-1',
+      seq: 1,
+      turn: 1,
+    })
+    state = reduceAgentLiveTurn(state, {
+      type: AgentRunEventType.ThinkingDelta,
+      runId: 'run-1',
+      seq: 2,
+      delta: 'hmm',
+    })
+    state = reduceAgentLiveTurn(state, {
+      type: AgentRunEventType.TextDelta,
+      runId: 'run-1',
+      seq: 3,
+      delta: 'Hi',
+    })
+
+    expect(state.phase).toBe(AgentLivePhase.Responding)
+    expect(state.thinking).toBe('hmm')
+    expect(state.text).toBe('Hi')
+  })
+
+  it('enters tools pending when a turn ends with tool calls', () => {
+    const state = reduceAgentLiveTurn(createIdleLiveTurn(), {
+      type: AgentRunEventType.TurnEnded,
+      runId: 'run-1',
+      seq: 1,
+      toolCallCount: 2,
+    })
+    expect(state.phase).toBe(AgentLivePhase.ToolsPending)
+  })
+
+  it('tracks context compaction from run events', () => {
+    let state = createIdleLiveTurn()
+    state = reduceAgentLiveTurn(state, {
+      type: AgentRunEventType.ContextCompactionStarted,
+      runId: 'run-1',
+      seq: 1,
+      archivedMessageCount: 4,
+    })
+    expect(state.contextCompaction).toBe('summarizing')
+
+    state = reduceAgentLiveTurn(state, {
+      type: AgentRunEventType.ContextCompactionCompleted,
+      runId: 'run-1',
+      seq: 2,
+      activeFromIndex: 8,
+      summaryChars: 1200,
+    })
+    expect(state.contextCompaction).toBe('summarized')
+
+    state = reduceAgentLiveTurn(state, {
+      type: AgentRunEventType.TurnStarted,
+      runId: 'run-1',
+      seq: 3,
+      turn: 1,
+    })
+    expect(state.contextCompaction).toBeUndefined()
+    expect(state.phase).toBe(AgentLivePhase.Thinking)
+  })
+})

package/src/agents/runtime/agentLiveReducer.ts

@@ -1,139 +1,139 @@
-import {
-  AgentLivePhase,
-  type AgentLiveTurn,
-  type AgentUiToolCall,
-} from '../../components/agents/agentTypes.js'
-import {
-  AgentRunEventType,
-  type PlatformAgentRunEventPayload,
-} from './agentRunEventTypes.js'
-
-export function createIdleLiveTurn(): AgentLiveTurn {
-  return {
-    phase: AgentLivePhase.Idle,
-    thinking: '',
-    text: '',
-    toolCalls: [],
-  }
-}
-
-export function reduceAgentLiveTurn(
-  state: AgentLiveTurn,
-  event: PlatformAgentRunEventPayload,
-): AgentLiveTurn {
-  switch (event.type) {
-    case AgentRunEventType.TurnStarted:
-      return {
-        phase: AgentLivePhase.Thinking,
-        thinking: '',
-        text: '',
-        toolCalls: [],
-      }
-
-    case AgentRunEventType.ThinkingDelta:
-      return {
-        ...state,
-        phase: AgentLivePhase.Thinking,
-        thinking: state.thinking + event.delta,
-      }
-
-    case AgentRunEventType.TextDelta:
-      return {
-        ...state,
-        phase: AgentLivePhase.Responding,
-        text: state.text + event.delta,
-      }
-
-    case AgentRunEventType.ToolCallStarted: {
-      const toolCalls = upsertToolCall(state.toolCalls, {
-        id: event.toolCallId,
-        name: event.name,
-        arguments: {},
-      })
-      return {
-        ...state,
-        phase: AgentLivePhase.Responding,
-        toolCalls,
-      }
-    }
-
-    case AgentRunEventType.ToolCallArgsDelta:
-      return state
-
-    case AgentRunEventType.ToolCallDone:
-      return {
-        ...state,
-        toolCalls: upsertToolCall(state.toolCalls, event.toolCall),
-      }
-
-    case AgentRunEventType.ToolExecStarted:
-      return {
-        ...state,
-        phase: AgentLivePhase.ToolRunning,
-        activeTool: {
-          toolCallId: event.toolCallId,
-          name: event.name,
-          arguments: event.arguments,
-        },
-      }
-
-    case AgentRunEventType.ToolExecEnded:
-      return {
-        ...state,
-        phase: AgentLivePhase.Responding,
-        activeTool: undefined,
-      }
-
-    case AgentRunEventType.TurnEnded:
-      return event.toolCallCount > 0
-        ? {
-            ...state,
-            phase: AgentLivePhase.ToolsPending,
-            activeTool: undefined,
-          }
-        : {
-            ...state,
-            phase: AgentLivePhase.Idle,
-            activeTool: undefined,
-          }
-
-    case AgentRunEventType.ContextCompactionStarted:
-      return { ...state, contextCompaction: 'summarizing' }
-
-    case AgentRunEventType.ContextCompactionCompleted:
-      return { ...state, contextCompaction: 'summarized' }
-
-    case AgentRunEventType.StateChanged:
-      if (event.state === 'pending_tools') {
-        return {
-          ...state,
-          phase: AgentLivePhase.ToolsPending,
-          activeTool: undefined,
-        }
-      }
-      if (event.state === 'awaiting_user' || event.state === 'ready') {
-        return createIdleLiveTurn()
-      }
-      if (event.state === 'interrupted' || event.state === 'failed') {
-        return createIdleLiveTurn()
-      }
-      return state
-
-    case AgentRunEventType.Error:
-      return createIdleLiveTurn()
-
-    default:
-      return state
-  }
-}
-
-function upsertToolCall(
-  toolCalls: AgentUiToolCall[],
-  next: AgentUiToolCall,
-): AgentUiToolCall[] {
-  const index = toolCalls.findIndex(call => call.id === next.id)
-  if (index < 0) return [...toolCalls, next]
-  const copy = [...toolCalls]
-  copy[index] = { ...copy[index], ...next }
-  return copy
-}
+import {
+  AgentLivePhase,
+  type AgentLiveTurn,
+  type AgentUiToolCall,
+} from '../../components/agents/agentTypes.js'
+import {
+  AgentRunEventType,
+  type PlatformAgentRunEventPayload,
+} from './agentRunEventTypes.js'
+
+export function createIdleLiveTurn(): AgentLiveTurn {
+  return {
+    phase: AgentLivePhase.Idle,
+    thinking: '',
+    text: '',
+    toolCalls: [],
+  }
+}
+
+export function reduceAgentLiveTurn(
+  state: AgentLiveTurn,
+  event: PlatformAgentRunEventPayload,
+): AgentLiveTurn {
+  switch (event.type) {
+    case AgentRunEventType.TurnStarted:
+      return {
+        phase: AgentLivePhase.Thinking,
+        thinking: '',
+        text: '',
+        toolCalls: [],
+      }
+
+    case AgentRunEventType.ThinkingDelta:
+      return {
+        ...state,
+        phase: AgentLivePhase.Thinking,
+        thinking: state.thinking + event.delta,
+      }
+
+    case AgentRunEventType.TextDelta:
+      return {
+        ...state,
+        phase: AgentLivePhase.Responding,
+        text: state.text + event.delta,
+      }
+
+    case AgentRunEventType.ToolCallStarted: {
+      const toolCalls = upsertToolCall(state.toolCalls, {
+        id: event.toolCallId,
+        name: event.name,
+        arguments: {},
+      })
+      return {
+        ...state,
+        phase: AgentLivePhase.Responding,
+        toolCalls,
+      }
+    }
+
+    case AgentRunEventType.ToolCallArgsDelta:
+      return state
+
+    case AgentRunEventType.ToolCallDone:
+      return {
+        ...state,
+        toolCalls: upsertToolCall(state.toolCalls, event.toolCall),
+      }
+
+    case AgentRunEventType.ToolExecStarted:
+      return {
+        ...state,
+        phase: AgentLivePhase.ToolRunning,
+        activeTool: {
+          toolCallId: event.toolCallId,
+          name: event.name,
+          arguments: event.arguments,
+        },
+      }
+
+    case AgentRunEventType.ToolExecEnded:
+      return {
+        ...state,
+        phase: AgentLivePhase.Responding,
+        activeTool: undefined,
+      }
+
+    case AgentRunEventType.TurnEnded:
+      return event.toolCallCount > 0
+        ? {
+            ...state,
+            phase: AgentLivePhase.ToolsPending,
+            activeTool: undefined,
+          }
+        : {
+            ...state,
+            phase: AgentLivePhase.Idle,
+            activeTool: undefined,
+          }
+
+    case AgentRunEventType.ContextCompactionStarted:
+      return { ...state, contextCompaction: 'summarizing' }
+
+    case AgentRunEventType.ContextCompactionCompleted:
+      return { ...state, contextCompaction: 'summarized' }
+
+    case AgentRunEventType.StateChanged:
+      if (event.state === 'pending_tools') {
+        return {
+          ...state,
+          phase: AgentLivePhase.ToolsPending,
+          activeTool: undefined,
+        }
+      }
+      if (event.state === 'awaiting_user' || event.state === 'ready') {
+        return createIdleLiveTurn()
+      }
+      if (event.state === 'interrupted' || event.state === 'failed') {
+        return createIdleLiveTurn()
+      }
+      return state
+
+    case AgentRunEventType.Error:
+      return createIdleLiveTurn()
+
+    default:
+      return state
+  }
+}
+
+function upsertToolCall(
+  toolCalls: AgentUiToolCall[],
+  next: AgentUiToolCall,
+): AgentUiToolCall[] {
+  const index = toolCalls.findIndex(call => call.id === next.id)
+  if (index < 0) return [...toolCalls, next]
+  const copy = [...toolCalls]
+  copy[index] = { ...copy[index], ...next }
+  return copy
+}