setSession

async setSession(sessionId: string): Promise<void>

const vibeKit = new VibeKit({
  agent: {
    type: "codex", // or "claude"
    model: {
      apiKey: "sk-proj-****"
    },
    mode: "code"
  },
  environment: {
    e2b: {
      apiKey: "e2b_****"
    }
  }
});

// Set a specific session ID
await vibeKit.setSession("session-abc123");

// Verify the session was set
const currentSession = await vibeKit.getSession();
console.log("Active session:", currentSession); // "session-abc123"

// Get the current session
const originalSession = await vibeKit.getSession();
console.log("Original session:", originalSession);

// Switch to a different session
await vibeKit.setSession("session-xyz789");

// Work in the new session
await vibeKit.generateCode("print('Working in new session')");

// Switch back to the original session
if (originalSession) {
  await vibeKit.setSession(originalSession);
  console.log("Switched back to original session");
}

// Restore a session from storage
const savedSessionId = localStorage.getItem('vibekit-session');

if (savedSessionId) {
  try {
    await vibeKit.setSession(savedSessionId);
    console.log("Session restored successfully");
    
    // Continue work in the restored session
    await vibeKit.generateCode("# Continuing previous work");
  } catch (error) {
    console.error("Failed to restore session:", error);
    // Handle invalid or expired session
  }
}

// Define session IDs for different projects
const sessions = {
  projectA: "session-project-a-123",
  projectB: "session-project-b-456",
  projectC: "session-project-c-789"
};

// Switch between projects
async function switchToProject(projectName: keyof typeof sessions) {
  const sessionId = sessions[projectName];
  
  await vibeKit.setSession(sessionId);
  console.log(`Switched to ${projectName} (${sessionId})`);
  
  // Generate project-specific code
  await vibeKit.generateCode(`# Working on ${projectName}`);
}

// Usage
await switchToProject('projectA');
await switchToProject('projectB');

try {
  await vibeKit.setSession("invalid-session-id");
} catch (error) {
  if (error.message.includes('not initialized')) {
    console.error("Agent is not properly initialized");
  } else {
    console.error("Failed to set session:", error.message);
    // Handle invalid session ID
  }
}

// Correct configuration for session management
const config = {
  agent: {
    type: "codex", // or "claude"
    model: {
      apiKey: "your-api-key"
    },
    mode: "code"
  },
  environment: {
    e2b: {
      apiKey: "your-e2b-api-key" // For Codex agent
    }
    // Claude agent may have different environment requirements
  }
};

class SessionManager {
  private vibeKit: VibeKit;
  
  constructor(vibeKit: VibeKit) {
    this.vibeKit = vibeKit;
  }
  
  async saveCurrentSession(): Promise<void> {
    const sessionId = await this.vibeKit.getSession();
    if (sessionId) {
      localStorage.setItem('vibekit-session', sessionId);
    }
  }
  
  async restoreSession(): Promise<boolean> {
    const savedSession = localStorage.getItem('vibekit-session');
    if (savedSession) {
      try {
        await this.vibeKit.setSession(savedSession);
        return true;
      } catch (error) {
        console.error('Failed to restore session:', error);
        // Clean up invalid session
        localStorage.removeItem('vibekit-session');
      }
    }
    return false;
  }
}

class MultiUserSessionManager {
  private vibeKit: VibeKit;
  private userSessions = new Map<string, string>();
  
  constructor(vibeKit: VibeKit) {
    this.vibeKit = vibeKit;
  }
  
  async switchUser(userId: string): Promise<void> {
    const userSessionId = this.userSessions.get(userId);
    
    if (userSessionId) {
      // User has an existing session
      await this.vibeKit.setSession(userSessionId);
    } else {
      // Create new session for user
      await this.vibeKit.generateCode("# Starting new session");
      const newSessionId = await this.vibeKit.getSession();
      if (newSessionId) {
        this.userSessions.set(userId, newSessionId);
      }
    }
  }
  
  async getCurrentUserSession(): Promise<string | null> {
    return await this.vibeKit.getSession();
  }
}

interface ProjectSession {
  id: string;
  name: string;
  sessionId: string;
  lastAccessed: Date;
}

class ProjectManager {
  private vibeKit: VibeKit;
  private projects: ProjectSession[] = [];
  
  constructor(vibeKit: VibeKit) {
    this.vibeKit = vibeKit;
  }
  
  async switchToProject(projectId: string): Promise<void> {
    const project = this.projects.find(p => p.id === projectId);
    
    if (project) {
      await this.vibeKit.setSession(project.sessionId);
      project.lastAccessed = new Date();
      console.log(`Switched to project: ${project.name}`);
    } else {
      throw new Error(`Project ${projectId} not found`);
    }
  }
  
  async createProject(name: string): Promise<string> {
    // Create a new session for the project
    await this.vibeKit.generateCode(`# Project: ${name}`);
    const sessionId = await this.vibeKit.getSession();
    
    if (!sessionId) {
      throw new Error("Failed to create session for project");
    }
    
    const project: ProjectSession = {
      id: crypto.randomUUID(),
      name,
      sessionId,
      lastAccessed: new Date()
    };
    
    this.projects.push(project);
    return project.id;
  }
}