import { AgentsClient } from '@azure/ai-agents';
import { DefaultAzureCredential } from '@azure/identity';
import { parse, stringify } from 'comment-json';
import { readFile } from 'fs/promises';

import dotenv from 'dotenv'
dotenv.config();

// load the mcp.json as MCP tool array
const loadMCPToolFromConfigPath = async (mcpConfigPath: any) => {
  const mcpConfigContent = await readFile(mcpConfigPath, 'utf8');
  const mcpConfig = JSON.parse(stringify(parse(mcpConfigContent, null, true)));
  return {
    tools: Object.keys(mcpConfig.servers).map((serverLabel) => {
      const server = mcpConfig['servers'][serverLabel];
      return {
        type: 'mcp',
        serverLabel,
        serverUrl: server.url
      };
    }),
    toolResources:
    {
      'mcp': Object.keys(mcpConfig.servers).map((serverLabel) => {
        return {
          serverLabel,
          requireApproval: 'never',
          headers: {}
        };
      })
    }
  };
};

const main = async (options: { agent?: { name?: string; instructions?: string }, model: { name: string } }) => {
  if (!process.env.PROJECT_ENDPOINT) {
    throw new Error("Missing PROJECT_ENDPOINT environment variable");
  }

  if (!process.env.MODEL_DEPLOYMENT_NAME) {
    throw new Error("Missing MODEL_DEPLOYMENT_NAME environment variable");
  }

  if (!process.env.API_VERSION) {
    throw new Error("Missing API_VERSION environment variable");
  }

  if (!process.env.MCP_CONFIG_PATH) {
    throw new Error("Missing MCP_CONFIG_PATH environment variable");
  }

  const modelDeploymentName = options.model.name;
  const agentName = options?.agent?.name || `my-agent-${Date.now()}`;
  const agentInstructions = options?.agent?.instructions || "You are a helpful assistant";
  const { tools, toolResources } = await loadMCPToolFromConfigPath(process.env.MCP_CONFIG_PATH);

  const client = new AgentsClient(process.env.PROJECT_ENDPOINT, new DefaultAzureCredential());

  const agent = await client.createAgent(
    modelDeploymentName,
    {
      name: agentName,
      instructions: agentInstructions,
      toolResources, // 効果なし
      tools
    }
  );
  return agent
};

main({
  model: {
    name: process.env.MODEL_DEPLOYMENT_NAME || "gpt-4o"
  },
}).then((data: any) => {
  console.log("Agent created:", data.id);
}).catch((err) => {
  console.error("Error creating agent:", err);
});

import {
  Agent,
  AgentsClient,
  DoneEvent,
  ErrorEvent,
  MessageDeltaChunk,
  MessageDeltaTextContent,
  MessageStreamEvent,
  RequiredToolCall,
  RunsSubmitToolOutputsToRunOptionalParams,
  RunStreamEvent,
  SubmitToolApprovalAction,
  ThreadRun
} from '@azure/ai-agents';
import { DefaultAzureCredential } from '@azure/identity';

import dotenv from 'dotenv'
dotenv.config();

// check if the object is ThreadRun
const isThreadRun = (x: any): x is ThreadRun => {
  return x && typeof x.id === "string";
}

const responseHandler = async (client: AgentsClient, threadId: string, agentOrThreadRun: Agent | ThreadRun) => {
  const streamEventMessages = await (async () => {
    return await (('requiredAction' in agentOrThreadRun)
      ? client.runs.submitToolOutputs(
        threadId, // threadId
        agentOrThreadRun.id, // runId
        [], // toolOutputs
        {
          toolApprovals: (agentOrThreadRun.requiredAction as SubmitToolApprovalAction)?.submitToolApproval.
            toolCalls.map((tc: RequiredToolCall) => ({ toolCallId: tc.id, approve: true })) || []
        } as RunsSubmitToolOutputsToRunOptionalParams // options
      )
      : client.runs.create(
          threadId,
          agentOrThreadRun.id  // agentId
      )
    ).stream();
  })();

  let threadRun: ThreadRun | undefined = undefined;
  for await (const eventMessage of streamEventMessages) {
    switch (eventMessage.event) {
      case RunStreamEvent.ThreadRunCreated:
        console.debug(`ThreadRun status: ${(eventMessage.data as ThreadRun).status}`);
        break;
      case MessageStreamEvent.ThreadMessageDelta:
        {
          const messageDelta = eventMessage.data;
          (messageDelta as MessageDeltaChunk).delta.content.forEach((contentPart) => {
            if (contentPart.type === "text") {
              const textContent = contentPart as MessageDeltaTextContent;
              const textValue = textContent.text?.value || "";
              process.stdout.write(textValue);
            }
          });
        }
        break;
      case RunStreamEvent.ThreadRunCompleted:
        process.stdout.write("\n");
        console.debug("Thread Run Completed");
        break;
      case ErrorEvent.Error:
        console.debug(`An error occurred. Data ${eventMessage.data}`);
        break;
      case RunStreamEvent.ThreadRunRequiresAction: 
        console.debug("Tool approval required.");
        if (!isThreadRun(eventMessage.data)) {
          console.warn("Received ThreadRunRequiresAction but event data is not a ThreadRun:", eventMessage.data);
          continue;
        }
        threadRun = eventMessage.data;
        break;
      case DoneEvent.Done:
        console.debug("Stream completed.");
        break;
    }
  }
  return threadRun;
}

const main = async () => {
  if (!process.env.PROJECT_ENDPOINT) {
    throw new Error("Missing PROJECT_ENDPOINT environment variable");
  }
  const client = new AgentsClient(process.env.PROJECT_ENDPOINT, new DefaultAzureCredential());

  const agentId = process.argv[2];
  if (!agentId) {
    throw new Error("Please provide the agent ID as a command line argument");
  }
  const ask = process.argv[3] || "Please explain the spec of Azure AI Services.";

  // retrieve the agent
  const agent = await client.getAgent(agentId);

  // create a new thread
  const thread = await client.threads.create();

  // send a user message to the agent
  const message = await client.messages.create(
    thread.id,
    "user",
    ask,
  );

  let threadRun: ThreadRun | undefined;
  do {
    // start a new run and stream events
     threadRun = await responseHandler(client, thread.id, threadRun ? threadRun : agent);
  } while (threadRun);
};

main().catch((err) => {
  console.error("Error in conversation:", err);
});