@loopstack/google-oauth-example

start -> calendar_fetched -> end

calendar_fetched -> (unauthorized via @Guard) -> awaiting_auth
                                                    |
                                              auth_completed -> start (retry)

@Transition({ to: 'calendar_fetched' })
async fetchEvents(state: CalendarSummaryState, ctx: WorkflowContext): Promise<CalendarSummaryState> {
  const args = ctx.input.args as { calendarId: string };
  const result = await this.googleCalendarFetchEvents.call({
    calendarId: args.calendarId,
    timeMin: this.now(),
    timeMax: this.endOfWeek(),
  });
  return {
    ...state,
    requiresAuthentication: result.data!.error === 'unauthorized',
    events: result.data!.events,
  };
}
 
@Transition({ from: 'calendar_fetched', to: 'awaiting_auth', priority: 10 })
@Guard('needsAuth')
async authRequired() {
  const result = await this.orchestrator.queue(
    { provider: 'google', scopes: ['https://www.googleapis.com/auth/calendar.readonly'] },
    { workflowName: OAuthWorkflow.name, callback: { transition: 'authCompleted' } },
  );
 
  await this.documentStore.save(
    LinkDocument,
    {
      label: 'Google authentication required',
      workflowId: result.workflowId,
      embed: true,
      expanded: true,
    },
    { id: `link_${result.workflowId}` },
  );
}
 
needsAuth(state: CalendarSummaryState): boolean {
  return !!state.requiresAuthentication;
}

@Transition({
  from: 'awaiting_auth',
  to: 'start',
  wait: true,
  schema: CallbackSchema,
})
async authCompleted(state: CalendarSummaryState, payload: { workflowId: string }): Promise<CalendarSummaryState> {
  await this.documentStore.save(
    LinkDocument,
    {
      status: 'success',
      label: 'Google authentication completed',
      workflowId: payload.workflowId,
      embed: true,
      expanded: false,
    },
    { id: `link_${payload.workflowId}` },
  );
  return state;
}

@Transition({ from: 'calendar_fetched', to: 'end' })
async displayResults(state: CalendarSummaryState): Promise<unknown> {
  await this.documentStore.save(MarkdownDocument, {
    markdown: this.render(__dirname + '/templates/calendarSummary.md', { events: state.events }),
  });
  return {};
}

@InjectTool({
  provider: 'claude',
  model: 'claude-sonnet-4-6',
  system: `You are a helpful Google Workspace assistant with access to Calendar, Gmail, and Drive tools.
When a tool returns an unauthorized error, use authenticate_google to let the user sign in,
then retry. Be concise and format results using markdown.`,
  tools: [
    'google_calendar_list_calendars',
    'google_calendar_fetch_events',
    'google_calendar_create_event',
    'gmail_search_messages',
    'gmail_get_message',
    'gmail_send_message',
    'gmail_reply_to_message',
    'google_drive_list_files',
    'google_drive_get_file_metadata',
    'google_drive_download_file',
    'google_drive_upload_file',
    'authenticate_google',
  ],
})
llmGenerateText: LlmGenerateTextTool;
@InjectTool({ provider: 'claude' }) llmDelegateToolCalls: LlmDelegateToolCallsTool;
 
@Transition({ from: 'ready', to: 'prompt_executed' })
async llmTurn() {
  const result: ToolResult<LlmGenerateTextResult> = await this.llmGenerateText.call();
  this.llmResult = result.data;
}
 
@Transition({ from: 'prompt_executed', to: 'awaiting_tools', priority: 10 })
@Guard('hasToolCalls')
async executeToolCalls() {
  const result: ToolResult<LlmDelegateResult> = await this.llmDelegateToolCalls.call({
    message: this.llmResult!.message,
    callback: { transition: 'toolResultReceived' },
  });
  this.delegateResult = result.data;
}
 
hasToolCalls(): boolean {
  return this.llmResult?.message.stopReason === 'tool_use';
}

GOOGLE_CLIENT_ID=your-client-id
GOOGLE_CLIENT_SECRET=your-client-secret
GOOGLE_OAUTH_REDIRECT_URI=http://localhost:5173/oauth/callback

ANTHROPIC_API_KEY=your-anthropic-api-key