@a2a-js/sdk 0.2.1

package/build/src/samples/agents/movie-agent/index.js

@@ -0,0 +1,252 @@
+import express from "express";
+import { v4 as uuidv4 } from 'uuid'; // For generating unique IDs
+import { InMemoryTaskStore, A2AExpressApp, DefaultRequestHandler } from "../../../index.js";
+import { ai } from "./genkit.js";
+import { searchMovies, searchPeople } from "./tools.js";
+if (!process.env.GEMINI_API_KEY || !process.env.TMDB_API_KEY) {
+    console.error("GEMINI_API_KEY and TMDB_API_KEY environment variables are required");
+    process.exit(1);
+}
+// Simple store for contexts
+const contexts = new Map();
+// Load the Genkit prompt
+const movieAgentPrompt = ai.prompt('movie_agent');
+/**
+ * MovieAgentExecutor implements the agent's core logic.
+ */
+class MovieAgentExecutor {
+    cancelledTasks = new Set();
+    cancelTask = async (taskId, eventBus) => {
+        this.cancelledTasks.add(taskId);
+        // The execute loop is responsible for publishing the final state
+    };
+    async execute(requestContext, eventBus) {
+        const userMessage = requestContext.userMessage;
+        const existingTask = requestContext.task;
+        // Determine IDs for the task and context
+        const taskId = requestContext.taskId;
+        const contextId = requestContext.contextId;
+        console.log(`[MovieAgentExecutor] Processing message ${userMessage.messageId} for task ${taskId} (context: ${contextId})`);
+        // 1. Publish initial Task event if it's a new task
+        if (!existingTask) {
+            const initialTask = {
+                kind: 'task',
+                id: taskId,
+                contextId: contextId,
+                status: {
+                    state: 'submitted',
+                    timestamp: new Date().toISOString(),
+                },
+                history: [userMessage], // Start history with the current user message
+                metadata: userMessage.metadata, // Carry over metadata from message if any
+            };
+            eventBus.publish(initialTask);
+        }
+        // 2. Publish "working" status update
+        const workingStatusUpdate = {
+            kind: 'status-update',
+            taskId: taskId,
+            contextId: contextId,
+            status: {
+                state: 'working',
+                message: {
+                    kind: 'message',
+                    role: 'agent',
+                    messageId: uuidv4(),
+                    parts: [{ kind: 'text', text: 'Processing your question, hang tight!' }],
+                    taskId: taskId,
+                    contextId: contextId,
+                },
+                timestamp: new Date().toISOString(),
+            },
+            final: false,
+        };
+        eventBus.publish(workingStatusUpdate);
+        // 3. Prepare messages for Genkit prompt
+        const historyForGenkit = contexts.get(contextId) || [];
+        if (!historyForGenkit.find(m => m.messageId === userMessage.messageId)) {
+            historyForGenkit.push(userMessage);
+        }
+        contexts.set(contextId, historyForGenkit);
+        const messages = historyForGenkit
+            .map((m) => ({
+            role: (m.role === 'agent' ? 'model' : 'user'),
+            content: m.parts
+                .filter((p) => p.kind === 'text' && !!p.text)
+                .map((p) => ({
+                text: p.text,
+            })),
+        }))
+            .filter((m) => m.content.length > 0);
+        if (messages.length === 0) {
+            console.warn(`[MovieAgentExecutor] No valid text messages found in history for task ${taskId}.`);
+            const failureUpdate = {
+                kind: 'status-update',
+                taskId: taskId,
+                contextId: contextId,
+                status: {
+                    state: 'failed',
+                    message: {
+                        kind: 'message',
+                        role: 'agent',
+                        messageId: uuidv4(),
+                        parts: [{ kind: 'text', text: 'No message found to process.' }],
+                        taskId: taskId,
+                        contextId: contextId,
+                    },
+                    timestamp: new Date().toISOString(),
+                },
+                final: true,
+            };
+            eventBus.publish(failureUpdate);
+            return;
+        }
+        const goal = existingTask?.metadata?.goal || userMessage.metadata?.goal;
+        try {
+            // 4. Run the Genkit prompt
+            const response = await movieAgentPrompt({ goal: goal, now: new Date().toISOString() }, {
+                messages,
+                tools: [searchMovies, searchPeople],
+            });
+            // Check if the request has been cancelled
+            if (this.cancelledTasks.has(taskId)) {
+                console.log(`[MovieAgentExecutor] Request cancelled for task: ${taskId}`);
+                const cancelledUpdate = {
+                    kind: 'status-update',
+                    taskId: taskId,
+                    contextId: contextId,
+                    status: {
+                        state: 'canceled',
+                        timestamp: new Date().toISOString(),
+                    },
+                    final: true, // Cancellation is a final state
+                };
+                eventBus.publish(cancelledUpdate);
+                return;
+            }
+            const responseText = response.text; // Access the text property using .text()
+            console.info(`[MovieAgentExecutor] Prompt response: ${responseText}`);
+            const lines = responseText.trim().split('\n');
+            const finalStateLine = lines.at(-1)?.trim().toUpperCase();
+            const agentReplyText = lines.slice(0, lines.length - 1).join('\n').trim();
+            let finalA2AState = "unknown";
+            if (finalStateLine === 'COMPLETED') {
+                finalA2AState = 'completed';
+            }
+            else if (finalStateLine === 'AWAITING_USER_INPUT') {
+                finalA2AState = 'input-required';
+            }
+            else {
+                console.warn(`[MovieAgentExecutor] Unexpected final state line from prompt: ${finalStateLine}. Defaulting to 'completed'.`);
+                finalA2AState = 'completed'; // Default if LLM deviates
+            }
+            // 5. Publish final task status update
+            const agentMessage = {
+                kind: 'message',
+                role: 'agent',
+                messageId: uuidv4(),
+                parts: [{ kind: 'text', text: agentReplyText || "Completed." }], // Ensure some text
+                taskId: taskId,
+                contextId: contextId,
+            };
+            historyForGenkit.push(agentMessage);
+            contexts.set(contextId, historyForGenkit);
+            const finalUpdate = {
+                kind: 'status-update',
+                taskId: taskId,
+                contextId: contextId,
+                status: {
+                    state: finalA2AState,
+                    message: agentMessage,
+                    timestamp: new Date().toISOString(),
+                },
+                final: true,
+            };
+            eventBus.publish(finalUpdate);
+            console.log(`[MovieAgentExecutor] Task ${taskId} finished with state: ${finalA2AState}`);
+        }
+        catch (error) {
+            console.error(`[MovieAgentExecutor] Error processing task ${taskId}:`, error);
+            const errorUpdate = {
+                kind: 'status-update',
+                taskId: taskId,
+                contextId: contextId,
+                status: {
+                    state: 'failed',
+                    message: {
+                        kind: 'message',
+                        role: 'agent',
+                        messageId: uuidv4(),
+                        parts: [{ kind: 'text', text: `Agent error: ${error.message}` }],
+                        taskId: taskId,
+                        contextId: contextId,
+                    },
+                    timestamp: new Date().toISOString(),
+                },
+                final: true,
+            };
+            eventBus.publish(errorUpdate);
+        }
+    }
+}
+// --- Server Setup ---
+const movieAgentCard = {
+    name: 'Movie Agent',
+    description: 'An agent that can answer questions about movies and actors using TMDB.',
+    // Adjust the base URL and port as needed. /a2a is the default base in A2AExpressApp
+    url: 'http://localhost:41241/', // Example: if baseUrl in A2AExpressApp 
+    provider: {
+        organization: 'A2A Samples',
+        url: 'https://example.com/a2a-samples' // Added provider URL
+    },
+    version: '0.0.2', // Incremented version
+    capabilities: {
+        streaming: true, // The new framework supports streaming
+        pushNotifications: false, // Assuming not implemented for this agent yet
+        stateTransitionHistory: true, // Agent uses history
+    },
+    // authentication: null, // Property 'authentication' does not exist on type 'AgentCard'.
+    securitySchemes: undefined, // Or define actual security schemes if any
+    security: undefined,
+    defaultInputModes: ['text'],
+    defaultOutputModes: ['text', 'task-status'], // task-status is a common output mode
+    skills: [
+        {
+            id: 'general_movie_chat',
+            name: 'General Movie Chat',
+            description: 'Answer general questions or chat about movies, actors, directors.',
+            tags: ['movies', 'actors', 'directors'],
+            examples: [
+                'Tell me about the plot of Inception.',
+                'Recommend a good sci-fi movie.',
+                'Who directed The Matrix?',
+                'What other movies has Scarlett Johansson been in?',
+                'Find action movies starring Keanu Reeves',
+                'Which came out first, Jurassic Park or Terminator 2?',
+            ],
+            inputModes: ['text'], // Explicitly defining for skill
+            outputModes: ['text', 'task-status'] // Explicitly defining for skill
+        },
+    ],
+    supportsAuthenticatedExtendedCard: false,
+};
+async function main() {
+    // 1. Create TaskStore
+    const taskStore = new InMemoryTaskStore();
+    // 2. Create AgentExecutor
+    const agentExecutor = new MovieAgentExecutor();
+    // 3. Create DefaultRequestHandler
+    const requestHandler = new DefaultRequestHandler(movieAgentCard, taskStore, agentExecutor);
+    // 4. Create and setup A2AExpressApp
+    const appBuilder = new A2AExpressApp(requestHandler);
+    const expressApp = appBuilder.setupRoutes(express());
+    // 5. Start the server
+    const PORT = process.env.PORT || 41241;
+    expressApp.listen(PORT, () => {
+        console.log(`[MovieAgent] Server using new framework started on http://localhost:${PORT}`);
+        console.log(`[MovieAgent] Agent Card: http://localhost:${PORT}/.well-known/agent.json`);
+        console.log('[MovieAgent] Press Ctrl+C to stop the server');
+    });
+}
+main().catch(console.error);
+//# sourceMappingURL=index.js.map

