vintasend 0.4.0 → 0.4.7

package/dist/examples/vintasend-medplum-example/src/utils/spacePersistence.test.ts

@@ -0,0 +1,450 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { Communication } from '@medplum/fhirtypes';
+import { MockClient } from '@medplum/mock';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { createConversationTopic, saveMessage, loadConversationMessages, loadRecentTopics } from './spacePersistence';
+import type { Message } from '../types/spaces';
+
+describe('spacePersistence', () => {
+  let medplum: MockClient;
+  let mockProfile: { id: string; resourceType: string };
+
+  beforeEach(() => {
+    medplum = new MockClient();
+    mockProfile = {
+      id: 'practitioner-123',
+      resourceType: 'Practitioner',
+    };
+    vi.spyOn(medplum, 'getProfile').mockResolvedValue(mockProfile as any);
+  });
+
+  describe('createConversationTopic', () => {
+    test('creates conversation topic with title and model', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({
+        resourceType: 'Communication',
+        id: 'topic-1',
+        status: 'in-progress',
+      } as Communication & { id: string });
+
+      const result = await createConversationTopic(medplum, 'Test Topic', 'gpt-4');
+
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'Communication',
+          status: 'in-progress',
+          identifier: [
+            {
+              system: 'http://medplum.com/ai-message',
+              value: 'ai-message-topic',
+            },
+          ],
+          sender: { reference: 'Practitioner/practitioner-123' },
+          topic: {
+            text: 'Test Topic',
+          },
+          note: [
+            {
+              text: JSON.stringify({ model: 'gpt-4' }),
+            },
+          ],
+        })
+      );
+      expect(result).toBeDefined();
+    });
+
+    test('throws error when profile not found', async () => {
+      vi.spyOn(medplum, 'getProfile').mockResolvedValue(undefined);
+
+      await expect(createConversationTopic(medplum, 'Test Topic', 'gpt-4')).rejects.toThrow('Profile not found');
+    });
+
+    test('throws error when profile has no id', async () => {
+      vi.spyOn(medplum, 'getProfile').mockResolvedValue({} as any);
+
+      await expect(createConversationTopic(medplum, 'Test Topic', 'gpt-4')).rejects.toThrow('Profile not found');
+    });
+  });
+
+  describe('saveMessage', () => {
+    test('saves message with all fields', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({
+        resourceType: 'Communication',
+        id: 'message-1',
+        status: 'completed',
+      } as Communication & { id: string });
+
+      const message: Message = {
+        role: 'user',
+        content: 'Hello, world!',
+        tool_calls: [{ id: 'call-1', type: 'function' }],
+        tool_call_id: 'call-1',
+        resources: ['Patient/123'],
+      };
+
+      const result = await saveMessage(medplum, 'topic-1', message, 1);
+
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceType: 'Communication',
+          status: 'completed',
+          identifier: [
+            {
+              system: 'http://medplum.com/ai-message',
+              value: 'ai-message',
+            },
+          ],
+          partOf: [
+            {
+              reference: 'Communication/topic-1',
+            },
+          ],
+          payload: [
+            {
+              contentString: JSON.stringify({
+                role: 'user',
+                content: 'Hello, world!',
+                tool_calls: [{ id: 'call-1', type: 'function' }],
+                tool_call_id: 'call-1',
+                resources: ['Patient/123'],
+                sequenceNumber: 1,
+              }),
+            },
+          ],
+        })
+      );
+      expect(result).toBeDefined();
+    });
+
+    test('saves message with minimal fields', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({
+        resourceType: 'Communication',
+        id: 'message-2',
+        status: 'completed',
+      } as Communication & { id: string });
+
+      const message: Message = {
+        role: 'assistant',
+        content: 'Response',
+      };
+
+      const result = await saveMessage(medplum, 'topic-2', message, 2);
+
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          payload: [
+            {
+              contentString: JSON.stringify({
+                role: 'assistant',
+                content: 'Response',
+                tool_calls: undefined,
+                tool_call_id: undefined,
+                resources: undefined,
+                sequenceNumber: 2,
+              }),
+            },
+          ],
+        })
+      );
+      expect(result).toBeDefined();
+    });
+
+    test('saves message with null content', async () => {
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue({
+        resourceType: 'Communication',
+        id: 'message-3',
+        status: 'completed',
+      } as Communication & { id: string });
+
+      const message: Message = {
+        role: 'tool',
+        content: null,
+        tool_call_id: 'call-1',
+      };
+
+      await saveMessage(medplum, 'topic-3', message, 3);
+
+      const call = createSpy.mock.calls[0][0] as Communication;
+      const payload = JSON.parse(call.payload?.[0]?.contentString ?? '{}');
+      expect(payload.content).toBeNull();
+      expect(payload.role).toBe('tool');
+      expect(payload.tool_call_id).toBe('call-1');
+      expect(payload.sequenceNumber).toBe(3);
+    });
+  });
+
+  describe('loadConversationMessages', () => {
+    test('loads messages from communications', async () => {
+      const mockCommunications: (Communication & { id: string })[] = [
+        {
+          resourceType: 'Communication',
+          id: 'comm-1',
+          status: 'completed',
+          payload: [
+            {
+              contentString: JSON.stringify({
+                role: 'user',
+                content: 'Hello',
+                sequenceNumber: 1,
+              }),
+            },
+          ],
+        },
+        {
+          resourceType: 'Communication',
+          id: 'comm-2',
+          status: 'completed',
+          payload: [
+            {
+              contentString: JSON.stringify({
+                role: 'assistant',
+                content: 'Hi there',
+                sequenceNumber: 2,
+              }),
+            },
+          ],
+        },
+      ];
+
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue(mockCommunications as any);
+
+      const messages = await loadConversationMessages(medplum, 'topic-1');
+
+      expect(medplum.searchResources).toHaveBeenCalledWith('Communication', {
+        'part-of': 'Communication/topic-1',
+        _sort: '_lastUpdated',
+      });
+      expect(messages).toEqual([
+        {
+          role: 'user',
+          content: 'Hello',
+        },
+        {
+          role: 'assistant',
+          content: 'Hi there',
+        },
+      ]);
+    });
+
+    test('handles messages with tool_calls and resources', async () => {
+      const mockCommunications: (Communication & { id: string })[] = [
+        {
+          resourceType: 'Communication',
+          id: 'comm-1',
+          status: 'completed',
+          payload: [
+            {
+              contentString: JSON.stringify({
+                role: 'assistant',
+                content: 'I can help',
+                tool_calls: [{ id: 'call-1', type: 'function' }],
+                resources: ['Patient/123'],
+                sequenceNumber: 1,
+              }),
+            },
+          ],
+        },
+      ];
+
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue(mockCommunications as any);
+
+      const messages = await loadConversationMessages(medplum, 'topic-1');
+
+      expect(messages).toEqual([
+        {
+          role: 'assistant',
+          content: 'I can help',
+          tool_calls: [{ id: 'call-1', type: 'function' }],
+          resources: ['Patient/123'],
+        },
+      ]);
+    });
+
+    test('handles messages without sequenceNumber', async () => {
+      const mockCommunications: (Communication & { id: string })[] = [
+        {
+          resourceType: 'Communication',
+          id: 'comm-1',
+          status: 'completed',
+          payload: [
+            {
+              contentString: JSON.stringify({
+                role: 'user',
+                content: 'Test',
+              }),
+            },
+          ],
+        },
+      ];
+
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue(mockCommunications as any);
+
+      const messages = await loadConversationMessages(medplum, 'topic-1');
+
+      expect(messages).toEqual([
+        {
+          role: 'user',
+          content: 'Test',
+        },
+      ]);
+    });
+
+    test('skips communications without payload', async () => {
+      const mockCommunications: (Communication & { id: string })[] = [
+        {
+          resourceType: 'Communication',
+          id: 'comm-1',
+          status: 'completed',
+          payload: [
+            {
+              contentString: JSON.stringify({
+                role: 'user',
+                content: 'Hello',
+                sequenceNumber: 1,
+              }),
+            },
+          ],
+        },
+        {
+          resourceType: 'Communication',
+          id: 'comm-2',
+          status: 'completed',
+          // No payload
+        },
+        {
+          resourceType: 'Communication',
+          id: 'comm-3',
+          status: 'completed',
+          payload: [], // Empty payload
+        },
+      ];
+
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue(mockCommunications as any);
+
+      const messages = await loadConversationMessages(medplum, 'topic-1');
+
+      expect(messages).toEqual([
+        {
+          role: 'user',
+          content: 'Hello',
+        },
+      ]);
+    });
+
+    test('throws error when JSON parsing fails with Error instance', async () => {
+      const mockCommunications: (Communication & { id: string })[] = [
+        {
+          resourceType: 'Communication',
+          id: 'comm-1',
+          status: 'completed',
+          payload: [
+            {
+              contentString: 'invalid json{',
+            },
+          ],
+        },
+      ];
+
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue(mockCommunications as any);
+
+      await expect(loadConversationMessages(medplum, 'topic-1')).rejects.toThrow('Failed to parse message');
+    });
+
+    test('throws error when JSON parsing fails with non-Error', async () => {
+      const mockCommunications: (Communication & { id: string })[] = [
+        {
+          resourceType: 'Communication',
+          id: 'comm-1',
+          status: 'completed',
+          payload: [
+            {
+              contentString: 'test',
+            },
+          ],
+        },
+      ];
+
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue(mockCommunications as any);
+      // Mock JSON.parse to throw a non-Error object
+      const originalParse = JSON.parse;
+      vi.spyOn(JSON, 'parse').mockImplementationOnce(() => {
+        throw new Error('string error'); // Throw Error instead of string
+      });
+
+      await expect(loadConversationMessages(medplum, 'topic-1')).rejects.toThrow('Failed to parse message');
+
+      JSON.parse = originalParse;
+    });
+
+    test('handles empty communications array', async () => {
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue([] as any);
+
+      const messages = await loadConversationMessages(medplum, 'topic-1');
+
+      expect(messages).toEqual([]);
+    });
+  });
+
+  describe('loadRecentTopics', () => {
+    test('loads recent topics with default limit', async () => {
+      const mockTopics: (Communication & { id: string })[] = [
+        {
+          resourceType: 'Communication',
+          id: 'topic-1',
+          status: 'in-progress',
+          topic: { text: 'Topic 1' },
+        },
+        {
+          resourceType: 'Communication',
+          id: 'topic-2',
+          status: 'in-progress',
+          topic: { text: 'Topic 2' },
+        },
+      ];
+
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue(mockTopics as any);
+
+      const topics = await loadRecentTopics(medplum);
+
+      expect(medplum.getProfile).toHaveBeenCalled();
+      expect(medplum.searchResources).toHaveBeenCalledWith('Communication', {
+        identifier: 'http://medplum.com/ai-message|ai-message-topic',
+        sender: 'Practitioner/practitioner-123',
+        _sort: '-_lastUpdated',
+        _count: '10',
+      });
+      expect(topics).toEqual(mockTopics);
+    });
+
+    test('loads recent topics with custom limit', async () => {
+      const mockTopics: (Communication & { id: string })[] = [
+        {
+          resourceType: 'Communication',
+          id: 'topic-1',
+          status: 'in-progress',
+          topic: { text: 'Topic 1' },
+        },
+      ];
+
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue(mockTopics as any);
+
+      const topics = await loadRecentTopics(medplum, 5);
+
+      expect(medplum.searchResources).toHaveBeenCalledWith('Communication', {
+        identifier: 'http://medplum.com/ai-message|ai-message-topic',
+        sender: 'Practitioner/practitioner-123',
+        _sort: '-_lastUpdated',
+        _count: '5',
+      });
+      expect(topics).toEqual(mockTopics);
+    });
+
+    test('handles empty topics array', async () => {
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue([] as any);
+
+      const topics = await loadRecentTopics(medplum);
+
+      expect(topics).toEqual([]);
+    });
+  });
+});

