Spaces:

AUXteam
/

Maxun

Paused

Maxun / frontend /src /components /views /api.ts

Upload folder using huggingface_hub

6e38ce1 verified 9 months ago

13.4 kB

import { Session, SessionRuns } from "../types/datamodel";
import { getServerUrl } from "../utils";
import { Team, AgentConfig } from "../types/datamodel";
export class SessionAPI {
  private getBaseUrl(): string {
    return getServerUrl();
  }

  private getHeaders(): HeadersInit {
    return {
      "Content-Type": "application/json",
    };
  }

  async listSessions(userId: string): Promise<Session[]> {
    const response = await fetch(
      `${this.getBaseUrl()}/sessions/?user_id=${userId}`,
      {
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status)
      throw new Error(data.message || "Failed to fetch sessions");
    return data.data;
  }

  async getSession(sessionId: number, userId: string): Promise<Session> {
    const response = await fetch(
      `${this.getBaseUrl()}/sessions/${sessionId}?user_id=${userId}`,
      {
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status)
      throw new Error(data.message || "Failed to fetch session");
    return data.data;
  }

  async createSession(
    sessionData: Partial<Session>,
    userId: string
  ): Promise<Session> {
    const session = {
      ...sessionData,
      user_id: userId, // Ensure user_id is included
    };

    const response = await fetch(`${this.getBaseUrl()}/sessions/`, {
      method: "POST",
      headers: this.getHeaders(),
      body: JSON.stringify(session),
    });
    const data = await response.json();
    if (!data.status)
      throw new Error(data.message || "Failed to create session");
    return data.data;
  }

  async updateSession(
    sessionId: number,
    sessionData: Partial<Session>,
    userId: string
  ): Promise<Session> {
    const session = {
      ...sessionData,
      id: sessionId,
      user_id: userId, // Ensure user_id is included
    };

    const response = await fetch(
      `${this.getBaseUrl()}/sessions/${sessionId}?user_id=${userId}`,
      {
        method: "PUT",
        headers: this.getHeaders(),
        body: JSON.stringify(session),
      }
    );
    const data = await response.json();
    if (!data.status)
      throw new Error(data.message || "Failed to update session");
    return data.data;
  }

  // session runs with messages
  async getSessionRuns(
    sessionId: number,
    userId: string
  ): Promise<SessionRuns> {
    const response = await fetch(
      `${this.getBaseUrl()}/sessions/${sessionId}/runs?user_id=${userId}`,
      {
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status)
      throw new Error(data.message || "Failed to fetch session runs");
    return data.data; // Returns { runs: RunMessage[] }
  }

  async deleteSession(sessionId: number, userId: string): Promise<void> {
    const response = await fetch(
      `${this.getBaseUrl()}/sessions/${sessionId}?user_id=${userId}`,
      {
        method: "DELETE",
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status)
      throw new Error(data.message || "Failed to delete session");
  }

  // Adding messages endpoint
  async listSessionMessages(sessionId: number, userId: string): Promise<any[]> {
    // Replace 'any' with proper message type
    const response = await fetch(
      `${this.getBaseUrl()}/sessions/${sessionId}/messages?user_id=${userId}`,
      {
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status)
      throw new Error(data.message || "Failed to fetch messages");
    return data.data;
  }
}

export class TeamAPI {
  private getBaseUrl(): string {
    return getServerUrl();
  }

  private getHeaders(): HeadersInit {
    return {
      "Content-Type": "application/json",
    };
  }

  async listTeams(userId: string): Promise<Team[]> {
    const response = await fetch(
      `${this.getBaseUrl()}/teams/?user_id=${userId}`,
      {
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status) throw new Error(data.message || "Failed to fetch teams");
    return data.data;
  }

  async getTeam(teamId: number, userId: string): Promise<Team> {
    const response = await fetch(
      `${this.getBaseUrl()}/teams/${teamId}?user_id=${userId}`,
      {
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status) throw new Error(data.message || "Failed to fetch team");
    return data.data;
  }

  async createTeam(teamData: Partial<Team>, userId: string): Promise<Team> {
    const team = {
      ...teamData,
      user_id: userId,
    };

    const response = await fetch(`${this.getBaseUrl()}/teams/`, {
      method: "POST",
      headers: this.getHeaders(),
      body: JSON.stringify(team),
    });
    const data = await response.json();
    if (!data.status) throw new Error(data.message || "Failed to create team");
    return data.data;
  }

  async deleteTeam(teamId: number, userId: string): Promise<void> {
    const response = await fetch(
      `${this.getBaseUrl()}/teams/${teamId}?user_id=${userId}`,
      {
        method: "DELETE",
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status) throw new Error(data.message || "Failed to delete team");
  }

  // Team-Agent Link Management
  async linkAgent(teamId: number, agentId: number): Promise<void> {
    const response = await fetch(
      `${this.getBaseUrl()}/teams/${teamId}/agents/${agentId}`,
      {
        method: "POST",
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status)
      throw new Error(data.message || "Failed to link agent to team");
  }

  async linkAgentWithSequence(
    teamId: number,
    agentId: number,
    sequenceId: number
  ): Promise<void> {
    const response = await fetch(
      `${this.getBaseUrl()}/teams/${teamId}/agents/${agentId}/${sequenceId}`,
      {
        method: "POST",
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status)
      throw new Error(
        data.message || "Failed to link agent to team with sequence"
      );
  }

  async unlinkAgent(teamId: number, agentId: number): Promise<void> {
    const response = await fetch(
      `${this.getBaseUrl()}/teams/${teamId}/agents/${agentId}`,
      {
        method: "DELETE",
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status)
      throw new Error(data.message || "Failed to unlink agent from team");
  }

  async getTeamAgents(teamId: number): Promise<AgentConfig[]> {
    const response = await fetch(
      `${this.getBaseUrl()}/teams/${teamId}/agents`,
      {
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status)
      throw new Error(data.message || "Failed to fetch team agents");
    return data.data;
  }
}

export class PlanAPI {
  private getBaseUrl(): string {
    return getServerUrl();
  }

  private getHeaders(): HeadersInit {
    return {
      "Content-Type": "application/json",
    };
  }

  async listPlans(userId: string): Promise<any[]> {
    const response = await fetch(
      `${this.getBaseUrl()}/plans/?user_id=${userId}`,
      {
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status) throw new Error(data.message || "Failed to fetch plans");
    return data.data;
  }

  async getPlan(planId: number, userId: string): Promise<any> {
    const response = await fetch(
      `${this.getBaseUrl()}/plans/${planId}?user_id=${userId}`,
      {
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status) throw new Error(data.message || "Failed to fetch plan");
    return data.data;
  }

  async createPlan(planData: Partial<any>, userId: string): Promise<any> {
    const plan = {
      ...planData,
      user_id: userId,
    };

    const response = await fetch(`${this.getBaseUrl()}/plans/`, {
      method: "POST",
      headers: this.getHeaders(),
      body: JSON.stringify(plan),
    });
    const data = await response.json();
    if (!data.status) throw new Error(data.message || "Failed to create plan");
    return data.data;
  }

  async updatePlan(
    planId: number,
    planData: Partial<any>,
    userId: string
  ): Promise<any> {
    if (!planData.task) {
      console.error("Missing task in planData:", planData);
    }
    if (!planData.steps || !Array.isArray(planData.steps)) {
      console.error("Missing or invalid steps in planData:", planData);
    }

    const { created_at, ...dataWithoutCreatedAt } = planData;

    const plan = {
      ...dataWithoutCreatedAt,
      id: planId,
      user_id: userId,
      updated_at: null, // This will be replaced by the server with current time
    };

    try {
      const response = await fetch(
        `${this.getBaseUrl()}/plans/${planId}?user_id=${userId}`,
        {
          method: "PUT",
          headers: this.getHeaders(),
          body: JSON.stringify(plan),
        }
      );

      const data = await response.json();
      if (!data.status)
        throw new Error(data.message || "Failed to update plan");
      return data.data;
    } catch (error) {
      console.error("Error in updatePlan:", error);
      throw error;
    }
  }

  async deletePlan(planId: number, userId: string): Promise<void> {
    try {
      const response = await fetch(
        `${this.getBaseUrl()}/plans/${planId}?user_id=${userId}`,
        {
          method: "DELETE",
          headers: this.getHeaders(),
        }
      );

      if (!response.ok) {
        throw new Error(
          `Failed to delete plan. Server responded with status: ${response.status}`
        );
      }

      const data = await response.json();

      if (!data.status) {
        throw new Error(data.message || "Failed to delete plan");
      }
    } catch (error) {
      throw error;
    }
  }

  async learnPlan(sessionId: number, userId: string): Promise<any> {
    try {
      const response = await fetch(`${this.getBaseUrl()}/plans/learn_plan`, {
        method: "POST",
        headers: this.getHeaders(),
        body: JSON.stringify({
          session_id: sessionId,
          user_id: userId,
        }),
      });

      if (!response.ok) {
        // Log the complete error response
        const errorText = await response.text();
        console.error("Full error response:", errorText);
        try {
          const errorData = JSON.parse(errorText);
          throw new Error(errorData.detail || response.statusText);
        } catch (e) {
          throw new Error(
            `${response.status} ${response.statusText}: ${errorText}`
          );
        }
      }

      return await response.json();
    } catch (error) {
      console.error("Error learning plan:", error);
      throw error;
    }
  }
}

export class SettingsAPI {
  private getBaseUrl(): string {
    return getServerUrl();
  }

  private getHeaders(): HeadersInit {
    return {
      "Content-Type": "application/json",
    };
  }

  async getSettings(userId: string): Promise<Record<string, any>> {
    const response = await fetch(
      `${this.getBaseUrl()}/settings/?user_id=${userId}`,
      {
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status)
      throw new Error(data.message || "Failed to fetch settings");
    return data.data.config || {}; // Return just the config object
  }

  async updateSettings(
    userId: string,
    config: Record<string, any>
  ): Promise<void> {
    const response = await fetch(`${this.getBaseUrl()}/settings/`, {
      method: "PUT",
      headers: this.getHeaders(),
      body: JSON.stringify({
        user_id: userId,
        config: config,
      }),
    });
    const data = await response.json();
    if (!data.status)
      throw new Error(data.message || "Failed to update settings");
  }

  async getConfigInfo(): Promise<{ has_config_file: boolean; config_file_path: string | null; config_content: any }> {
    const response = await fetch(
      `${this.getBaseUrl()}/settings/config-info`,
      {
        headers: this.getHeaders(),
      }
    );
    const data = await response.json();
    if (!data.status)
      throw new Error(data.message || "Failed to fetch config info");
    return data.data;
  }
}

export class McpAPI {
  private getBaseUrl(): string {
    return getServerUrl();
  }

  private getHeaders(): HeadersInit {
    return {
      "Content-Type": "application/json",
    };
  }

  async testMcpServer(serverConfig: any): Promise<any> {
    const response = await fetch(`${this.getBaseUrl()}/mcp/test-mcp-server`, {
      method: "POST",
      headers: this.getHeaders(),
      body: JSON.stringify({ server_config: serverConfig }),
    });
    const data = await response.json();
    // The MCP endpoint returns the response directly without status/data wrapper
    return data;
  }
}

export const teamAPI = new TeamAPI();
export const sessionAPI = new SessionAPI();
export const planAPI = new PlanAPI();
export const settingsAPI = new SettingsAPI();
export const mcpAPI = new McpAPI();

	import { Session, SessionRuns } from "../types/datamodel";
	import { getServerUrl } from "../utils";
	import { Team, AgentConfig } from "../types/datamodel";
	export class SessionAPI {
	private getBaseUrl(): string {
	return getServerUrl();
	}

	private getHeaders(): HeadersInit {
	return {
	"Content-Type": "application/json",
	};
	}

	async listSessions(userId: string): Promise<Session[]> {
	const response = await fetch(
	`${this.getBaseUrl()}/sessions/?user_id=${userId}`,
	{
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to fetch sessions");
	return data.data;
	}

	async getSession(sessionId: number, userId: string): Promise<Session> {
	const response = await fetch(
	`${this.getBaseUrl()}/sessions/${sessionId}?user_id=${userId}`,
	{
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to fetch session");
	return data.data;
	}

	async createSession(
	sessionData: Partial<Session>,
	userId: string
	): Promise<Session> {
	const session = {
	...sessionData,
	user_id: userId, // Ensure user_id is included
	};

	const response = await fetch(`${this.getBaseUrl()}/sessions/`, {
	method: "POST",
	headers: this.getHeaders(),
	body: JSON.stringify(session),
	});
	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to create session");
	return data.data;
	}

	async updateSession(
	sessionId: number,
	sessionData: Partial<Session>,
	userId: string
	): Promise<Session> {
	const session = {
	...sessionData,
	id: sessionId,
	user_id: userId, // Ensure user_id is included
	};

	const response = await fetch(
	`${this.getBaseUrl()}/sessions/${sessionId}?user_id=${userId}`,
	{
	method: "PUT",
	headers: this.getHeaders(),
	body: JSON.stringify(session),
	}
	);
	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to update session");
	return data.data;
	}

	// session runs with messages
	async getSessionRuns(
	sessionId: number,
	userId: string
	): Promise<SessionRuns> {
	const response = await fetch(
	`${this.getBaseUrl()}/sessions/${sessionId}/runs?user_id=${userId}`,
	{
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to fetch session runs");
	return data.data; // Returns { runs: RunMessage[] }
	}

	async deleteSession(sessionId: number, userId: string): Promise<void> {
	const response = await fetch(
	`${this.getBaseUrl()}/sessions/${sessionId}?user_id=${userId}`,
	{
	method: "DELETE",
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to delete session");
	}

	// Adding messages endpoint
	async listSessionMessages(sessionId: number, userId: string): Promise<any[]> {
	// Replace 'any' with proper message type
	const response = await fetch(
	`${this.getBaseUrl()}/sessions/${sessionId}/messages?user_id=${userId}`,
	{
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to fetch messages");
	return data.data;
	}
	}

	export class TeamAPI {
	private getBaseUrl(): string {
	return getServerUrl();
	}

	private getHeaders(): HeadersInit {
	return {
	"Content-Type": "application/json",
	};
	}

	async listTeams(userId: string): Promise<Team[]> {
	const response = await fetch(
	`${this.getBaseUrl()}/teams/?user_id=${userId}`,
	{
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status) throw new Error(data.message \|\| "Failed to fetch teams");
	return data.data;
	}

	async getTeam(teamId: number, userId: string): Promise<Team> {
	const response = await fetch(
	`${this.getBaseUrl()}/teams/${teamId}?user_id=${userId}`,
	{
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status) throw new Error(data.message \|\| "Failed to fetch team");
	return data.data;
	}

	async createTeam(teamData: Partial<Team>, userId: string): Promise<Team> {
	const team = {
	...teamData,
	user_id: userId,
	};

	const response = await fetch(`${this.getBaseUrl()}/teams/`, {
	method: "POST",
	headers: this.getHeaders(),
	body: JSON.stringify(team),
	});
	const data = await response.json();
	if (!data.status) throw new Error(data.message \|\| "Failed to create team");
	return data.data;
	}

	async deleteTeam(teamId: number, userId: string): Promise<void> {
	const response = await fetch(
	`${this.getBaseUrl()}/teams/${teamId}?user_id=${userId}`,
	{
	method: "DELETE",
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status) throw new Error(data.message \|\| "Failed to delete team");
	}

	// Team-Agent Link Management
	async linkAgent(teamId: number, agentId: number): Promise<void> {
	const response = await fetch(
	`${this.getBaseUrl()}/teams/${teamId}/agents/${agentId}`,
	{
	method: "POST",
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to link agent to team");
	}

	async linkAgentWithSequence(
	teamId: number,
	agentId: number,
	sequenceId: number
	): Promise<void> {
	const response = await fetch(
	`${this.getBaseUrl()}/teams/${teamId}/agents/${agentId}/${sequenceId}`,
	{
	method: "POST",
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status)
	throw new Error(
	data.message \|\| "Failed to link agent to team with sequence"
	);
	}

	async unlinkAgent(teamId: number, agentId: number): Promise<void> {
	const response = await fetch(
	`${this.getBaseUrl()}/teams/${teamId}/agents/${agentId}`,
	{
	method: "DELETE",
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to unlink agent from team");
	}

	async getTeamAgents(teamId: number): Promise<AgentConfig[]> {
	const response = await fetch(
	`${this.getBaseUrl()}/teams/${teamId}/agents`,
	{
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to fetch team agents");
	return data.data;
	}
	}

	export class PlanAPI {
	private getBaseUrl(): string {
	return getServerUrl();
	}

	private getHeaders(): HeadersInit {
	return {
	"Content-Type": "application/json",
	};
	}

	async listPlans(userId: string): Promise<any[]> {
	const response = await fetch(
	`${this.getBaseUrl()}/plans/?user_id=${userId}`,
	{
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status) throw new Error(data.message \|\| "Failed to fetch plans");
	return data.data;
	}

	async getPlan(planId: number, userId: string): Promise<any> {
	const response = await fetch(
	`${this.getBaseUrl()}/plans/${planId}?user_id=${userId}`,
	{
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status) throw new Error(data.message \|\| "Failed to fetch plan");
	return data.data;
	}

	async createPlan(planData: Partial<any>, userId: string): Promise<any> {
	const plan = {
	...planData,
	user_id: userId,
	};

	const response = await fetch(`${this.getBaseUrl()}/plans/`, {
	method: "POST",
	headers: this.getHeaders(),
	body: JSON.stringify(plan),
	});
	const data = await response.json();
	if (!data.status) throw new Error(data.message \|\| "Failed to create plan");
	return data.data;
	}

	async updatePlan(
	planId: number,
	planData: Partial<any>,
	userId: string
	): Promise<any> {
	if (!planData.task) {
	console.error("Missing task in planData:", planData);
	}
	if (!planData.steps \|\| !Array.isArray(planData.steps)) {
	console.error("Missing or invalid steps in planData:", planData);
	}

	const { created_at, ...dataWithoutCreatedAt } = planData;

	const plan = {
	...dataWithoutCreatedAt,
	id: planId,
	user_id: userId,
	updated_at: null, // This will be replaced by the server with current time
	};

	try {
	const response = await fetch(
	`${this.getBaseUrl()}/plans/${planId}?user_id=${userId}`,
	{
	method: "PUT",
	headers: this.getHeaders(),
	body: JSON.stringify(plan),
	}
	);

	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to update plan");
	return data.data;
	} catch (error) {
	console.error("Error in updatePlan:", error);
	throw error;
	}
	}

	async deletePlan(planId: number, userId: string): Promise<void> {
	try {
	const response = await fetch(
	`${this.getBaseUrl()}/plans/${planId}?user_id=${userId}`,
	{
	method: "DELETE",
	headers: this.getHeaders(),
	}
	);

	if (!response.ok) {
	throw new Error(
	`Failed to delete plan. Server responded with status: ${response.status}`
	);
	}

	const data = await response.json();

	if (!data.status) {
	throw new Error(data.message \|\| "Failed to delete plan");
	}
	} catch (error) {
	throw error;
	}
	}

	async learnPlan(sessionId: number, userId: string): Promise<any> {
	try {
	const response = await fetch(`${this.getBaseUrl()}/plans/learn_plan`, {
	method: "POST",
	headers: this.getHeaders(),
	body: JSON.stringify({
	session_id: sessionId,
	user_id: userId,
	}),
	});

	if (!response.ok) {
	// Log the complete error response
	const errorText = await response.text();
	console.error("Full error response:", errorText);
	try {
	const errorData = JSON.parse(errorText);
	throw new Error(errorData.detail \|\| response.statusText);
	} catch (e) {
	throw new Error(
	`${response.status} ${response.statusText}: ${errorText}`
	);
	}
	}

	return await response.json();
	} catch (error) {
	console.error("Error learning plan:", error);
	throw error;
	}
	}
	}

	export class SettingsAPI {
	private getBaseUrl(): string {
	return getServerUrl();
	}

	private getHeaders(): HeadersInit {
	return {
	"Content-Type": "application/json",
	};
	}

	async getSettings(userId: string): Promise<Record<string, any>> {
	const response = await fetch(
	`${this.getBaseUrl()}/settings/?user_id=${userId}`,
	{
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to fetch settings");
	return data.data.config \|\| {}; // Return just the config object
	}

	async updateSettings(
	userId: string,
	config: Record<string, any>
	): Promise<void> {
	const response = await fetch(`${this.getBaseUrl()}/settings/`, {
	method: "PUT",
	headers: this.getHeaders(),
	body: JSON.stringify({
	user_id: userId,
	config: config,
	}),
	});
	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to update settings");
	}

	async getConfigInfo(): Promise<{ has_config_file: boolean; config_file_path: string \| null; config_content: any }> {
	const response = await fetch(
	`${this.getBaseUrl()}/settings/config-info`,
	{
	headers: this.getHeaders(),
	}
	);
	const data = await response.json();
	if (!data.status)
	throw new Error(data.message \|\| "Failed to fetch config info");
	return data.data;
	}
	}

	export class McpAPI {
	private getBaseUrl(): string {
	return getServerUrl();
	}

	private getHeaders(): HeadersInit {
	return {
	"Content-Type": "application/json",
	};
	}

	async testMcpServer(serverConfig: any): Promise<any> {
	const response = await fetch(`${this.getBaseUrl()}/mcp/test-mcp-server`, {
	method: "POST",
	headers: this.getHeaders(),
	body: JSON.stringify({ server_config: serverConfig }),
	});
	const data = await response.json();
	// The MCP endpoint returns the response directly without status/data wrapper
	return data;
	}
	}

	export const teamAPI = new TeamAPI();
	export const sessionAPI = new SessionAPI();
	export const planAPI = new PlanAPI();
	export const settingsAPI = new SettingsAPI();
	export const mcpAPI = new McpAPI();