HR Interview Coordinator

import { Metorial } from "metorial";
import { metorialAnthropic } from "@metorial/anthropic";
import Anthropic from "@anthropic-ai/sdk";

// Initialize clients
const metorial = new Metorial({
  apiKey: "YOUR_METORIAL_API_KEY",
});

const anthropic = new Anthropic({
  apiKey: "YOUR_ANTHROPIC_API_KEY",
});

// Server deployment credentials
const CALENDAR_DEPLOYMENT_ID = "CALENDAR_DEPLOYMENT_ID";
const CALENDAR_OAUTH_SESSION_ID = "CALENDAR_OAUTH_SESSION_ID";
const GMAIL_DEPLOYMENT_ID = "GMAIL_DEPLOYMENT_ID";
const GMAIL_OAUTH_SESSION_ID = "GMAIL_OAUTH_SESSION_ID";

interface InterviewRequest {
  candidateName: string;
  candidateEmail: string;
  role: string;
  interviewers: string[]; // Email addresses
  durationMinutes: number;
  preferredDates: string[]; // ISO format dates
  interviewType: "technical" | "behavioral" | "panel";
}

async function scheduleInterview(request: InterviewRequest) {
  console.log(`Scheduling ${request.interviewType} interview for ${request.candidateName}...`);

  await metorial.withProviderSession(
    metorialAnthropic,
    {
      serverDeployments: [
        {
          serverDeploymentId: CALENDAR_DEPLOYMENT_ID,
          oauthSessionId: CALENDAR_OAUTH_SESSION_ID,
        },
        {
          serverDeploymentId: GMAIL_DEPLOYMENT_ID,
          oauthSessionId: GMAIL_OAUTH_SESSION_ID,
        },
      ],
      streaming: false,
    },
    async ({ tools, callTools }) => {
      const messages: Anthropic.MessageParam[] = [
        {
          role: "user",
          content: `Schedule interview and send confirmations:

Candidate: ${request.candidateName} (${request.candidateEmail})
Role: ${request.role}
Interviewers: ${request.interviewers.join(", ")}
Duration: ${request.durationMinutes} minutes
Preferred dates: ${request.preferredDates.join(", ")}
Type: ${request.interviewType}

Steps to complete:
1. Check calendar availability for all interviewers on preferred dates
2. Create calendar event with:
   - Title: "${request.role} Interview - ${request.candidateName}"
   - Add all interviewers as attendees
3. Send confirmation email to candidate (${request.candidateEmail}) with:
   - Subject: "Interview Scheduled - ${request.role}"
   - Professional email including: interview date/time, what to prepare, who they'll meet
4. Send prep email to interviewers (${request.interviewers.join(", ")}) with:
   - Subject: "Interview Prep - ${request.candidateName}"
   - Candidate background, interview format, evaluation guidelines

CRITICAL: Only use actual calendar data. If no slots available, inform user. DO NOT create events without checking availability first.`,
        },
      ];

      let response = await anthropic.messages.create({
        model: "claude-sonnet-4-20250514",
        max_tokens: 8192,
        tools: tools,
        messages: messages,
      });

      // Agentic loop - let AI use tools autonomously
      while (response.stop_reason === "tool_use") {
        const toolUseBlocks = response.content.filter(
          (block): block is Anthropic.ToolUseBlock => block.type === "tool_use"
        );

        console.log(`AI using ${toolUseBlocks.length} tool(s)...`);

        const toolResults = await callTools(toolUseBlocks);

        messages.push({ role: "assistant", content: response.content });
        messages.push(toolResults);

        response = await anthropic.messages.create({
          model: "claude-sonnet-4-20250514",
          max_tokens: 8192,
          tools: tools,
          messages: messages,
        });
      }

      // Extract final response
      const finalText = response.content
        .filter((block): block is Anthropic.TextBlock => block.type === "text")
        .map((block) => block.text)
        .join("\n");

      console.log("Interview coordination complete:", finalText);
    }
  );
}

// Example usage
scheduleInterview({
  candidateName: "John Novak",
  candidateEmail: "john.novak@sample.com",
  role: "Senior Software Engineer",
  interviewers: [
    "user@yourCompany.com",  // Hiring manager
  ],
  durationMinutes: 45,
  preferredDates: [
    "2026-02-7T14:00:00Z",  // First preference
    "2026-02-7T5:00:00Z",  // Second preference
    "2026-02-7T15:00:00Z",  // Third preference
  ],
  interviewType: "technical",
});

// Test scenario: Schedule technical interview
await scheduleInterview({
  candidateName: "Alex Rivera",
  candidateEmail: "alex.rivera@example.com",
  role: "Staff Frontend Engineer",
  interviewers: [
    "engineering.director@company.com",
    "senior.engineer@company.com",
    "product.manager@company.com",
  ],
  durationMinutes: 90,  // Panel interview
  preferredDates: [
    "2026-02-15T13:00:00Z",
    "2026-02-16T14:00:00Z",
    "2026-02-17T10:00:00Z",
  ],
  interviewType: "panel",
});