@loopstack/github-oauth-example 0.1.1 → 0.2.1

package/src/tools/authenticate-github-task.tool.ts

@@ -1,22 +1,18 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { z } from 'zod';
-import {
-  InjectDocument,
-  InjectTool,
-  Input,
-  RunContext,
-  Tool,
-  ToolInterface,
-  ToolResult,
-  ToolSideEffects,
-  WorkflowInterface,
-  WorkflowMetadataInterface,
-} from '@loopstack/common';
-import { CreateDocument, LinkDocument, Task } from '@loopstack/core';
+import { BaseTool, InjectWorkflow, Tool, ToolResult } from '@loopstack/common';
+import { LinkDocument } from '@loopstack/core';
+import { OAuthWorkflow } from '@loopstack/oauth-module';
 
 const AuthenticateGitHubTaskInputSchema = z
   .object({
     scopes: z.array(z.string()).describe('The OAuth scopes to request (e.g. repo, user, workflow, read:org)'),
+    callback: z
+      .object({
+        transition: z.string(),
+        metadata: z.record(z.string(), z.unknown()).optional(),
+      })
+      .optional(),
   })
   .strict();
 
@@ -24,102 +20,58 @@ type AuthenticateGitHubTaskInput = z.infer<typeof AuthenticateGitHubTaskInputSch
 
 @Injectable()
 @Tool({
-  config: {
+  uiConfig: {
     description:
       'Launches GitHub OAuth authentication. Shows the user a sign-in prompt to authorize access to GitHub. ' +
       'Use this when a GitHub tool returns an "unauthorized" error. ' +
       'Pass the required OAuth scopes for the GitHub APIs you need access to. ' +
       'IMPORTANT: When using this tool, it must be the ONLY tool call in your response. Do not combine it with other tool calls.',
   },
+  schema: AuthenticateGitHubTaskInputSchema,
 })
-export class AuthenticateGitHubTask implements ToolInterface<AuthenticateGitHubTaskInput> {
+export class AuthenticateGitHubTask extends BaseTool {
   private readonly logger = new Logger(AuthenticateGitHubTask.name);
 
-  @InjectTool() private task: Task;
-  @InjectTool() private createDocument: CreateDocument;
-  @InjectDocument() private linkDocument: LinkDocument;
+  @InjectWorkflow() private oAuth: OAuthWorkflow;
 
-  @Input({ schema: AuthenticateGitHubTaskInputSchema })
-  args: AuthenticateGitHubTaskInput;
-
-  async execute(
-    args: AuthenticateGitHubTaskInput,
-    ctx: RunContext,
-    parent: WorkflowInterface | ToolInterface,
-    metadata: WorkflowMetadataInterface,
-  ): Promise<ToolResult> {
-    const taskResult = await this.task.execute(
-      { workflow: 'oAuth', args: { provider: 'github', scopes: args.scopes } },
-      ctx,
-      parent,
+  async call(args: AuthenticateGitHubTaskInput): Promise<ToolResult> {
+    const result = await this.oAuth.run(
+      { provider: 'github', scopes: args.scopes },
+      { alias: 'oAuth', callback: args.callback },
     );
 
-    const effects: ToolSideEffects[] = [];
-
-    const linkResult = await this.createDocument.execute(
+    await this.repository.save(
+      LinkDocument,
       {
-        document: 'linkDocument',
-        id: 'github_auth_link',
-        validate: 'skip' as const,
-        update: {
-          content: {
-            icon: 'LockKeyhole',
-            label: 'GitHub authentication required',
-            caption: 'Complete sign-in to access GitHub',
-            href: `/pipelines/${String((taskResult.data as Record<string, unknown>).pipelineId)}`,
-            embed: true,
-            expanded: true,
-          },
-        },
+        status: 'pending',
+        label: 'GitHub authentication required',
+        workflowId: result.workflowId,
+        embed: true,
+        expanded: true,
       },
-      ctx,
-      this,
-      metadata,
+      { id: `link_${result.workflowId}` },
     );
-    if (linkResult.effects) {
-      effects.push(...linkResult.effects);
-    }
 
     return {
-      data: taskResult.data as Record<string, unknown>,
-      effects,
+      data: { ...result, mode: 'async' },
     };
   }
 
-  async complete(
-    result: Record<string, unknown>,
-    ctx: RunContext,
-    parent: WorkflowInterface | ToolInterface,
-    metadata: WorkflowMetadataInterface,
-  ): Promise<ToolResult> {
-    const data = result as { pipelineId?: string };
-
-    const effects: ToolSideEffects[] = [];
+  async complete(result: Record<string, unknown>): Promise<ToolResult> {
+    const data = result as { workflowId?: string };
 
-    const linkResult = await this.createDocument.execute(
+    await this.repository.save(
+      LinkDocument,
       {
-        document: 'linkDocument',
-        id: 'github_auth_link',
-        validate: 'skip' as const,
-        update: {
-          content: {
-            icon: 'ShieldCheck',
-            label: 'GitHub authentication completed',
-            href: `/pipelines/${data.pipelineId}`,
-          },
-        },
+        status: 'success',
+        label: 'GitHub authentication completed',
+        workflowId: data.workflowId,
       },
-      ctx,
-      this,
-      metadata,
+      { id: `link_${data.workflowId}` },
     );
-    if (linkResult.effects) {
-      effects.push(...linkResult.effects);
-    }
 
     return {
       data: 'GitHub authentication completed successfully. You can now use GitHub tools.',
-      effects,
     };
   }
 }