package/dist/examples/vintasend-medplum-example/src/utils/spacePersistence.ts

@@ -0,0 +1,147 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { Communication } from '@medplum/fhirtypes';
+import type { MedplumClient, ProfileResource } from '@medplum/core';
+import type { Message } from '../types/spaces';
+import { createReference, getReferenceString } from '@medplum/core';
+
+/**
+ * Creates a new conversation topic (main Communication resource)
+ * @param medplum - The Medplum client instance
+ * @param title - The title of the conversation
+ * @param model - The AI model being used
+ * @returns The created Communication resource
+ */
+export async function createConversationTopic(
+  medplum: MedplumClient,
+  title: string,
+  model: string
+): Promise<Communication> {
+  const profile = await medplum.getProfile();
+  if (!profile?.id) {
+    throw new Error('Profile not found');
+  }
+
+  const topic: Communication = {
+    resourceType: 'Communication',
+    status: 'in-progress',
+    identifier: [
+      {
+        system: 'http://medplum.com/ai-message',
+        value: 'ai-message-topic',
+      },
+    ],
+    sender: createReference(profile),
+    topic: {
+      text: title,
+    },
+    note: [
+      {
+        text: JSON.stringify({ model }),
+      },
+    ],
+  };
+
+  return medplum.createResource(topic);
+}
+
+/**
+ * Saves a message as a Communication resource linked to the topic
+ * @param medplum - The Medplum client instance
+ * @param topicId - The ID of the conversation topic
+ * @param message - The message to save
+ * @param sequenceNumber - The sequence number of the message
+ * @returns The created Communication resource
+ */
+export async function saveMessage(
+  medplum: MedplumClient,
+  topicId: string,
+  message: Message,
+  sequenceNumber: number
+): Promise<Communication> {
+  const communication: Communication = {
+    resourceType: 'Communication',
+    status: 'completed',
+    identifier: [
+      {
+        system: 'http://medplum.com/ai-message',
+        value: 'ai-message',
+      },
+    ],
+    partOf: [
+      {
+        reference: `Communication/${topicId}`,
+      },
+    ],
+    payload: [
+      {
+        contentString: JSON.stringify({
+          role: message.role,
+          content: message.content,
+          tool_calls: message.tool_calls,
+          tool_call_id: message.tool_call_id,
+          resources: message.resources,
+          sequenceNumber,
+        }),
+      },
+    ],
+  };
+
+  return medplum.createResource(communication);
+}
+
+/**
+ * Loads the last messages for a conversation topic
+ * @param medplum - The Medplum client instance
+ * @param topicId - The ID of the conversation topic
+ * @returns Array of messages
+ */
+export async function loadConversationMessages(medplum: MedplumClient, topicId: string): Promise<Message[]> {
+  const communications = await medplum.searchResources('Communication', {
+    'part-of': `Communication/${topicId}`,
+    _sort: '_lastUpdated',
+  });
+
+  const messages: { message: Message; sequenceNumber: number }[] = [];
+
+  for (const comm of communications) {
+    if (comm.payload?.[0]?.contentString) {
+      try {
+        const data = JSON.parse(comm.payload[0].contentString);
+        messages.push({
+          message: {
+            role: data.role,
+            content: data.content,
+            tool_calls: data.tool_calls,
+            tool_call_id: data.tool_call_id,
+            resources: data.resources,
+          },
+          sequenceNumber: data.sequenceNumber || 0,
+        });
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(`Failed to parse message: ${error.message}`);
+        }
+        throw new Error(`Failed to parse message: ${String(error)}`);
+      }
+    }
+  }
+
+  return messages.map((m) => m.message);
+}
+
+/**
+ * Loads recent conversation topics
+ * @param medplum - The Medplum client instance
+ * @param limit - Maximum number of topics to return
+ * @returns Array of conversation topic Communications
+ */
+export async function loadRecentTopics(medplum: MedplumClient, limit = 10): Promise<Communication[]> {
+  const profile = await medplum.getProfile();
+  return medplum.searchResources('Communication', {
+    identifier: 'http://medplum.com/ai-message|ai-message-topic',
+    sender: getReferenceString(profile as ProfileResource),
+    _sort: '-_lastUpdated',
+    _count: String(limit),
+  });
+}

