@loopstack/meeting-notes-example-workflow 0.20.6 → 0.21.0

package/src/__tests__/meeting-notes.workflow.spec.ts

@@ -1,9 +1,8 @@
 import { TestingModule } from '@nestjs/testing';
-import { AiGenerateDocument, AiModule } from '@loopstack/ai-module';
-import { RunContext, generateObjectFingerprint, getBlockTools } from '@loopstack/common';
-import { WorkflowProcessorService } from '@loopstack/core';
-import { CoreUiModule, CreateDocument } from '@loopstack/core-ui-module';
-import { ToolMock, createWorkflowTest } from '@loopstack/testing';
+import { ClaudeGenerateDocument, ClaudeModule } from '@loopstack/claude-module';
+import { RunContext, WorkflowEntity, getBlockTools } from '@loopstack/common';
+import { LoopCoreModule, WorkflowProcessorService } from '@loopstack/core';
+import { ToolMock, createStatelessContext, createWorkflowTest } from '@loopstack/testing';
 import { MeetingNotesDocument } from '../documents/meeting-notes-document';
 import { OptimizedNotesDocument } from '../documents/optimized-notes-document';
 import { MeetingNotesWorkflow } from '../meeting-notes.workflow';
@@ -13,30 +12,21 @@ describe('MeetingNotesWorkflow', () => {
   let workflow: MeetingNotesWorkflow;
   let processor: WorkflowProcessorService;
 
-  let mockCreateDocument: ToolMock;
-
-  const mockInitialNotes = {
-    text: `
-- meeting 1.1.2025
-- budget: need 2 cut costs sarah said
-- hire new person?? --> marketing
-- vendor pricing - follow up needed by anna`,
-  };
+  let mockClaudeGenerateDocument: ToolMock;
 
   beforeEach(async () => {
     module = await createWorkflowTest()
       .forWorkflow(MeetingNotesWorkflow)
-      .withImports(CoreUiModule, AiModule)
+      .withImports(LoopCoreModule, ClaudeModule)
       .withProvider(MeetingNotesDocument)
       .withProvider(OptimizedNotesDocument)
-      .withToolOverride(CreateDocument)
-      .withToolOverride(AiGenerateDocument)
+      .withToolOverride(ClaudeGenerateDocument)
       .compile();
 
     workflow = module.get(MeetingNotesWorkflow);
     processor = module.get(WorkflowProcessorService);
 
-    mockCreateDocument = module.get(CreateDocument);
+    mockClaudeGenerateDocument = module.get(ClaudeGenerateDocument);
   });
 
   afterEach(async () => {
@@ -46,152 +36,103 @@ describe('MeetingNotesWorkflow', () => {
   describe('initialization', () => {
     it('should be defined with correct tools', () => {
       expect(workflow).toBeDefined();
-      expect(getBlockTools(workflow)).toContain('createDocument');
-      expect(getBlockTools(workflow)).toContain('aiGenerateDocument');
+      expect(getBlockTools(workflow)).toContain('claudeGenerateDocument');
     });
   });
 
   describe('initial step', () => {
-    const context = {} as RunContext;
-
     it('should execute initial step and stop at waiting_for_response', async () => {
-      mockCreateDocument.execute.mockResolvedValue({
-        data: { content: mockInitialNotes },
-      });
+      const context = createStatelessContext();
 
       const result = await processor.process(workflow, {}, context);
 
-      // Should execute without errors and stop at waiting_for_response (manual step)
       expect(result.hasError).toBe(false);
       expect(result.stop).toBe(true);
+      expect(result.place).toBe('waiting_for_response');
 
-      // Should call CreateDocument once for the initial form
-      expect(mockCreateDocument.execute).toHaveBeenCalledTimes(1);
-      expect(mockCreateDocument.execute).toHaveBeenCalledWith(
+      expect(result.documents).toHaveLength(1);
+      expect(result.documents[0]).toEqual(
         expect.objectContaining({
-          id: 'input',
-          update: {
-            content: {
-              text: expect.stringContaining('1.1.2025'),
-            },
-          },
+          className: 'MeetingNotesDocument',
+          content: expect.objectContaining({
+            text: expect.stringContaining('1.1.2025'),
+          }),
         }),
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
       );
-
-      // // Verify history contains expected places
-      // const history = result.state.getHistory();
-      // const places = history.map((h) => h.metadata?.place);
-      // expect(places).toContain('waiting_for_response');
     });
-  });
 
-  describe('user response step', () => {
-    it('should process user response and generate optimized notes', async () => {
-      const mockUserEditedNotes = {
-        text: `Meeting Notes - January 1, 2025
-- Budget discussion: need to cut costs (Sarah's input)
-- Hiring: new person needed for marketing
-- Vendor pricing: follow up needed by Anna`,
-      };
+    it('should use custom input text when provided', async () => {
+      const context = createStatelessContext();
 
-      const mockOptimizedNotes = {
-        date: '2025-01-01',
-        summary: 'Budget and hiring discussion',
-        participants: ['Sarah', 'Anna'],
-        decisions: ['Cut costs', 'Hire for marketing'],
-        actionItems: ['Follow up on vendor pricing'],
-      };
+      const result = await processor.process(workflow, { inputText: 'Custom meeting notes here' }, context);
 
-      const args = { inputText: mockInitialNotes.text };
-
-      // Create module with existing workflow state
-      const moduleWithState = await createWorkflowTest()
-        .forWorkflow(MeetingNotesWorkflow)
-        .withImports(CoreUiModule, AiModule)
-        .withProvider(MeetingNotesDocument)
-        .withProvider(OptimizedNotesDocument)
-        .withToolOverride(CreateDocument)
-        .withToolOverride(AiGenerateDocument)
-        .withExistingWorkflow({
-          id: '123',
-          place: 'waiting_for_response',
-          hashRecord: {
-            options: generateObjectFingerprint(args), // previously run with same arguments
-          },
-        })
-        .compile();
+      expect(result.hasError).toBe(false);
+      expect(result.stop).toBe(true);
 
-      const workflowWithState = moduleWithState.get(MeetingNotesWorkflow);
-      const processorWithState = moduleWithState.get(WorkflowProcessorService);
+      expect(result.documents[0]).toEqual(
+        expect.objectContaining({
+          content: expect.objectContaining({
+            text: expect.stringContaining('Custom meeting notes here'),
+          }),
+        }),
+      );
+    });
+  });
 
-      const mockCreateDocumentWithState: ToolMock = moduleWithState.get(CreateDocument);
-      const mockAiGenerateDocumentWithState: ToolMock = moduleWithState.get(AiGenerateDocument);
+  describe('resume from waiting_for_response', () => {
+    it('should process user response and call LLM to optimize notes', async () => {
+      const workflowId = '00000000-0000-0000-0000-000000000001';
 
-      mockCreateDocumentWithState.execute.mockResolvedValue({
-        data: { content: mockUserEditedNotes },
-      });
-      mockAiGenerateDocumentWithState.execute.mockResolvedValue({
-        data: { content: mockOptimizedNotes },
-      });
+      mockClaudeGenerateDocument.call.mockResolvedValue({ data: undefined });
 
-      // Context with user payload for manual transition
-      const contextWithPayload = {
+      const context = {
+        workflowEntity: {
+          id: workflowId,
+          place: 'waiting_for_response',
+          documents: [],
+        } as Partial<WorkflowEntity>,
         payload: {
           transition: {
-            id: 'user_response',
-            workflowId: '123',
-            payload: mockUserEditedNotes,
+            id: 'userResponse',
+            workflowId,
+            payload: { text: 'Cleaned up meeting notes from user' },
           },
         },
-      } as RunContext;
+      } as unknown as RunContext;
 
-      const result = await processorWithState.process(workflowWithState, args, contextWithPayload);
+      const result = await processor.process(workflow, {}, context);
 
-      // Should execute and stop at notes_optimized (next manual step)
       expect(result.hasError).toBe(false);
       expect(result.stop).toBe(true);
-
-      // Should call CreateDocument once for user response
-      expect(mockCreateDocumentWithState.execute).toHaveBeenCalledTimes(1);
-      expect(mockCreateDocumentWithState.execute).toHaveBeenCalledWith(
-        expect.objectContaining({
-          id: 'input',
-        }),
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
+      expect(result.place).toBe('notes_optimized');
+
+      // User response should have been saved as document
+      expect(result.documents).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            className: 'MeetingNotesDocument',
+          }),
+        ]),
       );
 
-      // Should call AiGenerateDocument once
-      expect(mockAiGenerateDocumentWithState.execute).toHaveBeenCalledTimes(1);
-      expect(mockAiGenerateDocumentWithState.execute).toHaveBeenCalledWith(
+      // LLM should have been called to optimize notes
+      expect(mockClaudeGenerateDocument.call).toHaveBeenCalledTimes(1);
+      expect(mockClaudeGenerateDocument.call).toHaveBeenCalledWith(
         expect.objectContaining({
-          llm: {
-            provider: 'openai',
-            model: 'gpt-4o',
-          },
+          claude: { model: 'claude-sonnet-4-6' },
+          response: expect.objectContaining({ id: 'final' }),
+          prompt: expect.stringContaining('meeting notes'),
         }),
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
+        undefined,
       );
-
-      // // Verify history contains expected places
-      // const history = result.state.getHistory();
-      // const places = history.map((h) => h.metadata?.place);
-      // expect(places).toContain('response_received');
-      // expect(places).toContain('notes_optimized');
-
-      await moduleWithState.close();
     });
   });
 
-  describe('confirm step', () => {
+  describe('resume from notes_optimized', () => {
     it('should complete workflow when user confirms optimized notes', async () => {
-      const mockFinalNotes = {
+      const workflowId = '00000000-0000-0000-0000-000000000002';
+
+      const optimizedPayload = {
         date: '2025-01-01',
         summary: 'Budget discussion with updates',
         participants: ['Sarah', 'Anna', 'Bob'],
@@ -199,60 +140,38 @@ describe('MeetingNotesWorkflow', () => {
         actionItems: ['Follow up on vendor pricing by Friday'],
       };
 
-      const args = { inputText: 'any text' };
-
-      // Create module with existing workflow state after AI optimization
-      const moduleWithState = await createWorkflowTest()
-        .forWorkflow(MeetingNotesWorkflow)
-        .withImports(CoreUiModule, AiModule)
-        .withProvider(MeetingNotesDocument)
-        .withProvider(OptimizedNotesDocument)
-        .withToolOverride(CreateDocument)
-        .withToolOverride(AiGenerateDocument)
-        .withExistingWorkflow({
-          id: '123',
+      const context = {
+        workflowEntity: {
+          id: workflowId,
           place: 'notes_optimized',
-          hashRecord: {
-            options: generateObjectFingerprint(args), // previously run with same arguments
-          },
-        })
-        .compile();
-
-      const workflowWithState = moduleWithState.get(MeetingNotesWorkflow);
-      const processorWithState = moduleWithState.get(WorkflowProcessorService);
-
-      const mockCreateDocumentWithState: ToolMock = moduleWithState.get(CreateDocument);
-
-      mockCreateDocumentWithState.execute.mockResolvedValue({
-        data: { content: mockFinalNotes },
-      });
-
-      // Context with user confirmation for manual transition
-      const contextWithPayload = {
+          documents: [],
+        } as Partial<WorkflowEntity>,
         payload: {
           transition: {
             id: 'confirm',
-            workflowId: '123',
-            payload: mockFinalNotes,
+            workflowId,
+            payload: optimizedPayload,
           },
         },
-      } as RunContext;
+      } as unknown as RunContext;
 
-      const result = await processorWithState.process(workflowWithState, args, contextWithPayload);
+      const result = await processor.process(workflow, {}, context);
 
-      // Should complete and reach end state
       expect(result.hasError).toBe(false);
       expect(result.stop).toBe(false);
+      expect(result.place).toBe('end');
+
+      // Confirmed payload should have been saved as OptimizedNotesDocument
+      expect(result.documents).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            className: 'OptimizedNotesDocument',
+          }),
+        ]),
+      );
 
-      // Should call CreateDocument once for final confirmation
-      expect(mockCreateDocumentWithState.execute).toHaveBeenCalledTimes(1);
-
-      // // Verify history contains expected places including end
-      // const history = result.state.getHistory();
-      // const places = history.map((h) => h.metadata?.place);
-      // expect(places).toContain('end');
-
-      await moduleWithState.close();
+      // No additional LLM calls during confirmation
+      expect(mockClaudeGenerateDocument.call).not.toHaveBeenCalled();
     });
   });
 });

package/src/documents/meeting-notes-document.ts

@@ -1,18 +1,14 @@
 import { z } from 'zod';
-import { Document, DocumentInterface, Input } from '@loopstack/common';
+import { Document } from '@loopstack/common';
 
 export const MeetingNotesDocumentSchema = z.object({
   text: z.string(),
 });
 
 @Document({
-  configFile: __dirname + '/meeting-notes-document.yaml',
+  schema: MeetingNotesDocumentSchema,
+  uiConfig: __dirname + '/meeting-notes-document.yaml',
 })
-export class MeetingNotesDocument implements DocumentInterface {
-  @Input({
-    schema: MeetingNotesDocumentSchema,
-  })
-  content: {
-    text: string;
-  };
+export class MeetingNotesDocument {
+  text: string;
 }

package/src/documents/meeting-notes-document.yaml

@@ -1,13 +1,13 @@
 type: document
 ui:
-  form:
-    properties:
-      text:
-        title: Text
-        widget: textarea
-  actions:
-    - type: button
-      widget: button
+  widgets:
+    - widget: form
       options:
-        transition: user_response
-        label: 'Optimize Notes'
+        properties:
+          text:
+            title: Text
+            widget: textarea
+        actions:
+          - type: button
+            transition: userResponse
+            label: 'Optimize Notes'

package/src/documents/optimized-notes-document.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Document, DocumentInterface, Input } from '@loopstack/common';
+import { Document } from '@loopstack/common';
 
 export const OptimizedMeetingNotesDocumentSchema = z.object({
   date: z.string(),
@@ -10,11 +10,13 @@ export const OptimizedMeetingNotesDocumentSchema = z.object({
 });
 
 @Document({
-  configFile: __dirname + '/optimized-notes-document.yaml',
+  schema: OptimizedMeetingNotesDocumentSchema,
+  uiConfig: __dirname + '/optimized-notes-document.yaml',
 })
-export class OptimizedNotesDocument implements DocumentInterface {
-  @Input({
-    schema: OptimizedMeetingNotesDocumentSchema,
-  })
-  content: z.infer<typeof OptimizedMeetingNotesDocumentSchema>;
+export class OptimizedNotesDocument {
+  date: string;
+  summary: string;
+  participants: string[];
+  decisions: string[];
+  actionItems: string[];
 }

package/src/documents/optimized-notes-document.yaml

@@ -1,36 +1,36 @@
 type: document
 ui:
-  form:
-    order:
-      - date
-      - summary
-      - participants
-      - decisions
-      - actionItems
-    properties:
-      date:
-        title: Date
-      summary:
-        title: Summary
-        widget: textarea
-      participants:
-        title: Participants
-        collapsed: true
-        items:
-          title: Participant
-      decisions:
-        title: Decisions
-        collapsed: true
-        items:
-          title: Decision
-      actionItems:
-        title: Action Items
-        collapsed: true
-        items:
-          title: Action Item
-  actions:
-    - type: button
-      widget: button
+  widgets:
+    - widget: form
       options:
-        transition: confirm
-        label: 'Confirm'
+        order:
+          - date
+          - summary
+          - participants
+          - decisions
+          - actionItems
+        properties:
+          date:
+            title: Date
+          summary:
+            title: Summary
+            widget: textarea
+          participants:
+            title: Participants
+            collapsed: true
+            items:
+              title: Participant
+          decisions:
+            title: Decisions
+            collapsed: true
+            items:
+              title: Decision
+          actionItems:
+            title: Action Items
+            collapsed: true
+            items:
+              title: Action Item
+        actions:
+          - type: button
+            transition: confirm
+            label: 'Confirm'

package/src/meeting-notes-example.module.ts

@@ -1,12 +1,12 @@
 import { Module } from '@nestjs/common';
-import { AiModule } from '@loopstack/ai-module';
-import { CoreUiModule } from '@loopstack/core-ui-module';
+import { ClaudeModule } from '@loopstack/claude-module';
+import { LoopCoreModule } from '@loopstack/core';
 import { MeetingNotesDocument } from './documents/meeting-notes-document';
 import { OptimizedNotesDocument } from './documents/optimized-notes-document';
 import { MeetingNotesWorkflow } from './meeting-notes.workflow';
 
 @Module({
-  imports: [CoreUiModule, AiModule],
+  imports: [LoopCoreModule, ClaudeModule],
   providers: [MeetingNotesWorkflow, MeetingNotesDocument, OptimizedNotesDocument],
   exports: [MeetingNotesWorkflow],
 })

package/src/meeting-notes.ui.yaml

@@ -0,0 +1,10 @@
+title: 'Human-in-the-loop Demo (Meeting Notes Optimizer)'
+
+description: 'A demo workflow to demonstrate how to use AI to structure meeting notes.'
+
+ui:
+  form:
+    properties:
+      inputText:
+        title: 'Text'
+        widget: 'textarea'

package/src/meeting-notes.workflow.ts

@@ -1,43 +1,61 @@
 import { z } from 'zod';
-import { AiGenerateDocument } from '@loopstack/ai-module';
-import { InjectDocument, InjectTool, Input, Runtime, State, Workflow } from '@loopstack/common';
-import { CreateDocument } from '@loopstack/core-ui-module';
+import { ClaudeGenerateDocument } from '@loopstack/claude-module';
+import { BaseWorkflow, Final, Initial, InjectTool, Transition, Workflow } from '@loopstack/common';
 import { MeetingNotesDocument, MeetingNotesDocumentSchema } from './documents/meeting-notes-document';
 import { OptimizedMeetingNotesDocumentSchema, OptimizedNotesDocument } from './documents/optimized-notes-document';
 
 @Workflow({
-  configFile: __dirname + '/meeting-notes.workflow.yaml',
+  uiConfig: __dirname + '/meeting-notes.ui.yaml',
+  schema: z.object({
+    inputText: z
+      .string()
+      .default(
+        '- meeting 1.1.2025\n- budget: need 2 cut costs sarah said\n- hire new person?? --> marketing\n- vendor pricing - follow up needed by anna',
+      ),
+  }),
 })
-export class MeetingNotesWorkflow {
-  @InjectTool() aiGenerateDocument: AiGenerateDocument;
-  @InjectTool() createDocument: CreateDocument;
-  @InjectDocument() meetingNotesDocument: MeetingNotesDocument;
-  @InjectDocument() optimizedNotesDocument: OptimizedNotesDocument;
+export class MeetingNotesWorkflow extends BaseWorkflow<{ inputText: string }> {
+  @InjectTool() claudeGenerateDocument: ClaudeGenerateDocument;
 
-  @Input({
-    schema: z.object({
-      inputText: z
-        .string()
-        .default(
-          '- meeting 1.1.2025\n- budget: need 2 cut costs sarah said\n- hire new person?? --> marketing\n- vendor pricing - follow up needed by anna',
-        ),
-    }),
-  })
-  args: {
-    inputText: string;
-  };
+  meetingNotes?: z.infer<typeof MeetingNotesDocumentSchema>;
+  optimizedNotes?: z.infer<typeof OptimizedMeetingNotesDocumentSchema>;
 
-  @State({
-    schema: z.object({
-      meetingNotes: MeetingNotesDocumentSchema.optional(),
-      optimizedNotes: OptimizedMeetingNotesDocumentSchema.optional(),
-    }),
-  })
-  state: {
-    meetingNotes?: z.infer<typeof MeetingNotesDocumentSchema>;
-    optimizedNotes?: z.infer<typeof OptimizedMeetingNotesDocumentSchema>;
-  };
+  @Initial({ to: 'waiting_for_response' })
+  async createForm(args: { inputText: string }) {
+    await this.repository.save(
+      MeetingNotesDocument,
+      {
+        text: `Unstructured Notes:\n\n${args.inputText}`,
+      },
+      { id: 'input' },
+    );
+  }
 
-  @Runtime()
-  runtime: any;
+  @Transition({ from: 'waiting_for_response', to: 'response_received', wait: true, schema: MeetingNotesDocumentSchema })
+  async userResponse(payload: z.infer<typeof MeetingNotesDocumentSchema>) {
+    const result = await this.repository.save(MeetingNotesDocument, payload, { id: 'input' });
+    this.meetingNotes = result.content as z.infer<typeof MeetingNotesDocumentSchema>;
+  }
+
+  @Transition({ from: 'response_received', to: 'notes_optimized' })
+  async optimizeNotes() {
+    await this.claudeGenerateDocument.call({
+      claude: { model: 'claude-sonnet-4-6' },
+      response: {
+        id: 'final',
+        document: OptimizedNotesDocument,
+      },
+      prompt: `Extract all information from the provided meeting notes into the structured document.
+
+<Meeting Notes>
+${this.meetingNotes?.text}
+</Meeting Notes>`,
+    });
+  }
+
+  @Final({ from: 'notes_optimized', wait: true, schema: OptimizedMeetingNotesDocumentSchema })
+  async confirm(payload: z.infer<typeof OptimizedMeetingNotesDocumentSchema>) {
+    const result = await this.repository.save(OptimizedNotesDocument, payload, { id: 'final' });
+    this.optimizedNotes = result.content as z.infer<typeof OptimizedMeetingNotesDocumentSchema>;
+  }
 }