Sessions

import { client } from './agentmark.client';
import { generateText } from 'ai';

// Create session identifiers
const sessionId = `session-${Date.now()}`;
const sessionName = 'Customer Support Chat #12345';

async function handleUserMessage(message: string) {
  const prompt = await client.loadTextPrompt('chat.prompt.mdx');

  const input = await prompt.format({
    props: { message },
    telemetry: {
      isEnabled: true,
      functionId: 'chat-handler',
      metadata: {
        userId: 'user-123',
        sessionId: sessionId,
        sessionName: sessionName
      }
    }
  });

  const result = await generateText(input);
  return result;
}

// All these calls belong to the same session
await handleUserMessage('Hello!');
await handleUserMessage('What can you help me with?');
await handleUserMessage('Thanks!');

telemetry: {
  isEnabled: true,
  functionId: 'workflow-handler',
  metadata: {
    userId: 'user-123',
    sessionId: 'session-abc',
    sessionName: 'Data Processing Workflow',
    environment: 'production',
    workflowType: 'batch-import',
    recordCount: 1000
  }
}

class ChatSession {
  private sessionId: string;
  private sessionName: string;

  constructor(userId: string) {
    this.sessionId = `chat-${userId}-${Date.now()}`;
    this.sessionName = `Chat with ${userId}`;
  }

  async sendMessage(message: string) {
    const prompt = await client.loadTextPrompt('chat.prompt.mdx');

    const input = await prompt.format({
      props: { message },
      telemetry: {
        isEnabled: true,
        functionId: 'chat-message',
        metadata: {
          sessionId: this.sessionId,
          sessionName: this.sessionName,
          userId: userId
        }
      }
    });

    return await generateText(input);
  }
}

async function processOrder(orderId: string) {
  const sessionId = `order-${orderId}`;
  const sessionName = `Order Processing: ${orderId}`;

  const baseTelemetry = {
    isEnabled: true,
    metadata: {
      sessionId,
      sessionName,
      orderId
    }
  };

  // Step 1: Validate order
  const validatePrompt = await client.loadTextPrompt('validate-order.prompt.mdx');
  const validateInput = await validatePrompt.format({
    props: { orderId },
    telemetry: { ...baseTelemetry, functionId: 'validate-order' }
  });
  await generateText(validateInput);

  // Step 2: Process payment
  const paymentPrompt = await client.loadTextPrompt('process-payment.prompt.mdx');
  const paymentInput = await paymentPrompt.format({
    props: { orderId },
    telemetry: { ...baseTelemetry, functionId: 'process-payment' }
  });
  await generateText(paymentInput);

  // Step 3: Send confirmation
  const confirmPrompt = await client.loadTextPrompt('send-confirmation.prompt.mdx');
  const confirmInput = await confirmPrompt.format({
    props: { orderId },
    telemetry: { ...baseTelemetry, functionId: 'send-confirmation' }
  });
  await generateText(confirmInput);
}

async function processBatch(items: string[]) {
  const sessionId = `batch-${Date.now()}`;
  const sessionName = `Batch Processing: ${items.length} items`;

  for (const item of items) {
    const prompt = await client.loadTextPrompt('process-item.prompt.mdx');

    const input = await prompt.format({
      props: { item },
      telemetry: {
        isEnabled: true,
        functionId: 'batch-item-processor',
        metadata: {
          sessionId,
          sessionName,
          batchSize: items.length,
          itemId: item
        }
      }
    });

    await generateText(input);
  }
}

const sessionId = `workflow-${workflowId}-${Date.now()}`;

telemetry: {
  metadata: { sessionId, sessionName }
}

// Don't reuse sessions across different users or workflows
const newSessionId = `session-${Date.now()}`;

// ❌ Bad - Different IDs for same session
telemetry: { metadata: { sessionId: `${Math.random()}` } }

// ✅ Good - Same ID throughout session
const sessionId = `session-${userId}-${Date.now()}`;
telemetry: { metadata: { sessionId } }

// ❌ Bad
sessionName: "Session 1"

// ✅ Good
sessionName: "Customer Support: Billing Issue #4532"

telemetry: {
  isEnabled: true,
  functionId: 'support-handler',
  metadata: {
    sessionId: sessionId,
    sessionName: 'Customer Support Chat',
    userId: user.id,
    userTier: user.tier,
    issueType: 'billing',
    priority: 'high'
  }
}

// ❌ Bad - Session too broad
const sessionId = 'user-123-session'; // Used forever

// ✅ Good - Session has clear boundaries
const sessionId = `support-${ticketId}-${Date.now()}`; // One ticket

// For long-running applications, create new sessions
class LongRunningService {
  private sessionId: string;
  private sessionStartTime: number;

  async checkSessionRenewal() {
    const hoursSinceStart = (Date.now() - this.sessionStartTime) / 3600000;

    if (hoursSinceStart > 24) {
      // Create new session after 24 hours
      this.sessionId = `service-${Date.now()}`;
      this.sessionStartTime = Date.now();
    }
  }
}