package/dist/examples/vintasend-medplum-example/src/utils/task-search.ts

@@ -0,0 +1,63 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { parseSearchRequest } from '@medplum/core';
+import type { SearchRequest, Filter } from '@medplum/core';
+
+export interface NormalizeTaskSearchOptions {
+  /**
+   * Additional filters to apply to the search request.
+   * These filters will be merged with existing filters, replacing any with the same code.
+   */
+  additionalFilters?: Filter[];
+}
+
+export interface NormalizeTaskSearchResult {
+  /**
+   * The normalized search request with required fields set.
+   */
+  normalizedSearch: SearchRequest;
+  /**
+   * Whether navigation is needed to update the URL with normalized parameters.
+   */
+  needsNavigation: boolean;
+}
+
+/**
+ * Normalizes a task search request by ensuring required fields are present.
+ * Checks for _lastUpdated sort rule, count, and total parameters.
+ *
+ * @param locationPathname - The pathname from useLocation()
+ * @param locationSearch - The search string from useLocation()
+ * @param options - Optional configuration for additional filters
+ * @returns Normalized search request and whether navigation is needed
+ */
+export function normalizeTaskSearch(
+  locationPathname: string,
+  locationSearch: string,
+  options?: NormalizeTaskSearchOptions
+): NormalizeTaskSearchResult {
+  const parsedSearch = parseSearchRequest(locationPathname + locationSearch);
+  const lastUpdatedSortRule = parsedSearch.sortRules?.find((rule) => rule.code === '_lastUpdated');
+
+  let filters = parsedSearch.filters || [];
+  if (options?.additionalFilters) {
+    const additionalFilterCodes = new Set(options.additionalFilters.map((f) => f.code));
+    filters = filters.filter((f) => !additionalFilterCodes.has(f.code));
+    filters = [...filters, ...options.additionalFilters];
+  }
+
+  const normalizedSearch: SearchRequest = {
+    ...parsedSearch,
+    filters,
+    sortRules: lastUpdatedSortRule ? parsedSearch.sortRules : [{ code: '_lastUpdated', descending: true }],
+    count: parsedSearch.count || 20,
+    total: parsedSearch.total || 'accurate',
+  };
+
+  const needsNavigation = !lastUpdatedSortRule || !parsedSearch.count || !parsedSearch.total;
+
+  return {
+    normalizedSearch,
+    needsNavigation,
+  };
+}

package/dist/examples/vintasend-medplum-example/src/vite-env.d.ts

@@ -0,0 +1,3 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+/// <reference types="vite/client" />

package/dist/examples/vintasend-medplum-example/tsconfig.bots.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["dist", "**/*.test.ts", "**/*.test.tsx", "**/test.setup.ts"]
+}

package/dist/examples/vintasend-medplum-example/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "useDefineForClassFields": true,
+    "lib": ["DOM", "DOM.Iterable", "ESNext"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "jsx": "react-jsx"
+  },
+  "exclude": ["dist"]
+}

package/dist/examples/vintasend-medplum-example/vercel.json

@@ -0,0 +1,3 @@
+{
+  "routes": [{ "src": "/[^.]+", "dest": "/", "status": 200 }]
+}