original engineering code

Author: diberry

quickstarts/ai-agents/ts/data/first.841a34ea-9194-4043-afb8-22acada89e38.pngImageFile.png

@@ -2,10 +2,10 @@
   "name": "azureaiagents",
   "version": "1.0.0",
   "main": "index.js",
-  "type": "module",
   "scripts": {
     "build": "tsc",
     "start": "tsc && node -r dotenv/config dist/index.js",
+    "start:js": "node -r dotenv/config src/original.js",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "author": "",

quickstarts/ai-agents/ts/data/nifty500QuarterlyResults.csv

@@ -24,6 +24,10 @@ import "dotenv/config";
 const projectEndpoint = process.env["PROJECT_ENDPOINT"]!;
 const modelDeploymentName = process.env["MODEL_DEPLOYMENT_NAME"]! || "gpt-4o";
 
+if (!process.env["PROJECT_ENDPOINT"]) {
+  throw new Error("PROJECT_ENDPOINT environment variable is required");
+}
+
 /**
  * Initialize the client, upload files, and create agent and thread
  */
@@ -138,12 +142,12 @@ async function executeAgentTask(
 /**
  * Retrieve and process the results from the agent
  */
-async function processResults(client: AgentsClient, threadId: string): Promise<any[]> {
+async function processResults(client: AgentsClient, threadId: string): Promise<ThreadMessage[]> {
   console.log("Processing results...");
 
   // Print the messages from the agent
   const messagesIterator = client.messages.list(threadId);
-  const messagesArray = [];
+  const messagesArray: ThreadMessage[] = [];
 
   for await (const m of messagesIterator) {
     messagesArray.push(m);
@@ -176,7 +180,7 @@ async function processResults(client: AgentsClient, threadId: string): Promise<a
  */
 async function downloadGeneratedFiles(
   client: AgentsClient, 
-  messages: any[]
+  messages: ThreadMessage[]
 ): Promise<string | undefined> {
   console.log("Checking for and downloading generated files...");
 
@@ -233,7 +237,14 @@ async function downloadGeneratedFiles(
     chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
   }
   const buffer = Buffer.concat(chunks);
-  fs.writeFileSync(imageFileName, buffer);
+
+  try {
+    fs.writeFileSync(imageFileName, buffer);
+    console.log(`File saved to ${imageFileName}`);
+  } catch (error) {
+    console.error(`Error saving file to ${imageFileName}:`, error);
+  }
+
   console.log(`File saved to ${imageFileName}`);
 
   return imageFileName;

quickstarts/ai-agents/ts/data/undefinedImageFile.png

@@ -0,0 +1,292 @@
+// index.ts
+// This sample demonstrates how to use the Azure AI Agents SDK
+// It's organized in phases: setup, execution, processing results, downloading files, and cleanup
+import {
+  RunStreamEvent,
+  MessageStreamEvent,
+  DoneEvent,
+  ErrorEvent,
+  AgentsClient,
+  isOutputOfType,
+  ToolUtility,
+  Agent,
+  Thread,
+  File,
+  Message,
+} from "@azure/ai-agents";
+import { DefaultAzureCredential } from "@azure/identity";
+
+import * as fs from "fs";
+import * as path from "node:path";
+import "dotenv/config";
+
+// Configuration
+const projectEndpoint = process.env["PROJECT_ENDPOINT"]!;
+const modelDeploymentName = process.env["MODEL_DEPLOYMENT_NAME"]! || "gpt-4o";
+
+/**
+ * Initialize the client, upload files, and create agent and thread
+ */
+async function setupAgentAndResources(client: AgentsClient): Promise<{
+  agent: Agent;
+  thread: Thread;
+  localFile: File;
+}> {
+  console.log("Setting up agent and resources...");
+  
+  // Upload file and wait for it to be processed
+  const filePath = "./data/nifty500QuarterlyResults.csv";
+  const localFileStream = fs.createReadStream(filePath);
+  const localFile = await client.files.upload(localFileStream, "assistants", {
+    fileName: "myLocalFile",
+  });
+  console.log(`Uploaded local file, file ID : ${localFile.id}`);
+
+  // Create code interpreter tool
+  const codeInterpreterTool = ToolUtility.createCodeInterpreterTool([localFile.id]);
+
+  // Create agent with code interpreter tool
+  const agent = await client.createAgent(modelDeploymentName, {
+    name: "my-agent",
+    instructions: "You are a helpful agent",
+    tools: [codeInterpreterTool.definition],
+    toolResources: codeInterpreterTool.resources,
+  });
+  console.log(`Created agent, agent ID: ${agent.id}`);
+
+  // Create a thread
+  const thread = await client.threads.create();
+  console.log(`Created thread, thread ID: ${thread.id}`);
+
+  return { agent, thread, localFile };
+}
+
+/**
+ * Execute a task by sending a message to the agent and processing the streaming response
+ */
+async function executeAgentTask(
+  client: AgentsClient,
+  thread: Thread,
+  agent: Agent,
+  userPrompt: string
+): Promise<Message> {
+  console.log("Executing agent task...");
+  
+  // Create a message
+  const message = await client.messages.create(thread.id, "user", userPrompt);
+  console.log(`Created message, message ID: ${message.id}`);
+
+  // Create and execute a run with streaming responses
+  const streamEventMessages = await client.runs.create(thread.id, agent.id).stream();
+
+  // Process streaming events
+  for await (const eventMessage of streamEventMessages) {
+    switch (eventMessage.event) {
+      case RunStreamEvent.ThreadRunCreated:
+        // Type check or cast to access the status property safely
+        if (typeof eventMessage.data === 'object' && eventMessage.data !== null && 'status' in eventMessage.data) {
+          console.log(`ThreadRun status: ${eventMessage.data.status}`);
+        } else {
+          console.log(`ThreadRun created: ${JSON.stringify(eventMessage.data)}`);
+        }
+        break;
+        
+      case MessageStreamEvent.ThreadMessageDelta:
+        {
+          const messageDelta = eventMessage.data;
+          // Type check or cast to access the delta property safely
+          if (typeof messageDelta === 'object' && 
+              messageDelta !== null && 
+              'delta' in messageDelta && 
+              messageDelta.delta && 
+              'content' in messageDelta.delta && 
+              Array.isArray(messageDelta.delta.content)) {
+            
+            messageDelta.delta.content.forEach((contentPart) => {
+              if (contentPart.type === "text") {
+                const textContent = contentPart;
+                // Add type guard for text content
+                if ('text' in textContent && 
+                    textContent.text && 
+                    typeof textContent.text === 'object') {
+                  const textValue = textContent.text.value || "No text";
+                  console.log(`Text delta received:: ${textValue}`);
+                }
+              }
+            });
+          }
+        }
+        break;
+
+      case RunStreamEvent.ThreadRunCompleted:
+        console.log("Thread Run Completed");
+        break;
+        
+      case ErrorEvent.Error:
+        console.log(`An error occurred. Data ${eventMessage.data}`);
+        break;
+        
+      case DoneEvent.Done:
+        console.log("Stream completed.");
+        break;
+    }
+  }
+  
+  return message;
+}
+
+/**
+ * Retrieve and process the results from the agent
+ */
+async function processResults(client: AgentsClient, threadId: string): Promise<any[]> {
+  console.log("Processing results...");
+  
+  // Print the messages from the agent
+  const messagesIterator = client.messages.list(threadId);
+  const messagesArray = [];
+  
+  for await (const m of messagesIterator) {
+    messagesArray.push(m);
+  }
+  
+  console.log(`Message Details:`);
+  messagesArray.forEach((m) => {
+    console.log(`File Paths:`);
+    console.log(`Type: ${m.content[0].type}`);
+    
+    if (isOutputOfType(m.content[0], "text")) {
+      const textContent = m.content[0];
+      // Use type guard to safely access text property
+      if ('text' in textContent && 
+          textContent.text && 
+          typeof textContent.text === 'object' && 
+          'value' in textContent.text) {
+        console.log(`Text: ${textContent.text.value}`);
+      }
+    }
+    
+    console.log(`File ID: ${m.id}`);
+  });
+  
+  return messagesArray;
+}
+
+/**
+ * Download and save any files generated by the agent
+ */
+async function downloadGeneratedFiles(
+  client: AgentsClient, 
+  messages: any[]
+): Promise<string | undefined> {
+  console.log("Checking for and downloading generated files...");
+  
+  // Get most recent message from the assistant
+  const assistantMessage = messages.find((msg) => msg.role === "assistant");
+  if (!assistantMessage) {
+    console.log("No assistant message found");
+    return;
+  }
+  
+  const textContent = assistantMessage.content.find((content) => isOutputOfType(content, "text"));
+  if (!textContent) {
+    console.log("No text content found in assistant message");
+    return;
+  }
+  
+  // Save the newly created file
+  console.log(`Saving new files...`);
+  const imageFileOutput = messages[0].content[0];
+  
+  // Use type checking to safely access the imageFile property
+  let imageFileId = '';
+  
+  // Check if content has image file type and has the correct structure
+  if (isOutputOfType(imageFileOutput, "image_file") && 
+      'image_file' in imageFileOutput && 
+      imageFileOutput.image_file && 
+      typeof imageFileOutput.image_file === 'object') {
+    // Use type assertion after validating the structure
+    const typedImageFile = imageFileOutput.image_file as { fileId: string };
+    if ('fileId' in typedImageFile && typeof typedImageFile.fileId === 'string') {
+      imageFileId = typedImageFile.fileId;
+    }
+  }
+  
+  if (!imageFileId) {
+    console.log("No image file found in the message content");
+    return;
+  }
+  
+  const imageFileName = path.resolve(
+    "./data/" + (await client.files.get(imageFileId)).filename + "ImageFile.png",
+  );
+  console.log(`Image file name : ${imageFileName}`);
+
+  const fileContent = await (await client.files.getContent(imageFileId).asNodeStream()).body;
+  if (!fileContent) {
+    console.log("No file content available");
+    return;
+  }
+  
+  const chunks = [];
+  for await (const chunk of fileContent) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const buffer = Buffer.concat(chunks);
+  fs.writeFileSync(imageFileName, buffer);
+  console.log(`File saved to ${imageFileName}`);
+  
+  return imageFileName;
+}
+
+/**
+ * Clean up resources - delete files and agent
+ */
+async function cleanupResources(
+  client: AgentsClient, 
+  agentId: string, 
+  fileId: string
+): Promise<void> {
+  console.log("Cleaning up resources...");
+  
+  // Delete the file from the agent to free up space
+  await client.files.delete(fileId);
+  console.log(`Deleted file, file ID : ${fileId}`);
+  
+  // Delete the agent once done
+  await client.deleteAgent(agentId);
+  console.log(`Deleted agent, agent ID: ${agentId}`);
+}
+
+/**
+ * Main function to demonstrate the Azure AI Agents SDK
+ */
+async function main() {
+  try {
+    // Create an Azure AI Client
+    const client = new AgentsClient(projectEndpoint, new DefaultAzureCredential());
+    
+    // Step 1: Setup agent and resources
+    const { agent, thread, localFile } = await setupAgentAndResources(client);
+    
+    // Step 2: Execute a task
+    const userPrompt = "Could you please create a bar chart in the TRANSPORTATION sector for the operating profit from the uploaded CSV file and provide the file to me?";
+    await executeAgentTask(client, thread, agent, userPrompt);
+    
+    // Step 3: Process the results
+    const messages = await processResults(client, thread.id);
+    
+    // Step 4: Download any generated files
+    await downloadGeneratedFiles(client, messages);
+    
+    // Step 5: Cleanup resources
+    await cleanupResources(client, agent.id, localFile.id);
+    
+    console.log("Azure AI Agents sample completed successfully!");
+  } catch (error) {
+    console.error("The sample encountered an error:", error);
+  }
+}
+
+// Execute the sample
+main();