package/build/src/samples/agents/movie-agent/tmdb.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utility function to call the TMDB API
+ * @param endpoint The TMDB API endpoint (e.g., 'movie', 'person')
+ * @param query The search query
+ * @returns Promise that resolves to the API response data
+ */
+export declare function callTmdbApi(endpoint: string, query: string): Promise<any>;

package/build/src/samples/agents/movie-agent/tmdb.js

@@ -0,0 +1,32 @@
+/**
+ * Utility function to call the TMDB API
+ * @param endpoint The TMDB API endpoint (e.g., 'movie', 'person')
+ * @param query The search query
+ * @returns Promise that resolves to the API response data
+ */
+export async function callTmdbApi(endpoint, query) {
+    // Validate API key
+    const apiKey = process.env.TMDB_API_KEY;
+    if (!apiKey) {
+        throw new Error("TMDB_API_KEY environment variable is not set");
+    }
+    try {
+        // Make request to TMDB API
+        const url = new URL(`https://api.themoviedb.org/3/search/${endpoint}`);
+        url.searchParams.append("api_key", apiKey);
+        url.searchParams.append("query", query);
+        url.searchParams.append("include_adult", "false");
+        url.searchParams.append("language", "en-US");
+        url.searchParams.append("page", "1");
+        const response = await fetch(url.toString());
+        if (!response.ok) {
+            throw new Error(`TMDB API error: ${response.status} ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    catch (error) {
+        console.error(`Error calling TMDB API (${endpoint}):`, error);
+        throw error;
+    }
+}
+//# sourceMappingURL=tmdb.js.map

package/build/src/samples/agents/movie-agent/tools.d.ts

@@ -0,0 +1,15 @@
+import { z } from "./genkit.js";
+export declare const searchMovies: import("genkit").ToolAction<z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query?: string;
+}, {
+    query?: string;
+}>, z.ZodTypeAny>;
+export declare const searchPeople: import("genkit").ToolAction<z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query?: string;
+}, {
+    query?: string;
+}>, z.ZodTypeAny>;

package/build/src/samples/agents/movie-agent/tools.js

@@ -0,0 +1,74 @@
+import { ai, z } from "./genkit.js";
+import { callTmdbApi } from "./tmdb.js";
+export const searchMovies = ai.defineTool({
+    name: "searchMovies",
+    description: "search TMDB for movies by title",
+    inputSchema: z.object({
+        query: z.string(),
+    }),
+}, async ({ query }) => {
+    console.log("[tmdb:searchMovies]", JSON.stringify(query));
+    try {
+        const data = await callTmdbApi("movie", query);
+        // Only modify image paths to be full URLs
+        const results = data.results.map((movie) => {
+            if (movie.poster_path) {
+                movie.poster_path = `https://image.tmdb.org/t/p/w500${movie.poster_path}`;
+            }
+            if (movie.backdrop_path) {
+                movie.backdrop_path = `https://image.tmdb.org/t/p/w500${movie.backdrop_path}`;
+            }
+            return movie;
+        });
+        return {
+            ...data,
+            results,
+        };
+    }
+    catch (error) {
+        console.error("Error searching movies:", error);
+        // Re-throwing allows Genkit/the caller to handle it appropriately
+        throw error;
+    }
+});
+export const searchPeople = ai.defineTool({
+    name: "searchPeople",
+    description: "search TMDB for people by name",
+    inputSchema: z.object({
+        query: z.string(),
+    }),
+}, async ({ query }) => {
+    console.log("[tmdb:searchPeople]", JSON.stringify(query));
+    try {
+        const data = await callTmdbApi("person", query);
+        // Only modify image paths to be full URLs
+        const results = data.results.map((person) => {
+            if (person.profile_path) {
+                person.profile_path = `https://image.tmdb.org/t/p/w500${person.profile_path}`;
+            }
+            // Also modify poster paths in known_for works
+            if (person.known_for && Array.isArray(person.known_for)) {
+                person.known_for = person.known_for.map((work) => {
+                    if (work.poster_path) {
+                        work.poster_path = `https://image.tmdb.org/t/p/w500${work.poster_path}`;
+                    }
+                    if (work.backdrop_path) {
+                        work.backdrop_path = `https://image.tmdb.org/t/p/w500${work.backdrop_path}`;
+                    }
+                    return work;
+                });
+            }
+            return person;
+        });
+        return {
+            ...data,
+            results,
+        };
+    }
+    catch (error) {
+        console.error("Error searching people:", error);
+        // Re-throwing allows Genkit/the caller to handle it appropriately
+        throw error;
+    }
+});
+//# sourceMappingURL=tools.js.map

