@loopstack/github-oauth-example 0.1.1 → 0.2.1

package/src/workflows/__tests__/github-repos-overview-workflow.spec.ts

@@ -1,17 +1,7 @@
 import { TestingModule } from '@nestjs/testing';
 import { z } from 'zod';
-import {
-  RunContext,
-  generateObjectFingerprint,
-  getBlockArgsSchema,
-  getBlockConfig,
-  getBlockDocuments,
-  getBlockHelper,
-  getBlockHelpers,
-  getBlockStateSchema,
-  getBlockTools,
-} from '@loopstack/common';
-import { CreateDocument, LoopCoreModule, Task, WorkflowProcessorService } from '@loopstack/core';
+import { RunContext, WorkflowEntity, getBlockArgsSchema, getBlockConfig, getBlockTools } from '@loopstack/common';
+import { LoopCoreModule, WorkflowProcessorService } from '@loopstack/core';
 import { CreateChatMessage, CreateChatMessageToolModule } from '@loopstack/create-chat-message-tool';
 import {
   GitHubCreateIssueCommentTool,
@@ -40,10 +30,14 @@ import {
   GitHubSearchReposTool,
   GitHubTriggerWorkflowTool,
 } from '@loopstack/github-module';
-import { OAuthModule } from '@loopstack/oauth-module';
-import { ToolMock, createWorkflowTest } from '@loopstack/testing';
+import { OAuthModule, OAuthWorkflow } from '@loopstack/oauth-module';
+import { ToolMock, createStatelessContext, createWorkflowTest } from '@loopstack/testing';
 import { GitHubReposOverviewWorkflow } from '../github-repos-overview.workflow';
 
+const mockOAuthWorkflow = {
+  run: jest.fn(),
+};
+
 function applyAllGitHubToolMocks(builder: ReturnType<typeof createWorkflowTest>) {
   return builder
     .withToolMock(GitHubGetAuthenticatedUserTool)
@@ -73,6 +67,16 @@ function applyAllGitHubToolMocks(builder: ReturnType<typeof createWorkflowTest>)
     .withToolMock(GitHubSearchIssuesTool);
 }
 
+function buildWorkflowTest() {
+  return applyAllGitHubToolMocks(
+    createWorkflowTest()
+      .forWorkflow(GitHubReposOverviewWorkflow)
+      .withImports(LoopCoreModule, CreateChatMessageToolModule, OAuthModule)
+      .withMock(OAuthWorkflow, mockOAuthWorkflow)
+      .withToolOverride(CreateChatMessage),
+  );
+}
+
 describe('GitHubReposOverviewWorkflow', () => {
   let module: TestingModule;
   let workflow: GitHubReposOverviewWorkflow;
@@ -87,21 +91,10 @@ describe('GitHubReposOverviewWorkflow', () => {
   let mockListDirectory: ToolMock;
   let mockListWorkflowRuns: ToolMock;
   let mockSearchCode: ToolMock;
-  let mockTask: ToolMock;
-  let mockCreateDocument: ToolMock;
-
-  function buildWorkflowTest() {
-    return applyAllGitHubToolMocks(
-      createWorkflowTest()
-        .forWorkflow(GitHubReposOverviewWorkflow)
-        .withImports(LoopCoreModule, CreateChatMessageToolModule, OAuthModule)
-        .withToolOverride(Task)
-        .withToolOverride(CreateDocument)
-        .withToolOverride(CreateChatMessage),
-    );
-  }
 
   beforeEach(async () => {
+    jest.clearAllMocks();
+
     module = await buildWorkflowTest().compile();
 
     workflow = module.get(GitHubReposOverviewWorkflow);
@@ -116,8 +109,6 @@ describe('GitHubReposOverviewWorkflow', () => {
     mockListDirectory = module.get(GitHubListDirectoryTool);
     mockListWorkflowRuns = module.get(GitHubListWorkflowRunsTool);
     mockSearchCode = module.get(GitHubSearchCodeTool);
-    mockTask = module.get(Task);
-    mockCreateDocument = module.get(CreateDocument);
   });
 
   afterEach(async () => {
@@ -136,71 +127,24 @@ describe('GitHubReposOverviewWorkflow', () => {
       expect(getBlockArgsSchema(workflow)).toBeInstanceOf(z.ZodType);
     });
 
-    it('should have stateSchema defined', () => {
-      expect(getBlockStateSchema(workflow)).toBeDefined();
-      expect(getBlockStateSchema(workflow)).toBeInstanceOf(z.ZodType);
-    });
-
     it('should have config defined', () => {
       expect(getBlockConfig(workflow)).toBeDefined();
     });
 
-    it('should have all 28 tools available', () => {
+    it('should have GitHub tools available', () => {
       const tools = getBlockTools(workflow);
       expect(tools).toBeDefined();
-      expect(tools).toHaveLength(28);
-
-      // Core tools
-      expect(tools).toContain('task');
-      expect(tools).toContain('createDocument');
-      expect(tools).toContain('createChatMessage');
 
-      // GitHub — Users
       expect(tools).toContain('gitHubGetAuthenticatedUser');
       expect(tools).toContain('gitHubListUserOrgs');
-
-      // GitHub — Repos
-      expect(tools).toContain('gitHubListRepos');
       expect(tools).toContain('gitHubGetRepo');
-      expect(tools).toContain('gitHubCreateRepo');
-      expect(tools).toContain('gitHubListBranches');
 
-      // GitHub — Issues
+      expect(tools).toContain('gitHubListBranches');
       expect(tools).toContain('gitHubListIssues');
-      expect(tools).toContain('gitHubGetIssue');
-      expect(tools).toContain('gitHubCreateIssue');
-      expect(tools).toContain('gitHubCreateIssueComment');
-
-      // GitHub — Pull Requests
       expect(tools).toContain('gitHubListPullRequests');
-      expect(tools).toContain('gitHubGetPullRequest');
-      expect(tools).toContain('gitHubCreatePullRequest');
-      expect(tools).toContain('gitHubMergePullRequest');
-      expect(tools).toContain('gitHubListPrReviews');
-
-      // GitHub — Content
-      expect(tools).toContain('gitHubGetFileContent');
-      expect(tools).toContain('gitHubCreateOrUpdateFile');
       expect(tools).toContain('gitHubListDirectory');
-      expect(tools).toContain('gitHubGetCommit');
-
-      // GitHub — Actions
       expect(tools).toContain('gitHubListWorkflowRuns');
-      expect(tools).toContain('gitHubTriggerWorkflow');
-      expect(tools).toContain('gitHubGetWorkflowRun');
-
-      // GitHub — Search
       expect(tools).toContain('gitHubSearchCode');
-      expect(tools).toContain('gitHubSearchRepos');
-      expect(tools).toContain('gitHubSearchIssues');
-    });
-
-    it('should have all documents available', () => {
-      expect(getBlockDocuments(workflow)).toBeDefined();
-      expect(Array.isArray(getBlockDocuments(workflow))).toBe(true);
-      expect(getBlockDocuments(workflow)).toContain('linkDocument');
-      expect(getBlockDocuments(workflow)).toContain('markdown');
-      expect(getBlockDocuments(workflow)).toHaveLength(2);
     });
   });
 
@@ -235,61 +179,11 @@ describe('GitHubReposOverviewWorkflow', () => {
     });
   });
 
-  describe('states', () => {
-    it('should have stateSchema with expected properties', () => {
-      const schema = getBlockStateSchema(workflow) as z.ZodObject<any>;
-      expect(schema).toBeDefined();
-      const shape = schema.shape;
-      expect(shape.requiresAuthentication).toBeDefined();
-      expect(shape.user).toBeDefined();
-      expect(shape.orgs).toBeDefined();
-      expect(shape.repo).toBeDefined();
-      expect(shape.branches).toBeDefined();
-      expect(shape.issues).toBeDefined();
-      expect(shape.pullRequests).toBeDefined();
-      expect(shape.directoryEntries).toBeDefined();
-      expect(shape.workflowRuns).toBeDefined();
-      expect(shape.searchResults).toBeDefined();
-    });
-
-    it('should validate state with all optional fields', () => {
-      const schema = getBlockStateSchema(workflow)!;
-      const result = schema.parse({});
-      expect(result).toEqual({});
-    });
-
-    it('should throw error for invalid state field types', () => {
-      const schema = getBlockStateSchema(workflow)!;
-      expect(() => schema.parse({ repos: 'not-an-array' })).toThrow();
-      expect(() => schema.parse({ requiresAuthentication: 'not-a-boolean' })).toThrow();
-    });
-  });
-
-  describe('helpers', () => {
-    it('should have helpers defined', () => {
-      expect(getBlockHelpers(workflow)).toBeDefined();
-      expect(Array.isArray(getBlockHelpers(workflow))).toBe(true);
-    });
-
-    it('should have searchQuery helper registered', () => {
-      expect(getBlockHelpers(workflow)).toContain('searchQuery');
-    });
-
-    it('should execute searchQuery helper and return repo-scoped query', () => {
-      // Set args on the workflow instance so the helper can read them
-      (workflow as any).args = { owner: 'octocat', repo: 'Hello-World' };
-      const helper = getBlockHelper(workflow, 'searchQuery')!;
-      expect(helper).toBeDefined();
-      const result = helper.call(workflow);
-      expect(result).toBe('repo:octocat/Hello-World');
-    });
-  });
-
   describe('workflow execution — happy path', () => {
     const args = { owner: 'octocat', repo: 'Hello-World' };
 
     function setupAllMocks() {
-      mockGetAuthenticatedUser.execute.mockResolvedValue({
+      mockGetAuthenticatedUser.call.mockResolvedValue({
         data: {
           user: {
             id: 1,
@@ -307,13 +201,13 @@ describe('GitHubReposOverviewWorkflow', () => {
         },
       });
 
-      mockListUserOrgs.execute.mockResolvedValue({
+      mockListUserOrgs.call.mockResolvedValue({
         data: {
           orgs: [{ id: 1, login: 'github', description: 'How people build software', avatarUrl: '' }],
         },
       });
 
-      mockGetRepo.execute.mockResolvedValue({
+      mockGetRepo.call.mockResolvedValue({
         data: {
           repo: {
             id: 1296269,
@@ -337,7 +231,7 @@ describe('GitHubReposOverviewWorkflow', () => {
         },
       });
 
-      mockListBranches.execute.mockResolvedValue({
+      mockListBranches.call.mockResolvedValue({
         data: {
           branches: [
             { name: 'main', commitSha: 'abc123', protected: true },
@@ -346,7 +240,7 @@ describe('GitHubReposOverviewWorkflow', () => {
         },
       });
 
-      mockListIssues.execute.mockResolvedValue({
+      mockListIssues.call.mockResolvedValue({
         data: {
           issues: [
             {
@@ -366,7 +260,7 @@ describe('GitHubReposOverviewWorkflow', () => {
         },
       });
 
-      mockListPullRequests.execute.mockResolvedValue({
+      mockListPullRequests.call.mockResolvedValue({
         data: {
           pullRequests: [
             {
@@ -387,7 +281,7 @@ describe('GitHubReposOverviewWorkflow', () => {
         },
       });
 
-      mockListDirectory.execute.mockResolvedValue({
+      mockListDirectory.call.mockResolvedValue({
         data: {
           entries: [
             { name: 'README.md', path: 'README.md', sha: 'abc', size: 1234, type: 'file', htmlUrl: '' },
@@ -396,7 +290,7 @@ describe('GitHubReposOverviewWorkflow', () => {
         },
       });
 
-      mockListWorkflowRuns.execute.mockResolvedValue({
+      mockListWorkflowRuns.call.mockResolvedValue({
         data: {
           totalCount: 1,
           runs: [
@@ -416,7 +310,7 @@ describe('GitHubReposOverviewWorkflow', () => {
         },
       });
 
-      mockSearchCode.execute.mockResolvedValue({
+      mockSearchCode.call.mockResolvedValue({
         data: {
           totalCount: 1,
           results: [
@@ -426,8 +320,8 @@ describe('GitHubReposOverviewWorkflow', () => {
       });
     }
 
-    it('should execute full pipeline from start to end', async () => {
-      const context = {} as RunContext;
+    it('should execute full workflow from start to end', async () => {
+      const context = createStatelessContext();
       setupAllMocks();
 
       const result = await processor.process(workflow, args, context);
@@ -436,131 +330,121 @@ describe('GitHubReposOverviewWorkflow', () => {
       expect(result.hasError).toBe(false);
       expect(result.place).toBe('end');
 
+      // Verify markdown document was created
+      expect(result.documents).toEqual(
+        expect.arrayContaining([expect.objectContaining({ className: 'MarkdownDocument' })]),
+      );
+
       // Verify all read tools were called
-      expect(mockGetAuthenticatedUser.execute).toHaveBeenCalledTimes(1);
-      expect(mockListUserOrgs.execute).toHaveBeenCalledTimes(1);
-      expect(mockGetRepo.execute).toHaveBeenCalledTimes(1);
-      expect(mockListBranches.execute).toHaveBeenCalledTimes(1);
-      expect(mockListIssues.execute).toHaveBeenCalledTimes(1);
-      expect(mockListPullRequests.execute).toHaveBeenCalledTimes(1);
-      expect(mockListDirectory.execute).toHaveBeenCalledTimes(1);
-      expect(mockListWorkflowRuns.execute).toHaveBeenCalledTimes(1);
-      expect(mockSearchCode.execute).toHaveBeenCalledTimes(1);
-      expect(mockCreateDocument.execute).toHaveBeenCalledTimes(1);
+      expect(mockGetAuthenticatedUser.call).toHaveBeenCalledTimes(1);
+      expect(mockListUserOrgs.call).toHaveBeenCalledTimes(1);
+      expect(mockGetRepo.call).toHaveBeenCalledTimes(1);
+      expect(mockListBranches.call).toHaveBeenCalledTimes(1);
+      expect(mockListIssues.call).toHaveBeenCalledTimes(1);
+      expect(mockListPullRequests.call).toHaveBeenCalledTimes(1);
+      expect(mockListDirectory.call).toHaveBeenCalledTimes(1);
+      expect(mockListWorkflowRuns.call).toHaveBeenCalledTimes(1);
+      expect(mockSearchCode.call).toHaveBeenCalledTimes(1);
     });
 
     it('should pass owner and repo to gitHubGetRepo', async () => {
-      const context = {} as RunContext;
+      const context = createStatelessContext();
       setupAllMocks();
 
       await processor.process(workflow, args, context);
 
-      expect(mockGetRepo.execute).toHaveBeenCalledWith(
+      expect(mockGetRepo.call).toHaveBeenCalledWith(
         expect.objectContaining({ owner: 'octocat', repo: 'Hello-World' }),
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
+        undefined,
       );
     });
 
     it('should pass owner and repo to gitHubListBranches', async () => {
-      const context = {} as RunContext;
+      const context = createStatelessContext();
       setupAllMocks();
 
       await processor.process(workflow, args, context);
 
-      expect(mockListBranches.execute).toHaveBeenCalledWith(
+      expect(mockListBranches.call).toHaveBeenCalledWith(
         expect.objectContaining({ owner: 'octocat', repo: 'Hello-World' }),
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
+        undefined,
       );
     });
 
     it('should pass owner and repo to gitHubListIssues with state open', async () => {
-      const context = {} as RunContext;
+      const context = createStatelessContext();
       setupAllMocks();
 
       await processor.process(workflow, args, context);
 
-      expect(mockListIssues.execute).toHaveBeenCalledWith(
+      expect(mockListIssues.call).toHaveBeenCalledWith(
         expect.objectContaining({ owner: 'octocat', repo: 'Hello-World', state: 'open' }),
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
+        undefined,
       );
     });
 
     it('should pass owner and repo to gitHubListPullRequests', async () => {
-      const context = {} as RunContext;
+      const context = createStatelessContext();
       setupAllMocks();
 
       await processor.process(workflow, args, context);
 
-      expect(mockListPullRequests.execute).toHaveBeenCalledWith(
+      expect(mockListPullRequests.call).toHaveBeenCalledWith(
         expect.objectContaining({ owner: 'octocat', repo: 'Hello-World', state: 'open' }),
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
+        undefined,
       );
     });
 
     it('should pass owner and repo to gitHubListDirectory', async () => {
-      const context = {} as RunContext;
+      const context = createStatelessContext();
       setupAllMocks();
 
       await processor.process(workflow, args, context);
 
-      expect(mockListDirectory.execute).toHaveBeenCalledWith(
+      expect(mockListDirectory.call).toHaveBeenCalledWith(
         expect.objectContaining({ owner: 'octocat', repo: 'Hello-World' }),
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
+        undefined,
       );
     });
 
     it('should pass owner and repo to gitHubListWorkflowRuns', async () => {
-      const context = {} as RunContext;
+      const context = createStatelessContext();
       setupAllMocks();
 
       await processor.process(workflow, args, context);
 
-      expect(mockListWorkflowRuns.execute).toHaveBeenCalledWith(
+      expect(mockListWorkflowRuns.call).toHaveBeenCalledWith(
         expect.objectContaining({ owner: 'octocat', repo: 'Hello-World' }),
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
+        undefined,
       );
     });
 
     it('should pass repo-scoped query to gitHubSearchCode', async () => {
-      const context = {} as RunContext;
+      const context = createStatelessContext();
       setupAllMocks();
 
       await processor.process(workflow, args, context);
 
-      expect(mockSearchCode.execute).toHaveBeenCalledWith(
+      expect(mockSearchCode.call).toHaveBeenCalledWith(
         expect.objectContaining({ query: 'repo:octocat/Hello-World' }),
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
+        undefined,
       );
     });
   });
 
   describe('workflow execution — auth flow', () => {
     it('should stop at awaiting_auth when unauthorized', async () => {
-      const context = {} as RunContext;
+      const context = createStatelessContext();
 
-      mockGetAuthenticatedUser.execute.mockResolvedValue({
+      mockGetAuthenticatedUser.call.mockResolvedValue({
         data: {
           error: 'unauthorized',
           message: 'No valid GitHub token found. Please authenticate first.',
         },
       });
 
-      mockTask.execute.mockResolvedValue({
-        data: { pipelineId: 'test-pipeline-id' },
+      mockOAuthWorkflow.run.mockResolvedValue({
+        workflowId: 'test-workflow-id',
       });
 
       const result = await processor.process(workflow, { owner: 'octocat', repo: 'Hello-World' }, context);
@@ -570,25 +454,19 @@ describe('GitHubReposOverviewWorkflow', () => {
       expect(result.stop).toBe(true);
       expect(result.place).toBe('awaiting_auth');
 
-      expect(mockGetAuthenticatedUser.execute).toHaveBeenCalledTimes(1);
-      expect(mockTask.execute).toHaveBeenCalledTimes(1);
-      expect(mockTask.execute).toHaveBeenCalledWith(
+      expect(mockGetAuthenticatedUser.call).toHaveBeenCalledTimes(1);
+      expect(mockOAuthWorkflow.run).toHaveBeenCalledTimes(1);
+      expect(mockOAuthWorkflow.run).toHaveBeenCalledWith(
+        { provider: 'github', scopes: ['repo', 'read:org', 'workflow'] },
         expect.objectContaining({
-          workflow: 'oAuth',
-          args: expect.objectContaining({
-            provider: 'github',
-            scopes: ['repo', 'read:org', 'workflow'],
-          }),
-          callback: { transition: 'auth_completed' },
+          alias: 'oAuth',
+          callback: { transition: 'authCompleted' },
         }),
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
       );
 
       // Subsequent tools should NOT be called
-      expect(mockListUserOrgs.execute).not.toHaveBeenCalled();
-      expect(mockGetRepo.execute).not.toHaveBeenCalled();
+      expect(mockListUserOrgs.call).not.toHaveBeenCalled();
+      expect(mockGetRepo.call).not.toHaveBeenCalled();
     });
   });
 });
@@ -596,17 +474,6 @@ describe('GitHubReposOverviewWorkflow', () => {
 describe('GitHubReposOverviewWorkflow with existing entity', () => {
   let module: TestingModule;
 
-  function buildWorkflowTest() {
-    return applyAllGitHubToolMocks(
-      createWorkflowTest()
-        .forWorkflow(GitHubReposOverviewWorkflow)
-        .withImports(LoopCoreModule, CreateChatMessageToolModule, OAuthModule)
-        .withToolOverride(Task)
-        .withToolOverride(CreateDocument)
-        .withToolOverride(CreateChatMessage),
-    );
-  }
-
   afterEach(async () => {
     if (module) {
       await module.close();
@@ -617,16 +484,9 @@ describe('GitHubReposOverviewWorkflow with existing entity', () => {
     const workflowId = '00000000-0000-0000-0000-000000000001';
     const args = { owner: 'octocat', repo: 'Hello-World' };
 
-    module = await buildWorkflowTest()
-      .withExistingWorkflow({
-        place: 'awaiting_auth',
-        inputData: args,
-        id: workflowId,
-        hashRecord: {
-          options: generateObjectFingerprint(args),
-        },
-      })
-      .compile();
+    jest.clearAllMocks();
+
+    module = await buildWorkflowTest().compile();
 
     const workflow = module.get(GitHubReposOverviewWorkflow);
     const processor = module.get(WorkflowProcessorService);
@@ -639,10 +499,9 @@ describe('GitHubReposOverviewWorkflow with existing entity', () => {
     const mockListDirectory: ToolMock = module.get(GitHubListDirectoryTool);
     const mockListWorkflowRuns: ToolMock = module.get(GitHubListWorkflowRunsTool);
     const mockSearchCode: ToolMock = module.get(GitHubSearchCodeTool);
-    const mockCreateDocument: ToolMock = module.get(CreateDocument);
 
     // After auth, the workflow retries from start and succeeds
-    mockGetAuthenticatedUser.execute.mockResolvedValue({
+    mockGetAuthenticatedUser.call.mockResolvedValue({
       data: {
         user: {
           id: 1,
@@ -659,8 +518,8 @@ describe('GitHubReposOverviewWorkflow with existing entity', () => {
         },
       },
     });
-    mockListUserOrgs.execute.mockResolvedValue({ data: { orgs: [] } });
-    mockGetRepo.execute.mockResolvedValue({
+    mockListUserOrgs.call.mockResolvedValue({ data: { orgs: [] } });
+    mockGetRepo.call.mockResolvedValue({
       data: {
         repo: {
           id: 1,
@@ -683,19 +542,24 @@ describe('GitHubReposOverviewWorkflow with existing entity', () => {
         },
       },
     });
-    mockListBranches.execute.mockResolvedValue({ data: { branches: [] } });
-    mockListIssues.execute.mockResolvedValue({ data: { issues: [] } });
-    mockListPullRequests.execute.mockResolvedValue({ data: { pullRequests: [] } });
-    mockListDirectory.execute.mockResolvedValue({ data: { entries: [] } });
-    mockListWorkflowRuns.execute.mockResolvedValue({ data: { totalCount: 0, runs: [] } });
-    mockSearchCode.execute.mockResolvedValue({ data: { totalCount: 0, results: [] } });
+    mockListBranches.call.mockResolvedValue({ data: { branches: [] } });
+    mockListIssues.call.mockResolvedValue({ data: { issues: [] } });
+    mockListPullRequests.call.mockResolvedValue({ data: { pullRequests: [] } });
+    mockListDirectory.call.mockResolvedValue({ data: { entries: [] } });
+    mockListWorkflowRuns.call.mockResolvedValue({ data: { totalCount: 0, runs: [] } });
+    mockSearchCode.call.mockResolvedValue({ data: { totalCount: 0, results: [] } });
 
     const context = {
+      workflowEntity: {
+        id: workflowId,
+        place: 'awaiting_auth',
+        documents: [],
+      } as Partial<WorkflowEntity>,
       payload: {
         transition: {
-          id: 'auth_completed',
+          id: 'authCompleted',
           workflowId,
-          payload: { pipelineId: 'auth-pipeline-id' },
+          payload: { workflowId: 'auth-workflow-id', status: 'completed', data: {} },
         },
       },
     } as unknown as RunContext;
@@ -706,20 +570,12 @@ describe('GitHubReposOverviewWorkflow with existing entity', () => {
     expect(result.hasError).toBe(false);
     expect(result.place).toBe('end');
 
-    expect(mockCreateDocument.execute).toHaveBeenCalled();
-    expect(mockGetAuthenticatedUser.execute).toHaveBeenCalledTimes(1);
-    expect(mockGetRepo.execute).toHaveBeenCalledTimes(1);
-  });
-
-  it('should resume from existing workflow state', async () => {
-    module = await buildWorkflowTest()
-      .withExistingWorkflow({
-        place: 'repo_fetched',
-        inputData: { owner: 'octocat', repo: 'Hello-World' },
-      })
-      .compile();
+    // Verify markdown document was created after auth resume
+    expect(result.documents).toEqual(
+      expect.arrayContaining([expect.objectContaining({ className: 'MarkdownDocument' })]),
+    );
 
-    const workflow = module.get(GitHubReposOverviewWorkflow);
-    expect(workflow).toBeDefined();
+    expect(mockGetAuthenticatedUser.call).toHaveBeenCalledTimes(1);
+    expect(mockGetRepo.call).toHaveBeenCalledTimes(1);
   });
 });

package/src/workflows/github-agent.ui.yaml

@@ -0,0 +1,16 @@
+title: 'GitHub Agent'
+
+description: |
+  An interactive chat agent with access to GitHub.
+  Ask it to manage repositories, issues, pull requests, browse code, check CI/CD status,
+  search across GitHub, and more. Handles OAuth authentication automatically when needed —
+  the agent detects unauthorized errors and launches authentication on its own.
+
+ui:
+  widgets:
+    - widget: prompt-input
+      enabledWhen:
+        - waiting_for_user
+      options:
+        transition: userMessage
+        label: Send Message