This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
gitgram-ai/aitimemachine/a2a/test/server/default_request_handler.spec.ts
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00

1960 lines
60 KiB
TypeScript

import { describe, it, beforeEach, afterEach, assert, expect, vi, type Mock } from 'vitest';
import { AgentExecutor } from '../../src/server/agent_execution/agent_executor.js';
import {
TaskStore,
InMemoryTaskStore,
DefaultRequestHandler,
ExecutionEventQueue,
A2AError,
InMemoryPushNotificationStore,
RequestContext,
ExecutionEventBus,
UnauthenticatedUser,
ExtendedAgentCardProvider,
User,
} from '../../src/server/index.js';
import {
AgentCard,
Artifact,
DeleteTaskPushNotificationConfigParams,
GetTaskPushNotificationConfigParams,
ListTaskPushNotificationConfigParams,
Message,
MessageSendParams,
PushNotificationConfig,
Task,
TaskPushNotificationConfig,
TaskState,
TaskStatusUpdateEvent,
TextPart,
} from '../../src/index.js';
import {
DefaultExecutionEventBusManager,
ExecutionEventBusManager,
} from '../../src/server/events/execution_event_bus_manager.js';
import { A2ARequestHandler } from '../../src/server/request_handler/a2a_request_handler.js';
import {
MockAgentExecutor,
CancellableMockAgentExecutor,
fakeTaskExecute,
FailingCancellableMockAgentExecutor,
} from './mocks/agent-executor.mock.js';
import { MockPushNotificationSender } from './mocks/push_notification_sender.mock.js';
import { ServerCallContext } from '../../src/server/context.js';
import { MockTaskStore } from './mocks/task_store.mock.js';
describe('DefaultRequestHandler as A2ARequestHandler', () => {
let handler: A2ARequestHandler;
let mockTaskStore: TaskStore;
let mockAgentExecutor: AgentExecutor;
let executionEventBusManager: ExecutionEventBusManager;
const testAgentCard: AgentCard = {
name: 'Test Agent',
description: 'An agent for testing purposes',
url: 'http://localhost:8080',
version: '1.0.0',
protocolVersion: '0.3.0',
capabilities: {
extensions: [{ uri: 'requested-extension-uri' }],
streaming: true,
pushNotifications: true,
},
defaultInputModes: ['text/plain'],
defaultOutputModes: ['text/plain'],
skills: [
{
id: 'test-skill',
name: 'Test Skill',
description: 'A skill for testing',
tags: ['test'],
},
],
};
const serverCallContext = new ServerCallContext();
// Before each test, reset the components to a clean state
beforeEach(() => {
// Wrap in-memory store into a store which ensures we pass server call context.
// The parameter is optional to avoid breaking changes, however it should be passed.
const inMemoryStore = new InMemoryTaskStore();
mockTaskStore = {
save: async (task: Task, ctx?: ServerCallContext) => {
if (!ctx) {
throw new Error('Missing server call context');
}
return inMemoryStore.save(task);
},
load: async (id: string, ctx?: ServerCallContext) => {
if (!ctx) {
throw new Error('Missing server call context');
}
return inMemoryStore.load(id);
},
};
// Default mock for most tests
mockAgentExecutor = new MockAgentExecutor();
executionEventBusManager = new DefaultExecutionEventBusManager();
handler = new DefaultRequestHandler(
testAgentCard,
mockTaskStore,
mockAgentExecutor,
executionEventBusManager
);
});
// After each test, restore any mocks
afterEach(() => {
vi.restoreAllMocks();
vi.useRealTimers();
});
// Helper function to create a basic user message
const createTestMessage = (id: string, text: string): Message => ({
messageId: id,
role: 'user',
parts: [{ kind: 'text', text }],
kind: 'message',
});
it('sendMessage: should return a simple message response', async () => {
const params: MessageSendParams = {
message: createTestMessage('msg-1', 'Hello'),
};
const agentResponse: Message = {
messageId: 'agent-msg-1',
role: 'agent',
parts: [{ kind: 'text', text: 'Hi there!' }],
kind: 'message',
};
(mockAgentExecutor as MockAgentExecutor).execute.mockImplementation(async (ctx, bus) => {
bus.publish(agentResponse);
bus.finished();
});
const result = await handler.sendMessage(params, serverCallContext);
assert.deepEqual(result, agentResponse, "The result should be the agent's message");
expect((mockAgentExecutor as MockAgentExecutor).execute).toHaveBeenCalledTimes(1);
});
it('sendMessage: (blocking) should return a task in a completed state with an artifact', async () => {
const params: MessageSendParams = {
message: createTestMessage('msg-2', 'Do a task'),
};
const taskId = 'task-123';
const contextId = 'ctx-abc';
const testArtifact: Artifact = {
artifactId: 'artifact-1',
name: 'Test Document',
description: 'A test artifact.',
parts: [{ kind: 'text', text: 'This is the content of the artifact.' }],
};
(mockAgentExecutor as MockAgentExecutor).execute.mockImplementation(async (ctx, bus) => {
bus.publish({
id: taskId,
contextId,
status: { state: 'submitted' },
kind: 'task',
});
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: { state: 'working' },
final: false,
});
bus.publish({
taskId,
contextId,
kind: 'artifact-update',
artifact: testArtifact,
});
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: {
state: 'completed',
message: {
role: 'agent',
parts: [{ kind: 'text', text: 'Done!' }],
messageId: 'agent-msg-2',
kind: 'message',
},
},
final: true,
});
bus.finished();
});
const result = await handler.sendMessage(params, serverCallContext);
const taskResult = result as Task;
assert.equal(taskResult.kind, 'task');
assert.equal(taskResult.id, taskId);
assert.equal(taskResult.status.state, 'completed');
assert.isDefined(taskResult.artifacts, 'Task result should have artifacts');
assert.isArray(taskResult.artifacts);
assert.lengthOf(taskResult.artifacts!, 1);
assert.deepEqual(taskResult.artifacts![0], testArtifact);
});
it('sendMessage: should handle agent execution failure for blocking calls', async () => {
const errorMessage = 'Agent failed!';
(mockAgentExecutor as MockAgentExecutor).execute.mockRejectedValue(new Error(errorMessage));
// Test blocking case
const blockingParams: MessageSendParams = {
message: createTestMessage('msg-fail-block', 'Test failure blocking'),
};
const blockingResult = await handler.sendMessage(blockingParams, serverCallContext);
const blockingTask = blockingResult as Task;
assert.equal(blockingTask.kind, 'task', 'Result should be a task');
assert.equal(blockingTask.status.state, 'failed', 'Task status should be failed');
assert.include(
(blockingTask.status.message?.parts[0] as any).text,
errorMessage,
'Error message should be in the status'
);
});
it('sendMessage: (non-blocking) should return first task event immediately and process full task in background', async () => {
vi.useFakeTimers();
const saveSpy = vi.spyOn(mockTaskStore, 'save');
const params: MessageSendParams = {
message: createTestMessage('msg-nonblock', 'Do a long task'),
configuration: { blocking: false, acceptedOutputModes: [] },
};
const taskId = 'task-nonblock-123';
const contextId = 'ctx-nonblock-abc';
(mockAgentExecutor as MockAgentExecutor).execute.mockImplementation(async (ctx, bus) => {
// First event is the task creation, which should be returned immediately
bus.publish({
id: taskId,
contextId,
status: { state: 'submitted' },
kind: 'task',
});
// Simulate work before publishing more events
await vi.advanceTimersByTimeAsync(500);
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: { state: 'completed' },
final: true,
});
bus.finished();
});
// This call should return as soon as the first 'task' event is published
const immediateResult = await handler.sendMessage(params, serverCallContext);
// Assert that we got the initial task object back right away
const taskResult = immediateResult as Task;
assert.equal(taskResult.kind, 'task');
assert.equal(taskResult.id, taskId);
assert.equal(
taskResult.status.state,
'submitted',
"Should return immediately with 'submitted' state"
);
// The background processing should not have completed yet
expect(saveSpy).toHaveBeenCalledTimes(1);
assert.equal(saveSpy.mock.calls[0][0].status.state, 'submitted');
// Allow the background processing to complete
await vi.runAllTimersAsync();
// Now, check the final state in the store to ensure background processing finished
const finalTask = await mockTaskStore.load(taskId, serverCallContext);
assert.isDefined(finalTask);
assert.equal(
finalTask!.status.state,
'completed',
"Task should be 'completed' in the store after background processing"
);
expect(saveSpy).toHaveBeenCalledTimes(2);
assert.equal(saveSpy.mock.calls[1][0].status.state, 'completed');
});
it('sendMessage: (non-blocking) should handle failure in event loop after successfull task event', async () => {
vi.useFakeTimers();
const mockTaskStore = new MockTaskStore();
const handler = new DefaultRequestHandler(
testAgentCard,
mockTaskStore,
mockAgentExecutor,
executionEventBusManager
);
const params: MessageSendParams = {
message: createTestMessage('msg-nonblock', 'Do a long task'),
configuration: {
blocking: false,
acceptedOutputModes: [],
},
};
const taskId = 'task-nonblock-123';
const contextId = 'ctx-nonblock-abc';
(mockAgentExecutor as MockAgentExecutor).execute.mockImplementation(async (ctx, bus) => {
// First event is the task creation, which should be returned immediately
bus.publish({
id: taskId,
contextId,
status: { state: 'submitted' },
kind: 'task',
});
// Simulate work before publishing more events
await vi.advanceTimersByTimeAsync(500);
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: { state: 'completed' },
final: true,
});
bus.finished();
});
let finalTaskSaved: Task | undefined;
const errorMessage = 'Error thrown on saving completed task notification';
(mockTaskStore as MockTaskStore).save.mockImplementation(async (task) => {
if (task.status.state == 'completed') {
throw new Error(errorMessage);
}
if (task.status.state == 'failed') {
finalTaskSaved = task;
}
});
// This call should return as soon as the first 'task' event is published
const immediateResult = await handler.sendMessage(params, serverCallContext);
// Assert that we got the initial task object back right away
const taskResult = immediateResult as Task;
assert.equal(taskResult.kind, 'task');
assert.equal(taskResult.id, taskId);
assert.equal(
taskResult.status.state,
'submitted',
"Should return immediately with 'submitted' state"
);
// Allow the background processing to complete
await vi.runAllTimersAsync();
assert.equal(finalTaskSaved!.status.state, 'failed');
assert.equal(finalTaskSaved!.id, taskId);
assert.equal(finalTaskSaved!.contextId, contextId);
assert.equal(finalTaskSaved!.status.message!.role, 'agent');
assert.equal(
(finalTaskSaved!.status.message!.parts[0] as TextPart).text,
`Event processing loop failed: ${errorMessage}`
);
});
it('sendMessage: should handle agent execution failure for non-blocking calls', async () => {
const errorMessage = 'Agent failed!';
(mockAgentExecutor as MockAgentExecutor).execute.mockRejectedValue(new Error(errorMessage));
// Test non-blocking case
const nonBlockingParams: MessageSendParams = {
message: createTestMessage('msg-fail-nonblock', 'Test failure non-blocking'),
configuration: { blocking: false, acceptedOutputModes: [] },
};
const nonBlockingResult = await handler.sendMessage(nonBlockingParams, serverCallContext);
const nonBlockingTask = nonBlockingResult as Task;
assert.equal(nonBlockingTask.kind, 'task', 'Result should be a task');
assert.equal(nonBlockingTask.status.state, 'failed', 'Task status should be failed');
assert.include(
(nonBlockingTask.status.message?.parts[0] as any).text,
errorMessage,
'Error message should be in the status'
);
});
it('sendMessage: should return second task with full history if message is sent to an existing, non-terminal task', async () => {
const contextId = 'ctx-history-abc';
// First message
const firstMessage = createTestMessage('msg-1', 'Message 1');
firstMessage.contextId = contextId;
const firstParams: MessageSendParams = {
message: firstMessage,
};
let taskId: string;
(mockAgentExecutor as MockAgentExecutor).execute.mockImplementation(async (ctx, bus) => {
taskId = ctx.taskId;
// Publish task creation
bus.publish({
id: taskId,
contextId,
status: { state: 'submitted' },
kind: 'task',
});
// Publish working status
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: { state: 'working' },
final: false,
});
// Mark as input-required with agent response message
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: {
state: 'input-required',
message: {
messageId: 'agent-msg-1',
role: 'agent',
parts: [{ kind: 'text', text: 'Response to message 1' }],
kind: 'message',
taskId,
contextId,
},
},
final: true,
});
bus.finished();
});
const firstResult = await handler.sendMessage(firstParams, serverCallContext);
const firstTask = firstResult as Task;
// Check the first result is a task with `input-required` status
assert.equal(firstTask.kind, 'task');
assert.equal(firstTask.status.state, 'input-required');
// Check the history
assert.isDefined(firstTask.history, 'First task should have history');
assert.lengthOf(
firstTask.history!,
2,
'First task history should contain user message and agent message'
);
assert.equal(
firstTask.history![0].messageId,
'msg-1',
'First history item should be user message'
);
assert.equal(
firstTask.history![1].messageId,
'agent-msg-1',
'Second history item should be agent message'
);
// Second message
const secondMessage = createTestMessage('msg-2', 'Message 2');
secondMessage.contextId = contextId;
secondMessage.taskId = firstTask.id;
const secondParams: MessageSendParams = {
message: secondMessage,
};
(mockAgentExecutor as MockAgentExecutor).execute.mockImplementation(async (ctx, bus) => {
// Publish a status update with working state
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: { state: 'working' },
final: false,
});
// Publish a status update with working state and message
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: {
state: 'working',
message: {
messageId: 'agent-msg-2',
role: 'agent',
parts: [{ kind: 'text', text: 'Response to message 2' }],
kind: 'message',
taskId,
contextId,
},
},
final: false,
});
// Publish an artifact update
bus.publish({
taskId,
contextId,
kind: 'artifact-update',
artifact: {
artifactId: 'artifact-1',
name: 'Test Document',
description: 'A test artifact.',
parts: [{ kind: 'text', text: 'This is the content of the artifact.' }],
},
});
// Mark as completed
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: {
state: 'completed',
},
final: true,
});
bus.finished();
});
const secondResult = await handler.sendMessage(secondParams, serverCallContext);
const secondTask = secondResult as Task;
// Check the second result is a task with `completed` status
assert.equal(secondTask.kind, 'task');
assert.equal(secondTask.id, taskId, 'Should be the same task');
assert.equal(secondTask.status.state, 'completed');
// Check the history
assert.isDefined(secondTask.history, 'Second task should have history');
assert.lengthOf(
secondTask.history!,
4,
'Second task history should contain all 4 messages (user1, agent1, user2, agent2)'
);
assert.equal(
secondTask.history![0].messageId,
'msg-1',
'First message should be first user message'
);
assert.equal((secondTask.history![0].parts[0] as any).text, 'Message 1');
assert.equal(
secondTask.history![1].messageId,
'agent-msg-1',
'Second message should be first agent message'
);
assert.equal((secondTask.history![1].parts[0] as any).text, 'Response to message 1');
assert.equal(
secondTask.history![2].messageId,
'msg-2',
'Third message should be second user message'
);
assert.equal((secondTask.history![2].parts[0] as any).text, 'Message 2');
assert.equal(
secondTask.history![3].messageId,
'agent-msg-2',
'Fourth message should be second agent message'
);
assert.equal((secondTask.history![3].parts[0] as any).text, 'Response to message 2');
assert.equal(secondTask.artifacts![0].artifactId, 'artifact-1', 'Artifact should be the same');
assert.equal(
secondTask.artifacts![0].name,
'Test Document',
'Artifact name should be the same'
);
assert.equal(
secondTask.artifacts![0].description,
'A test artifact.',
'Artifact description should be the same'
);
assert.equal(
(secondTask.artifacts![0].parts[0] as any).text,
'This is the content of the artifact.',
'Artifact content should be the same'
);
});
it('sendMessage: should return second task with full history if message is sent to an existing, non-terminal task, in non-blocking mode', async () => {
const contextId = 'ctx-history-abc';
vi.useFakeTimers();
// First message
const firstMessage = createTestMessage('msg-1', 'Message 1');
firstMessage.contextId = contextId;
const firstParams: MessageSendParams = {
message: firstMessage,
};
let taskId: string;
(mockAgentExecutor as MockAgentExecutor).execute.mockImplementation(async (ctx, bus) => {
taskId = ctx.taskId;
// Publish task creation
bus.publish({
id: taskId,
contextId,
status: { state: 'submitted' },
kind: 'task',
});
// Publish working status
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: { state: 'working' },
final: false,
});
// Mark as input-required with agent response message
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: {
state: 'input-required',
message: {
messageId: 'agent-msg-1',
role: 'agent',
parts: [{ kind: 'text', text: 'Response to message 1' }],
kind: 'message',
taskId,
contextId,
},
},
final: true,
});
bus.finished();
});
const firstResult = await handler.sendMessage(firstParams, serverCallContext);
const firstTask = firstResult as Task;
// Check the first result is a task with `input-required` status
assert.equal(firstTask.kind, 'task');
assert.equal(firstTask.status.state, 'input-required');
// Check the history
assert.isDefined(firstTask.history, 'First task should have history');
assert.lengthOf(
firstTask.history!,
2,
'First task history should contain user message and agent message'
);
assert.equal(
firstTask.history![0].messageId,
'msg-1',
'First history item should be user message'
);
assert.equal(
firstTask.history![1].messageId,
'agent-msg-1',
'Second history item should be agent message'
);
// Second message
const secondMessage = createTestMessage('msg-2', 'Message 2');
secondMessage.contextId = contextId;
secondMessage.taskId = firstTask.id;
const secondParams: MessageSendParams = {
message: secondMessage,
configuration: { blocking: false },
};
(mockAgentExecutor as MockAgentExecutor).execute.mockImplementation(async (ctx, bus) => {
// Publish a status update with working state
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: { state: 'working' },
final: false,
});
await vi.advanceTimersByTimeAsync(10);
// Publish a status update with working state and message
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: {
state: 'working',
message: {
messageId: 'agent-msg-2',
role: 'agent',
parts: [{ kind: 'text', text: 'Response to message 2' }],
kind: 'message',
taskId,
contextId,
},
},
final: false,
});
// Publish an artifact update
bus.publish({
taskId,
contextId,
kind: 'artifact-update',
artifact: {
artifactId: 'artifact-1',
name: 'Test Document',
description: 'A test artifact.',
parts: [{ kind: 'text', text: 'This is the content of the artifact.' }],
},
});
// Mark as completed
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: {
state: 'completed',
},
final: true,
});
bus.finished();
});
const secondResult = await handler.sendMessage(secondParams, serverCallContext);
// Check the second result is a task with `completed` status
const secondTask = secondResult as Task;
assert.equal(secondTask.kind, 'task');
assert.equal(secondTask.id, taskId, 'Should be the same task');
assert.equal(secondTask.status.state, 'working'); // It will receive the Task in the status of the first published event
await vi.runAllTimersAsync(); // give time to the second task to publish all the updates
const finalTask = await mockTaskStore.load(taskId, serverCallContext);
// Check the history
assert.equal(finalTask.status.state, 'completed');
assert.isDefined(finalTask.history, 'Second task should have history');
assert.lengthOf(
finalTask.history!,
4,
'Second task history should contain all 4 messages (user1, agent1, user2, agent2)'
);
assert.equal(
finalTask.history![0].messageId,
'msg-1',
'First message should be first user message'
);
assert.equal((finalTask.history![0].parts[0] as any).text, 'Message 1');
assert.equal(
finalTask.history![1].messageId,
'agent-msg-1',
'Second message should be first agent message'
);
assert.equal((finalTask.history![1].parts[0] as any).text, 'Response to message 1');
assert.equal(
finalTask.history![2].messageId,
'msg-2',
'Third message should be second user message'
);
assert.equal((finalTask.history![2].parts[0] as any).text, 'Message 2');
assert.equal(
finalTask.history![3].messageId,
'agent-msg-2',
'Fourth message should be second agent message'
);
assert.equal((finalTask.history![3].parts[0] as any).text, 'Response to message 2');
assert.equal(finalTask.artifacts![0].artifactId, 'artifact-1', 'Artifact should be the same');
assert.equal(finalTask.artifacts![0].name, 'Test Document', 'Artifact name should be the same');
assert.equal(
finalTask.artifacts![0].description,
'A test artifact.',
'Artifact description should be the same'
);
assert.equal(
(finalTask.artifacts![0].parts[0] as any).text,
'This is the content of the artifact.',
'Artifact content should be the same'
);
});
it('sendMessageStream: should stream submitted, working, and completed events', async () => {
const params: MessageSendParams = {
message: createTestMessage('msg-3', 'Stream a task'),
};
const taskId = 'task-stream-1';
const contextId = 'ctx-stream-1';
(mockAgentExecutor as MockAgentExecutor).execute.mockImplementation(async (ctx, bus) => {
bus.publish({
id: taskId,
contextId,
status: { state: 'submitted' },
kind: 'task',
});
await new Promise((res) => setTimeout(res, 10));
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: { state: 'working' },
final: false,
});
await new Promise((res) => setTimeout(res, 10));
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: { state: 'completed' },
final: true,
});
bus.finished();
});
const eventGenerator = handler.sendMessageStream(params, serverCallContext);
const events = [];
for await (const event of eventGenerator) {
events.push(event);
}
assert.lengthOf(events, 3, 'Stream should yield 3 events');
assert.equal((events[0] as Task).status.state, 'submitted');
assert.equal((events[1] as TaskStatusUpdateEvent).status.state, 'working');
assert.equal((events[2] as TaskStatusUpdateEvent).status.state, 'completed');
assert.isTrue((events[2] as TaskStatusUpdateEvent).final);
});
it('sendMessage: should reject if task is in a terminal state', async () => {
const taskId = 'task-terminal-1';
const terminalStates: TaskState[] = ['completed', 'failed', 'canceled', 'rejected'];
for (const state of terminalStates) {
const fakeTask: Task = {
id: taskId,
contextId: 'ctx-terminal',
status: { state: state as TaskState },
kind: 'task',
};
await mockTaskStore.save(fakeTask, serverCallContext);
const params: MessageSendParams = {
message: { ...createTestMessage('msg-1', 'test'), taskId: taskId },
};
try {
await handler.sendMessage(params, serverCallContext);
assert.fail(`Should have thrown for state: ${state}`);
} catch (error: any) {
expect(error.code).to.equal(-32600); // Invalid Request
expect(error.message).to.contain(
`Task ${taskId} is in a terminal state (${state}) and cannot be modified.`
);
}
}
});
it('sendMessageStream: should reject if task is in a terminal state', async () => {
const taskId = 'task-terminal-2';
const fakeTask: Task = {
id: taskId,
contextId: 'ctx-terminal-stream',
status: { state: 'completed' },
kind: 'task',
};
await mockTaskStore.save(fakeTask, serverCallContext);
const params: MessageSendParams = {
message: { ...createTestMessage('msg-1', 'test'), taskId: taskId },
};
const generator = handler.sendMessageStream(params, serverCallContext);
try {
await generator.next();
assert.fail('sendMessageStream should have thrown an error');
} catch (error: any) {
expect(error.code).to.equal(-32600);
expect(error.message).to.contain(
`Task ${taskId} is in a terminal state (completed) and cannot be modified.`
);
}
});
it('sendMessageStream: should stop at input-required state', async () => {
const params: MessageSendParams = {
message: createTestMessage('msg-4', 'I need input'),
};
const taskId = 'task-input';
const contextId = 'ctx-input';
(mockAgentExecutor as MockAgentExecutor).execute.mockImplementation(async (ctx, bus) => {
bus.publish({
id: taskId,
contextId,
status: { state: 'submitted' },
kind: 'task',
});
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: { state: 'input-required' },
final: true,
});
bus.finished();
});
const eventGenerator = handler.sendMessageStream(params, serverCallContext);
const events = [];
for await (const event of eventGenerator) {
events.push(event);
}
assert.lengthOf(events, 2);
const lastEvent = events[1] as TaskStatusUpdateEvent;
assert.equal(lastEvent.status.state, 'input-required');
assert.isTrue(lastEvent.final);
});
it('resubscribe: should allow multiple clients to receive events for the same task', async () => {
const saveSpy = vi.spyOn(mockTaskStore, 'save');
vi.useFakeTimers();
const params: MessageSendParams = {
message: createTestMessage('msg-5', 'Long running task'),
};
let taskId;
let contextId;
(mockAgentExecutor as MockAgentExecutor).execute.mockImplementation(async (ctx, bus) => {
taskId = ctx.taskId;
contextId = ctx.contextId;
bus.publish({
id: taskId,
contextId,
status: { state: 'submitted' },
kind: 'task',
});
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: { state: 'working' },
final: false,
});
await vi.advanceTimersByTimeAsync(100);
bus.publish({
taskId,
contextId,
kind: 'status-update',
status: { state: 'completed' },
final: true,
});
bus.finished();
});
const stream1_generator = handler.sendMessageStream(params, serverCallContext);
const stream1_iterator = stream1_generator[Symbol.asyncIterator]();
const firstEventResult = await stream1_iterator.next();
const firstEvent = firstEventResult.value as Task;
assert.equal(firstEvent.id, taskId, 'Should get task event first');
const secondEventResult = await stream1_iterator.next();
const secondEvent = secondEventResult.value as TaskStatusUpdateEvent;
assert.equal(secondEvent.taskId, taskId, 'Should get the task status update event second');
const stream2_generator = handler.resubscribe({ id: taskId }, serverCallContext);
const results1: any[] = [firstEvent, secondEvent];
const results2: any[] = [];
const collect = async (iterator: AsyncGenerator<any>, results: any[]) => {
for await (const res of iterator) {
results.push(res);
}
};
const p1 = collect(stream1_iterator, results1);
const p2 = collect(stream2_generator, results2);
await vi.runAllTimersAsync();
await Promise.all([p1, p2]);
assert.equal((results1[0] as TaskStatusUpdateEvent).status.state, 'submitted');
assert.equal((results1[1] as TaskStatusUpdateEvent).status.state, 'working');
assert.equal((results1[2] as TaskStatusUpdateEvent).status.state, 'completed');
// First event of resubscribe is always a task.
assert.equal((results2[0] as Task).status.state, 'working');
assert.equal((results2[1] as TaskStatusUpdateEvent).status.state, 'completed');
expect(saveSpy).toHaveBeenCalledTimes(3);
const lastSaveCall = saveSpy.mock.calls[saveSpy.mock.calls.length - 1][0];
assert.equal(lastSaveCall.id, taskId);
assert.equal(lastSaveCall.status.state, 'completed');
});
it('getTask: should return an existing task from the store', async () => {
const fakeTask: Task = {
id: 'task-exist',
contextId: 'ctx-exist',
status: { state: 'working' },
kind: 'task',
history: [],
};
await mockTaskStore.save(fakeTask, serverCallContext);
const result = await handler.getTask({ id: 'task-exist' }, serverCallContext);
assert.deepEqual(result, fakeTask);
});
it('set/getTaskPushNotificationConfig: should save and retrieve config', async () => {
const taskId = 'task-push-config';
const fakeTask: Task = {
id: taskId,
contextId: 'ctx-push',
status: { state: 'working' },
kind: 'task',
};
await mockTaskStore.save(fakeTask, serverCallContext);
const pushConfig: PushNotificationConfig = {
id: 'config-1',
url: 'https://example.com/notify',
token: 'secret-token',
};
const setParams: TaskPushNotificationConfig = {
taskId,
pushNotificationConfig: pushConfig,
};
const setResponse = await handler.setTaskPushNotificationConfig(setParams, serverCallContext);
assert.deepEqual(
setResponse.pushNotificationConfig,
pushConfig,
'Set response should return the config'
);
const getParams: GetTaskPushNotificationConfigParams = {
id: taskId,
pushNotificationConfigId: 'config-1',
};
const getResponse = await handler.getTaskPushNotificationConfig(getParams, serverCallContext);
assert.deepEqual(
getResponse.pushNotificationConfig,
pushConfig,
'Get response should return the saved config'
);
});
it('set/getTaskPushNotificationConfig: should save and retrieve config by task ID for backward compatibility', async () => {
const taskId = 'task-push-compat';
await mockTaskStore.save(
{
id: taskId,
contextId: 'ctx-compat',
status: { state: 'working' },
kind: 'task',
},
serverCallContext
);
// Config ID defaults to task ID
const pushConfig: PushNotificationConfig = {
url: 'https://example.com/notify-compat',
};
await handler.setTaskPushNotificationConfig(
{
taskId,
pushNotificationConfig: pushConfig,
},
serverCallContext
);
const getResponse = await handler.getTaskPushNotificationConfig(
{
id: taskId,
},
serverCallContext
);
expect(getResponse.pushNotificationConfig.id).to.equal(taskId);
expect(getResponse.pushNotificationConfig.url).to.equal(pushConfig.url);
});
it('setTaskPushNotificationConfig: should overwrite an existing config with the same ID', async () => {
const taskId = 'task-overwrite';
await mockTaskStore.save(
{
id: taskId,
contextId: 'ctx-overwrite',
status: { state: 'working' },
kind: 'task',
},
serverCallContext
);
const initialConfig: PushNotificationConfig = {
id: 'config-same',
url: 'https://initial.url',
};
await handler.setTaskPushNotificationConfig(
{
taskId,
pushNotificationConfig: initialConfig,
},
serverCallContext
);
const newConfig: PushNotificationConfig = {
id: 'config-same',
url: 'https://new.url',
};
await handler.setTaskPushNotificationConfig(
{
taskId,
pushNotificationConfig: newConfig,
},
serverCallContext
);
const configs = await handler.listTaskPushNotificationConfigs(
{
id: taskId,
},
serverCallContext
);
expect(configs).to.have.lengthOf(1);
expect(configs[0].pushNotificationConfig.url).to.equal('https://new.url');
});
it('listTaskPushNotificationConfigs: should return all configs for a task', async () => {
const taskId = 'task-list-configs';
await mockTaskStore.save(
{
id: taskId,
contextId: 'ctx-list',
status: { state: 'working' },
kind: 'task',
},
serverCallContext
);
const config1: PushNotificationConfig = {
id: 'cfg1',
url: 'https://url1.com',
};
const config2: PushNotificationConfig = {
id: 'cfg2',
url: 'https://url2.com',
};
await handler.setTaskPushNotificationConfig(
{
taskId,
pushNotificationConfig: config1,
},
serverCallContext
);
await handler.setTaskPushNotificationConfig(
{
taskId,
pushNotificationConfig: config2,
},
serverCallContext
);
const listParams: ListTaskPushNotificationConfigParams = { id: taskId };
const listResponse = await handler.listTaskPushNotificationConfigs(
listParams,
serverCallContext
);
expect(listResponse).to.be.an('array').with.lengthOf(2);
assert.deepInclude(listResponse, {
taskId,
pushNotificationConfig: config1,
});
assert.deepInclude(listResponse, {
taskId,
pushNotificationConfig: config2,
});
});
it('deleteTaskPushNotificationConfig: should remove a specific config', async () => {
const taskId = 'task-delete-config';
await mockTaskStore.save(
{
id: taskId,
contextId: 'ctx-delete',
status: { state: 'working' },
kind: 'task',
},
serverCallContext
);
const config1: PushNotificationConfig = {
id: 'cfg-del-1',
url: 'https://url1.com',
};
const config2: PushNotificationConfig = {
id: 'cfg-del-2',
url: 'https://url2.com',
};
await handler.setTaskPushNotificationConfig(
{
taskId,
pushNotificationConfig: config1,
},
serverCallContext
);
await handler.setTaskPushNotificationConfig(
{
taskId,
pushNotificationConfig: config2,
},
serverCallContext
);
const deleteParams: DeleteTaskPushNotificationConfigParams = {
id: taskId,
pushNotificationConfigId: 'cfg-del-1',
};
await handler.deleteTaskPushNotificationConfig(deleteParams, serverCallContext);
const remainingConfigs = await handler.listTaskPushNotificationConfigs(
{
id: taskId,
},
serverCallContext
);
expect(remainingConfigs).to.have.lengthOf(1);
expect(remainingConfigs[0].pushNotificationConfig.id).to.equal('cfg-del-2');
});
it('deleteTaskPushNotificationConfig: should remove the whole entry if last config is deleted', async () => {
const taskId = 'task-delete-last-config';
await mockTaskStore.save(
{
id: taskId,
contextId: 'ctx-delete-last',
status: { state: 'working' },
kind: 'task',
},
serverCallContext
);
const config: PushNotificationConfig = {
id: 'cfg-last',
url: 'https://last.com',
};
await handler.setTaskPushNotificationConfig(
{
taskId,
pushNotificationConfig: config,
},
serverCallContext
);
await handler.deleteTaskPushNotificationConfig(
{
id: taskId,
pushNotificationConfigId: 'cfg-last',
},
serverCallContext
);
const configs = await handler.listTaskPushNotificationConfigs(
{
id: taskId,
},
serverCallContext
);
expect(configs).to.be.an('array').with.lengthOf(0);
});
it('should send push notification when task update is received', async () => {
const mockPushNotificationStore = new InMemoryPushNotificationStore();
const mockPushNotificationSender = new MockPushNotificationSender();
const handler = new DefaultRequestHandler(
testAgentCard,
mockTaskStore,
mockAgentExecutor,
executionEventBusManager,
mockPushNotificationStore,
mockPushNotificationSender
);
const pushNotificationConfig: PushNotificationConfig = {
url: 'https://push-1.com',
};
const contextId = 'ctx-push-1';
const params: MessageSendParams = {
message: {
...createTestMessage('msg-push-1', 'Work on task with push notification'),
contextId: contextId,
},
configuration: {
pushNotificationConfig: pushNotificationConfig,
},
};
let taskId: string;
(mockAgentExecutor as MockAgentExecutor).execute.mockImplementation(async (ctx, bus) => {
taskId = ctx.taskId;
fakeTaskExecute(ctx, bus);
});
await handler.sendMessage(params, serverCallContext);
const expectedTask: Task = {
id: taskId,
contextId,
status: { state: 'completed' },
kind: 'task',
history: [params.message as Message],
};
// Verify push notifications were sent with complete task objects
expect((mockPushNotificationSender as MockPushNotificationSender).send).toHaveBeenCalledTimes(
3
);
// Verify first call (submitted state)
const firstCallTask = (mockPushNotificationSender as MockPushNotificationSender).send.mock
.calls[0][0] as Task;
const expectedFirstTask: Task = {
...expectedTask,
status: { state: 'submitted' },
};
assert.deepEqual(firstCallTask, expectedFirstTask);
// // Verify second call (working state)
const secondCallTask = (mockPushNotificationSender as MockPushNotificationSender).send.mock
.calls[1][0] as Task;
const expectedSecondTask: Task = {
...expectedTask,
status: { state: 'working' },
};
assert.deepEqual(secondCallTask, expectedSecondTask);
// // Verify third call (completed state)
const thirdCallTask = (mockPushNotificationSender as MockPushNotificationSender).send.mock
.calls[2][0] as Task;
const expectedThirdTask: Task = {
...expectedTask,
status: { state: 'completed' },
};
assert.deepEqual(thirdCallTask, expectedThirdTask);
});
it('sendMessageStream: should send push notification when task update is received', async () => {
const mockPushNotificationStore = new InMemoryPushNotificationStore();
const mockPushNotificationSender = new MockPushNotificationSender();
const handler = new DefaultRequestHandler(
testAgentCard,
mockTaskStore,
mockAgentExecutor,
executionEventBusManager,
mockPushNotificationStore,
mockPushNotificationSender
);
const pushNotificationConfig: PushNotificationConfig = {
url: 'https://push-stream-1.com',
};
const contextId = 'ctx-push-stream-1';
const params: MessageSendParams = {
message: {
...createTestMessage('msg-push-stream-1', 'Work on task with push notification via stream'),
contextId: contextId,
},
configuration: {
pushNotificationConfig: pushNotificationConfig,
},
};
let taskId: string;
(mockAgentExecutor as MockAgentExecutor).execute.mockImplementation(async (ctx, bus) => {
taskId = ctx.taskId;
fakeTaskExecute(ctx, bus);
});
const eventGenerator = handler.sendMessageStream(params, serverCallContext);
const events = [];
for await (const event of eventGenerator) {
events.push(event);
}
// Verify stream events
assert.lengthOf(events, 3, 'Stream should yield 3 events');
assert.equal((events[0] as Task).status.state, 'submitted');
assert.equal((events[1] as TaskStatusUpdateEvent).status.state, 'working');
assert.equal((events[2] as TaskStatusUpdateEvent).status.state, 'completed');
assert.isTrue((events[2] as TaskStatusUpdateEvent).final);
// Verify push notifications were sent with complete task objects
expect((mockPushNotificationSender as MockPushNotificationSender).send).toHaveBeenCalledTimes(
3
);
const expectedTask: Task = {
id: taskId,
contextId,
status: { state: 'completed' },
kind: 'task',
history: [params.message as Message],
};
// Verify first call (submitted state)
const firstCallTask = (mockPushNotificationSender as MockPushNotificationSender).send.mock
.calls[0][0] as Task;
const expectedFirstTask: Task = {
...expectedTask,
status: { state: 'submitted' },
};
assert.deepEqual(firstCallTask, expectedFirstTask);
// Verify second call (working state)
const secondCallTask = (mockPushNotificationSender as MockPushNotificationSender).send.mock
.calls[1][0] as Task;
const expectedSecondTask: Task = {
...expectedTask,
status: { state: 'working' },
};
assert.deepEqual(secondCallTask, expectedSecondTask);
// Verify third call (completed state)
const thirdCallTask = (mockPushNotificationSender as MockPushNotificationSender).send.mock
.calls[2][0] as Task;
const expectedThirdTask: Task = {
...expectedTask,
status: { state: 'completed' },
};
assert.deepEqual(thirdCallTask, expectedThirdTask);
});
it('Push Notification methods should throw error if task does not exist', async () => {
const nonExistentTaskId = 'task-non-existent';
const config: PushNotificationConfig = {
id: 'cfg-x',
url: 'https://x.com',
};
const methodsToTest = [
{
name: 'setTaskPushNotificationConfig',
params: { taskId: nonExistentTaskId, pushNotificationConfig: config },
},
{
name: 'getTaskPushNotificationConfig',
params: { id: nonExistentTaskId, pushNotificationConfigId: 'cfg-x' },
},
{
name: 'listTaskPushNotificationConfigs',
params: { id: nonExistentTaskId },
},
{
name: 'deleteTaskPushNotificationConfig',
params: { id: nonExistentTaskId, pushNotificationConfigId: 'cfg-x' },
},
];
for (const method of methodsToTest) {
try {
await (handler as any)[method.name](method.params, serverCallContext);
assert.fail(`Method ${method.name} should have thrown for non-existent task.`);
} catch (error: any) {
expect(error).to.be.instanceOf(A2AError);
expect(error.code).to.equal(-32001); // Task Not Found
}
}
});
it('Push Notification methods should throw error if pushNotifications are not supported', async () => {
const unsupportedAgentCard = {
...testAgentCard,
capabilities: { ...testAgentCard.capabilities, pushNotifications: false },
};
handler = new DefaultRequestHandler(
unsupportedAgentCard,
mockTaskStore,
mockAgentExecutor,
executionEventBusManager
);
const taskId = 'task-unsupported';
await mockTaskStore.save(
{
id: taskId,
contextId: 'ctx-unsupported',
status: { state: 'working' },
kind: 'task',
},
serverCallContext
);
const config: PushNotificationConfig = {
id: 'cfg-u',
url: 'https://u.com',
};
const methodsToTest = [
{
name: 'setTaskPushNotificationConfig',
params: { taskId, pushNotificationConfig: config },
},
{
name: 'getTaskPushNotificationConfig',
params: { id: taskId, pushNotificationConfigId: 'cfg-u' },
},
{ name: 'listTaskPushNotificationConfigs', params: { id: taskId } },
{
name: 'deleteTaskPushNotificationConfig',
params: { id: taskId, pushNotificationConfigId: 'cfg-u' },
},
];
for (const method of methodsToTest) {
try {
await (handler as any)[method.name](method.params);
assert.fail(`Method ${method.name} should have thrown for unsupported push notifications.`);
} catch (error: any) {
expect(error).to.be.instanceOf(A2AError);
expect(error.code).to.equal(-32003); // Push Notification Not Supported
}
}
});
it('cancelTask: should cancel a running task and notify listeners', async () => {
vi.useFakeTimers();
// Use the more advanced mock for this specific test
const cancellableExecutor = new CancellableMockAgentExecutor();
handler = new DefaultRequestHandler(
testAgentCard,
mockTaskStore,
cancellableExecutor,
executionEventBusManager
);
const streamParams: MessageSendParams = {
message: createTestMessage('msg-9', 'Start and cancel'),
};
const streamGenerator = handler.sendMessageStream(streamParams, serverCallContext);
const streamEvents: any[] = [];
(async () => {
for await (const event of streamGenerator) {
streamEvents.push(event);
}
})();
// Allow the task to be created and enter the 'working' state
await vi.advanceTimersByTimeAsync(150);
const createdTask = streamEvents.find((e) => e.kind === 'task') as Task;
assert.isDefined(createdTask, 'Task creation event should have been received');
const taskId = createdTask.id;
// Now, issue the cancel request
const cancelResponse = await handler.cancelTask({ id: taskId }, serverCallContext);
// Let the executor's loop run to completion to detect the cancellation
await vi.runAllTimersAsync();
expect(cancellableExecutor.cancelTaskSpy).toHaveBeenCalledExactlyOnceWith(
taskId,
expect.anything()
);
const finalTask = await handler.getTask({ id: taskId }, serverCallContext);
assert.equal(finalTask.status.state, 'canceled');
assert.equal(cancelResponse.status.state, 'canceled');
});
it('cancelTask: should fail when it fails to cancel a task', async () => {
vi.useFakeTimers();
// Use the more advanced mock for this specific test
const failingCancellableExecutor = new FailingCancellableMockAgentExecutor();
handler = new DefaultRequestHandler(
testAgentCard,
mockTaskStore,
failingCancellableExecutor,
executionEventBusManager
);
const streamParams: MessageSendParams = {
message: createTestMessage('msg-9', 'Start and cancel'),
};
const streamGenerator = handler.sendMessageStream(streamParams, serverCallContext);
const streamEvents: any[] = [];
(async () => {
for await (const event of streamGenerator) {
streamEvents.push(event);
}
})();
// Allow the task to be created and enter the 'working' state
await vi.advanceTimersByTimeAsync(150);
const createdTask = streamEvents.find((e) => e.kind === 'task') as Task;
assert.isDefined(createdTask, 'Task creation event should have been received');
const taskId = createdTask.id;
let cancelResponse: Task;
let thrownError: any;
try {
cancelResponse = await handler.cancelTask({ id: taskId }, serverCallContext);
} catch (error: any) {
thrownError = error;
} finally {
assert.isDefined(thrownError);
assert.isUndefined(cancelResponse);
assert.equal(thrownError.code, -32002);
expect(thrownError.message).to.contain('Task not cancelable');
expect(failingCancellableExecutor.cancelTaskSpy).toHaveBeenCalledWith(
taskId,
expect.anything()
);
}
});
it('cancelTask: should fail for tasks in a terminal state', async () => {
const taskId = 'task-terminal';
const fakeTask: Task = {
id: taskId,
contextId: 'ctx-terminal',
status: { state: 'completed' },
kind: 'task',
};
await mockTaskStore.save(fakeTask, serverCallContext);
try {
await handler.cancelTask({ id: taskId }, serverCallContext);
assert.fail('Should have thrown a TaskNotCancelableError');
} catch (error: any) {
assert.equal(error.code, -32002);
expect(error.message).to.contain('Task not cancelable');
}
expect((mockAgentExecutor as MockAgentExecutor).cancelTask).not.toHaveBeenCalled();
});
it('should use contextId from incomingMessage if present (contextId assignment logic)', async () => {
const params: MessageSendParams = {
message: {
messageId: 'msg-ctx',
role: 'user',
parts: [{ kind: 'text', text: 'Hello' }],
kind: 'message',
contextId: 'incoming-ctx-id',
},
};
let capturedContextId: string | undefined;
(mockAgentExecutor.execute as unknown as Mock).mockImplementation(async (ctx, bus) => {
capturedContextId = ctx.contextId;
bus.publish({
id: ctx.taskId,
contextId: ctx.contextId,
status: { state: 'submitted' },
kind: 'task',
});
bus.finished();
});
await handler.sendMessage(params, serverCallContext);
expect(capturedContextId).to.equal('incoming-ctx-id');
});
it('should use contextId from task if not present in incomingMessage (contextId assignment logic)', async () => {
const taskId = 'task-ctx-id';
const taskContextId = 'task-context-id';
await mockTaskStore.save(
{
id: taskId,
contextId: taskContextId,
status: { state: 'working' },
kind: 'task',
},
serverCallContext
);
const params: MessageSendParams = {
message: {
messageId: 'msg-ctx2',
role: 'user',
parts: [{ kind: 'text', text: 'Hi' }],
kind: 'message',
taskId,
},
};
let capturedContextId: string | undefined;
(mockAgentExecutor.execute as unknown as Mock).mockImplementation(async (ctx, bus) => {
capturedContextId = ctx.contextId;
bus.publish({
id: ctx.taskId,
contextId: ctx.contextId,
status: { state: 'submitted' },
kind: 'task',
});
bus.finished();
});
await handler.sendMessage(params, serverCallContext);
expect(capturedContextId).to.equal(taskContextId);
});
it('should generate a new contextId if not present in message or task (contextId assignment logic)', async () => {
const params: MessageSendParams = {
message: {
messageId: 'msg-ctx3',
role: 'user',
parts: [{ kind: 'text', text: 'Hey' }],
kind: 'message',
},
};
let capturedContextId: string | undefined;
(mockAgentExecutor.execute as unknown as Mock).mockImplementation(async (ctx, bus) => {
capturedContextId = ctx.contextId;
bus.publish({
id: ctx.taskId,
contextId: ctx.contextId,
status: { state: 'submitted' },
kind: 'task',
});
bus.finished();
});
await handler.sendMessage(params, serverCallContext);
expect(capturedContextId).to.be.a('string').and.not.empty;
});
it('ExecutionEventQueue should be instantiable and return an object', () => {
const fakeBus = {
on: () => {},
off: () => {},
} as any;
const queue = new ExecutionEventQueue(fakeBus);
expect(queue).to.be.instanceOf(ExecutionEventQueue);
});
it('should pass a RequestContext with expected content to agentExecutor.execute', async () => {
const messageId = 'msg-expected-ctx';
const userMessageText = 'Verify RequestContext content.';
const incomingContextId = 'custom-context-id';
const incomingTaskId = 'custom-task-id';
const expectedExtension = 'requested-extension-uri';
const params: MessageSendParams = {
message: {
messageId: messageId,
role: 'user',
parts: [{ kind: 'text', text: userMessageText }],
kind: 'message',
contextId: incomingContextId,
taskId: incomingTaskId,
},
};
let capturedRequestContext: RequestContext | undefined;
(mockAgentExecutor.execute as unknown as Mock).mockImplementation(
async (ctx: RequestContext, bus: ExecutionEventBus) => {
capturedRequestContext = ctx;
bus.publish({
id: ctx.taskId,
contextId: ctx.contextId,
status: { state: 'submitted' },
kind: 'task',
});
bus.finished();
}
);
const fakeTask: Task = {
id: params.message.taskId!,
contextId: params.message.contextId!,
status: { state: 'submitted' as TaskState },
kind: 'task',
};
await mockTaskStore.save(fakeTask, serverCallContext);
await handler.sendMessage(
params,
new ServerCallContext(
[expectedExtension, 'not-available-extension-by-agent-card'],
new UnauthenticatedUser()
)
);
expect(capturedRequestContext).to.be.instanceOf(
RequestContext,
'Captured context should be an instance of RequestContext'
);
expect(capturedRequestContext?.userMessage.messageId).to.equal(
messageId,
'userMessage.messageId should match'
);
expect(capturedRequestContext?.taskId).to.equal(incomingTaskId, 'taskId should match');
expect(capturedRequestContext?.contextId).to.equal(incomingContextId, 'contextId should match');
expect(capturedRequestContext?.context?.requestedExtensions).to.deep.equal(
[expectedExtension],
'requestedExtensions should contain the expected extension'
);
expect(capturedRequestContext?.context?.user).to.be.an.instanceOf(UnauthenticatedUser);
});
describe('getAuthenticatedExtendedAgentCard tests', async () => {
class A2AUser implements User {
constructor(private _isAuthenticated: boolean) {}
get isAuthenticated(): boolean {
return this._isAuthenticated;
}
get userName(): string {
return 'test-user';
}
}
const extendedAgentcardProvider: ExtendedAgentCardProvider = async (context?) => {
if (context?.user?.isAuthenticated) {
return extendedAgentCard;
}
// Remove the extensions that are not allowed for unauthenticated clients
extendedAgentCard.capabilities.extensions = [{ uri: 'requested-extension-uri' }];
return extendedAgentCard;
};
const agentCardWithExtendedSupport: AgentCard = {
name: 'Test Agent',
description: 'An agent for testing purposes',
url: 'http://localhost:8080',
version: '1.0.0',
protocolVersion: '0.3.0',
capabilities: {
extensions: [{ uri: 'requested-extension-uri' }],
streaming: true,
pushNotifications: true,
},
defaultInputModes: ['text/plain'],
defaultOutputModes: ['text/plain'],
skills: [
{
id: 'test-skill',
name: 'Test Skill',
description: 'A skill for testing',
tags: ['test'],
},
],
supportsAuthenticatedExtendedCard: true,
};
const extendedAgentCard: AgentCard = {
name: 'Test ExtendedAgentCard Agent',
description: 'An agent for testing the extended agent card functionality',
url: 'http://localhost:8080',
version: '1.0.0',
protocolVersion: '0.3.0',
capabilities: {
extensions: [
{ uri: 'requested-extension-uri' },
{ uri: 'extension-uri-for-authenticated-clients' },
],
streaming: true,
pushNotifications: true,
},
defaultInputModes: ['text/plain'],
defaultOutputModes: ['text/plain'],
skills: [
{
id: 'test-skill',
name: 'Test Skill',
description: 'A skill for testing',
tags: ['test'],
},
],
};
it('getAuthenticatedExtendedAgentCard should fail if the agent card does not support extended agent card', async () => {
let caughtError;
try {
await handler.getAuthenticatedExtendedAgentCard();
} catch (error: any) {
caughtError = error;
} finally {
expect(caughtError).to.be.instanceOf(A2AError);
expect(caughtError.code).to.equal(-32004);
expect(caughtError.message).to.contain('Unsupported operation');
}
});
it('getAuthenticatedExtendedAgentCard should fail if ExtendedAgentCardProvider is not provided', async () => {
handler = new DefaultRequestHandler(
agentCardWithExtendedSupport,
mockTaskStore,
mockAgentExecutor,
executionEventBusManager
);
let caughtError;
try {
await handler.getAuthenticatedExtendedAgentCard();
} catch (error: any) {
caughtError = error;
} finally {
expect(caughtError).to.be.instanceOf(A2AError);
expect(caughtError.code).to.equal(-32007);
expect(caughtError.message).to.contain('Extended card not configured');
}
});
it('getAuthenticatedExtendedAgentCard should return extended card if user is authenticated with ExtendedAgentCardProvider as AgentCard', async () => {
handler = new DefaultRequestHandler(
agentCardWithExtendedSupport,
mockTaskStore,
mockAgentExecutor,
executionEventBusManager,
undefined,
undefined,
extendedAgentCard
);
const context = new ServerCallContext(undefined, new A2AUser(true));
const agentCard = await handler.getAuthenticatedExtendedAgentCard(context);
assert.deepEqual(agentCard, extendedAgentCard);
});
it('getAuthenticatedExtendedAgentCard should return capped extended card if user is not authenticated with ExtendedAgentCardProvider as callback', async () => {
handler = new DefaultRequestHandler(
agentCardWithExtendedSupport,
mockTaskStore,
mockAgentExecutor,
executionEventBusManager,
undefined,
undefined,
extendedAgentcardProvider
);
const context = new ServerCallContext(undefined, new A2AUser(false));
const agentCard = await handler.getAuthenticatedExtendedAgentCard(context);
assert(agentCard.capabilities.extensions.length === 1);
assert.deepEqual(agentCard.capabilities.extensions[0], { uri: 'requested-extension-uri' });
assert.deepEqual(agentCard.name, extendedAgentCard.name);
});
});
});