package/build/src/samples/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/src/samples/cli.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+import readline from "node:readline";
+import crypto from "node:crypto";
+import { // Added for explicit Part typing
+A2AClient, } from "../index.js";
+// --- ANSI Colors ---
+const colors = {
+    reset: "\x1b[0m",
+    bright: "\x1b[1m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    gray: "\x1b[90m",
+};
+// --- Helper Functions ---
+function colorize(color, text) {
+    return `${colors[color]}${text}${colors.reset}`;
+}
+function generateId() {
+    return crypto.randomUUID();
+}
+// --- State ---
+let currentTaskId = undefined; // Initialize as undefined
+let currentContextId = undefined; // Initialize as undefined
+const serverUrl = process.argv[2] || "http://localhost:41241"; // Agent's base URL
+const client = new A2AClient(serverUrl);
+let agentName = "Agent"; // Default, try to get from agent card later
+// --- Readline Setup ---
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: colorize("cyan", "You: "),
+});
+// --- Response Handling ---
+// Function now accepts the unwrapped event payload directly
+function printAgentEvent(event) {
+    const timestamp = new Date().toLocaleTimeString();
+    const prefix = colorize("magenta", `\n${agentName} [${timestamp}]:`);
+    // Check if it's a TaskStatusUpdateEvent
+    if (event.kind === "status-update") {
+        const update = event; // Cast for type safety
+        const state = update.status.state;
+        let stateEmoji = "❓";
+        let stateColor = "yellow";
+        switch (state) {
+            case "working":
+                stateEmoji = "⏳";
+                stateColor = "blue";
+                break;
+            case "input-required":
+                stateEmoji = "🤔";
+                stateColor = "yellow";
+                break;
+            case "completed":
+                stateEmoji = "✅";
+                stateColor = "green";
+                break;
+            case "canceled":
+                stateEmoji = "⏹️";
+                stateColor = "gray";
+                break;
+            case "failed":
+                stateEmoji = "❌";
+                stateColor = "red";
+                break;
+            default:
+                stateEmoji = "ℹ️"; // For other states like submitted, rejected etc.
+                stateColor = "dim";
+                break;
+        }
+        console.log(`${prefix} ${stateEmoji} Status: ${colorize(stateColor, state)} (Task: ${update.taskId}, Context: ${update.contextId}) ${update.final ? colorize("bright", "[FINAL]") : ""}`);
+        if (update.status.message) {
+            printMessageContent(update.status.message);
+        }
+    }
+    // Check if it's a TaskArtifactUpdateEvent
+    else if (event.kind === "artifact-update") {
+        const update = event; // Cast for type safety
+        console.log(`${prefix} 📄 Artifact Received: ${update.artifact.name || "(unnamed)"} (ID: ${update.artifact.artifactId}, Task: ${update.taskId}, Context: ${update.contextId})`);
+        // Create a temporary message-like structure to reuse printMessageContent
+        printMessageContent({
+            messageId: generateId(), // Dummy messageId
+            kind: "message", // Dummy kind
+            role: "agent", // Assuming artifact parts are from agent
+            parts: update.artifact.parts,
+            taskId: update.taskId,
+            contextId: update.contextId,
+        });
+    }
+    else {
+        // This case should ideally not be reached if called correctly
+        console.log(prefix, colorize("yellow", "Received unknown event type in printAgentEvent:"), event);
+    }
+}
+function printMessageContent(message) {
+    message.parts.forEach((part, index) => {
+        const partPrefix = colorize("red", `  Part ${index + 1}:`);
+        if (part.kind === "text") { // Check kind property
+            console.log(`${partPrefix} ${colorize("green", "📝 Text:")}`, part.text);
+        }
+        else if (part.kind === "file") { // Check kind property
+            const filePart = part;
+            console.log(`${partPrefix} ${colorize("blue", "📄 File:")} Name: ${filePart.file.name || "N/A"}, Type: ${filePart.file.mimeType || "N/A"}, Source: ${("bytes" in filePart.file) ? "Inline (bytes)" : filePart.file.uri}`);
+        }
+        else if (part.kind === "data") { // Check kind property
+            const dataPart = part;
+            console.log(`${partPrefix} ${colorize("yellow", "📊 Data:")}`, JSON.stringify(dataPart.data, null, 2));
+        }
+        else {
+            console.log(`${partPrefix} ${colorize("yellow", "Unsupported part kind:")}`, part);
+        }
+    });
+}
+// --- Agent Card Fetching ---
+async function fetchAndDisplayAgentCard() {
+    // Use the client's getAgentCard method.
+    // The client was initialized with serverUrl, which is the agent's base URL.
+    console.log(colorize("dim", `Attempting to fetch agent card from agent at: ${serverUrl}`));
+    try {
+        // client.getAgentCard() uses the agentBaseUrl provided during client construction
+        const card = await client.getAgentCard();
+        agentName = card.name || "Agent"; // Update global agent name
+        console.log(colorize("green", `✓ Agent Card Found:`));
+        console.log(`  Name:        ${colorize("bright", agentName)}`);
+        if (card.description) {
+            console.log(`  Description: ${card.description}`);
+        }
+        console.log(`  Version:     ${card.version || "N/A"}`);
+        if (card.capabilities?.streaming) {
+            console.log(`  Streaming:   ${colorize("green", "Supported")}`);
+        }
+        else {
+            console.log(`  Streaming:   ${colorize("yellow", "Not Supported (or not specified)")}`);
+        }
+        // Update prompt prefix to use the fetched name
+        // The prompt is set dynamically before each rl.prompt() call in the main loop
+        // to reflect the current agentName if it changes (though unlikely after initial fetch).
+    }
+    catch (error) {
+        console.log(colorize("yellow", `⚠️ Error fetching or parsing agent card`));
+        throw error;
+    }
+}
+// --- Main Loop ---
+async function main() {
+    console.log(colorize("bright", `A2A Terminal Client`));
+    console.log(colorize("dim", `Agent Base URL: ${serverUrl}`));
+    await fetchAndDisplayAgentCard(); // Fetch the card before starting the loop
+    console.log(colorize("dim", `No active task or context initially. Use '/new' to start a fresh session or send a message.`));
+    console.log(colorize("green", `Enter messages, or use '/new' to start a new session. '/exit' to quit.`));
+    rl.setPrompt(colorize("cyan", `${agentName} > You: `)); // Set initial prompt
+    rl.prompt();
+    rl.on("line", async (line) => {
+        const input = line.trim();
+        rl.setPrompt(colorize("cyan", `${agentName} > You: `)); // Ensure prompt reflects current agentName
+        if (!input) {
+            rl.prompt();
+            return;
+        }
+        if (input.toLowerCase() === "/new") {
+            currentTaskId = undefined;
+            currentContextId = undefined; // Reset contextId on /new
+            console.log(colorize("bright", `✨ Starting new session. Task and Context IDs are cleared.`));
+            rl.prompt();
+            return;
+        }
+        if (input.toLowerCase() === "/exit") {
+            rl.close();
+            return;
+        }
+        // Construct params for sendMessageStream
+        const messageId = generateId(); // Generate a unique message ID
+        const messagePayload = {
+            messageId: messageId,
+            kind: "message", // Required by Message interface
+            role: "user",
+            parts: [
+                {
+                    kind: "text", // Required by TextPart interface
+                    text: input,
+                },
+            ],
+        };
+        // Conditionally add taskId to the message payload
+        if (currentTaskId) {
+            messagePayload.taskId = currentTaskId;
+        }
+        // Conditionally add contextId to the message payload
+        if (currentContextId) {
+            messagePayload.contextId = currentContextId;
+        }
+        const params = {
+            message: messagePayload,
+            // Optional: configuration for streaming, blocking, etc.
+            // configuration: {
+            //   acceptedOutputModes: ['text/plain', 'application/json'], // Example
+            //   blocking: false // Default for streaming is usually non-blocking
+            // }
+        };
+        try {
+            console.log(colorize("red", "Sending message..."));
+            // Use sendMessageStream
+            const stream = client.sendMessageStream(params);
+            // Iterate over the events from the stream
+            for await (const event of stream) {
+                const timestamp = new Date().toLocaleTimeString(); // Get fresh timestamp for each event
+                const prefix = colorize("magenta", `\n${agentName} [${timestamp}]:`);
+                if (event.kind === "status-update" || event.kind === "artifact-update") {
+                    const typedEvent = event;
+                    printAgentEvent(typedEvent);
+                    // If the event is a TaskStatusUpdateEvent and it's final, reset currentTaskId
+                    if (typedEvent.kind === "status-update" && typedEvent.final && typedEvent.status.state !== "input-required") {
+                        console.log(colorize("yellow", `   Task ${typedEvent.taskId} is final. Clearing current task ID.`));
+                        currentTaskId = undefined;
+                        // Optionally, you might want to clear currentContextId as well if a task ending implies context ending.
+                        // currentContextId = undefined; 
+                        // console.log(colorize("dim", `   Context ID also cleared as task is final.`));
+                    }
+                }
+                else if (event.kind === "message") {
+                    const msg = event;
+                    console.log(`${prefix} ${colorize("green", "✉️ Message Stream Event:")}`);
+                    printMessageContent(msg);
+                    if (msg.taskId && msg.taskId !== currentTaskId) {
+                        console.log(colorize("dim", `   Task ID context updated to ${msg.taskId} based on message event.`));
+                        currentTaskId = msg.taskId;
+                    }
+                    if (msg.contextId && msg.contextId !== currentContextId) {
+                        console.log(colorize("dim", `   Context ID updated to ${msg.contextId} based on message event.`));
+                        currentContextId = msg.contextId;
+                    }
+                }
+                else if (event.kind === "task") {
+                    const task = event;
+                    console.log(`${prefix} ${colorize("blue", "ℹ️ Task Stream Event:")} ID: ${task.id}, Context: ${task.contextId}, Status: ${task.status.state}`);
+                    if (task.id !== currentTaskId) {
+                        console.log(colorize("dim", `   Task ID updated from ${currentTaskId || 'N/A'} to ${task.id}`));
+                        currentTaskId = task.id;
+                    }
+                    if (task.contextId && task.contextId !== currentContextId) {
+                        console.log(colorize("dim", `   Context ID updated from ${currentContextId || 'N/A'} to ${task.contextId}`));
+                        currentContextId = task.contextId;
+                    }
+                    if (task.status.message) {
+                        console.log(colorize("gray", "   Task includes message:"));
+                        printMessageContent(task.status.message);
+                    }
+                    if (task.artifacts && task.artifacts.length > 0) {
+                        console.log(colorize("gray", `   Task includes ${task.artifacts.length} artifact(s).`));
+                    }
+                }
+                else {
+                    console.log(prefix, colorize("yellow", "Received unknown event structure from stream:"), event);
+                }
+            }
+            console.log(colorize("dim", `--- End of response stream for this input ---`));
+        }
+        catch (error) {
+            const timestamp = new Date().toLocaleTimeString();
+            const prefix = colorize("red", `\n${agentName} [${timestamp}] ERROR:`);
+            console.error(prefix, `Error communicating with agent:`, error.message || error);
+            if (error.code) {
+                console.error(colorize("gray", `   Code: ${error.code}`));
+            }
+            if (error.data) {
+                console.error(colorize("gray", `   Data: ${JSON.stringify(error.data)}`));
+            }
+            if (!(error.code || error.data) && error.stack) {
+                console.error(colorize("gray", error.stack.split('\n').slice(1, 3).join('\n')));
+            }
+        }
+        finally {
+            rl.prompt();
+        }
+    }).on("close", () => {
+        console.log(colorize("yellow", "\nExiting A2A Terminal Client. Goodbye!"));
+        process.exit(0);
+    });
+}
+// --- Start ---
+main().catch(err => {
+    console.error(colorize("red", "Unhandled error in main:"), err);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map