aixyz 0.10.0 → 0.12.0

package/accepts.ts

@@ -34,5 +34,5 @@ export { HTTPFacilitatorClient };
  * The default facilitator client provided by aixyz.
  */
 export const facilitator: FacilitatorClient = new HTTPFacilitatorClient({
-  url: "https://x402.agently.to/facilitator",
+  url: "https://x402.use-agently.com/facilitator",
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aixyz",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Payment-native SDK for AI Agent",
   "keywords": [
     "ai",
@@ -23,9 +23,9 @@
   ],
   "dependencies": {
     "@a2a-js/sdk": "^0.3.10",
-    "@aixyz/cli": "0.10.0",
-    "@aixyz/config": "0.10.0",
-    "@aixyz/erc-8004": "0.10.0",
+    "@aixyz/cli": "0.12.0",
+    "@aixyz/config": "0.12.0",
+    "@aixyz/erc-8004": "0.12.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "@next/env": "^16.1.6",
     "@x402/core": "^2.3.1",

package/server/adapters/a2a.test.ts

@@ -0,0 +1,161 @@
+import { describe, expect, mock, test } from "bun:test";
+import { DefaultExecutionEventBus } from "@a2a-js/sdk/server";
+import type { Message, Task, TaskArtifactUpdateEvent, TaskStatusUpdateEvent } from "@a2a-js/sdk";
+import type { AgentExecutionEvent } from "@a2a-js/sdk/server";
+import { ToolLoopAgentExecutor } from "./a2a";
+import type { ToolLoopAgent } from "ai";
+import type { RequestContext } from "@a2a-js/sdk/server";
+
+function makeRequestContext(overrides?: Partial<RequestContext>): RequestContext {
+  return {
+    taskId: "task-1",
+    contextId: "ctx-1",
+    userMessage: {
+      kind: "message",
+      messageId: "msg-1",
+      role: "user",
+      parts: [{ kind: "text", text: "Hello!" }],
+    },
+    task: undefined,
+    referenceTasks: undefined,
+    context: undefined,
+    ...overrides,
+  } as unknown as RequestContext;
+}
+
+function makeAsyncIterable(chunks: string[]): AsyncIterable<string> {
+  return {
+    [Symbol.asyncIterator]: async function* () {
+      for (const chunk of chunks) {
+        yield chunk;
+      }
+    },
+  };
+}
+
+describe("ToolLoopAgentExecutor streaming", () => {
+  test("publishes initial task, working status, artifact chunks, and completed status when streaming", async () => {
+    const chunks = ["Hello", ", ", "world", "!"];
+    const mockAgent = {
+      stream: mock(async () => ({
+        textStream: makeAsyncIterable(chunks),
+      })),
+    } as unknown as ToolLoopAgent<never>;
+
+    const executor = new ToolLoopAgentExecutor(mockAgent);
+    const eventBus = new DefaultExecutionEventBus();
+
+    const events: AgentExecutionEvent[] = [];
+    eventBus.on("event", (event) => events.push(event));
+
+    const ctx = makeRequestContext();
+    await executor.execute(ctx, eventBus);
+
+    // First event: initial Task object
+    const initialTask = events[0] as Task;
+    expect(initialTask.kind).toBe("task");
+    expect(initialTask.id).toBe("task-1");
+    expect(initialTask.contextId).toBe("ctx-1");
+    expect(initialTask.status.state).toBe("submitted");
+
+    // Second event: working status
+    const workingUpdate = events[1] as TaskStatusUpdateEvent;
+    expect(workingUpdate.kind).toBe("status-update");
+    expect(workingUpdate.status.state).toBe("working");
+    expect(workingUpdate.final).toBe(false);
+    expect(workingUpdate.taskId).toBe("task-1");
+    expect(workingUpdate.contextId).toBe("ctx-1");
+
+    // Artifact update events (one per non-empty chunk)
+    const artifactUpdates = events.slice(2, events.length - 1) as TaskArtifactUpdateEvent[];
+    expect(artifactUpdates.length).toBe(chunks.length);
+    expect(artifactUpdates[0].kind).toBe("artifact-update");
+    expect(artifactUpdates[0].append).toBe(false);
+    expect((artifactUpdates[0].artifact.parts[0] as { kind: string; text: string }).text).toBe("Hello");
+
+    // Subsequent chunks should have append: true
+    expect(artifactUpdates[1].append).toBe(true);
+    expect((artifactUpdates[1].artifact.parts[0] as { kind: string; text: string }).text).toBe(", ");
+
+    // All artifact updates share the same artifactId
+    const artifactId = artifactUpdates[0].artifact.artifactId;
+    expect(artifactUpdates.every((e) => e.artifact.artifactId === artifactId)).toBe(true);
+
+    // Last event: completed status
+    const completedUpdate = events[events.length - 1] as TaskStatusUpdateEvent;
+    expect(completedUpdate.kind).toBe("status-update");
+    expect(completedUpdate.status.state).toBe("completed");
+    expect(completedUpdate.final).toBe(true);
+  });
+
+  test("does not publish initial task when task context already exists", async () => {
+    const mockAgent = {
+      stream: mock(async () => ({
+        textStream: makeAsyncIterable(["hi"]),
+      })),
+    } as unknown as ToolLoopAgent<never>;
+
+    const executor = new ToolLoopAgentExecutor(mockAgent);
+    const eventBus = new DefaultExecutionEventBus();
+
+    const events: AgentExecutionEvent[] = [];
+    eventBus.on("event", (event) => events.push(event));
+
+    const existingTask: Task = {
+      kind: "task",
+      id: "task-1",
+      contextId: "ctx-1",
+      status: { state: "working", timestamp: new Date().toISOString() },
+    };
+    await executor.execute(makeRequestContext({ task: existingTask }), eventBus);
+
+    // No initial task published; first event is working status
+    const first = events[0] as TaskStatusUpdateEvent;
+    expect(first.kind).toBe("status-update");
+    expect(first.status.state).toBe("working");
+  });
+
+  test("skips empty chunks", async () => {
+    const mockAgent = {
+      stream: mock(async () => ({
+        textStream: makeAsyncIterable(["", "content", ""]),
+      })),
+    } as unknown as ToolLoopAgent<never>;
+
+    const executor = new ToolLoopAgentExecutor(mockAgent);
+    const eventBus = new DefaultExecutionEventBus();
+
+    const events: AgentExecutionEvent[] = [];
+    eventBus.on("event", (event) => events.push(event));
+
+    await executor.execute(makeRequestContext(), eventBus);
+
+    // initial task + working + 1 artifact ("content") + completed
+    expect(events.length).toBe(4);
+    const artifact = events[2] as TaskArtifactUpdateEvent;
+    expect(artifact.kind).toBe("artifact-update");
+    expect((artifact.artifact.parts[0] as { kind: string; text: string }).text).toBe("content");
+  });
+
+  test("publishes error message and finishes when streaming throws", async () => {
+    const mockAgent = {
+      stream: mock(async () => {
+        throw new Error("stream failed");
+      }),
+    } as unknown as ToolLoopAgent<never>;
+
+    const executor = new ToolLoopAgentExecutor(mockAgent);
+    const eventBus = new DefaultExecutionEventBus();
+
+    const events: AgentExecutionEvent[] = [];
+    eventBus.on("event", (event) => events.push(event));
+
+    await executor.execute(makeRequestContext(), eventBus);
+
+    // initial task + working status + error message
+    expect(events.length).toBe(3);
+    const errorMsg = events[2] as Message;
+    expect(errorMsg.kind).toBe("message");
+    expect((errorMsg.parts[0] as { kind: string; text: string }).text).toContain("stream failed");
+  });
+});

package/server/adapters/a2a.ts

@@ -7,7 +7,7 @@ import {
   RequestContext,
   TaskStore,
 } from "@a2a-js/sdk/server";
-import { AgentCard, Message, TextPart } from "@a2a-js/sdk";
+import { AgentCard, Message, Task, TaskArtifactUpdateEvent, TaskStatusUpdateEvent, TextPart } from "@a2a-js/sdk";
 import type { ToolLoopAgent, ToolSet } from "ai";
 import { getAixyzConfigRuntime } from "../../config";
 import { AixyzServer } from "../index";
@@ -18,23 +18,66 @@ export class ToolLoopAgentExecutor<TOOLS extends ToolSet = ToolSet> implements A
   constructor(private agent: ToolLoopAgent<never, TOOLS>) {}
 
   async execute(requestContext: RequestContext, eventBus: ExecutionEventBus): Promise<void> {
+    const { taskId, contextId, userMessage, task } = requestContext;
     try {
       // Extract the user's message text
-      const userMessage = requestContext.userMessage;
       const textParts = userMessage.parts.filter((part): part is TextPart => part.kind === "text");
       const prompt = textParts.map((part) => part.text).join("\n");
 
-      // TODO(@fuxingloh): supporting streaming later
-      const result = await this.agent.generate({ prompt });
-      const responseMessage: Message = {
-        kind: "message",
-        messageId: randomUUID(),
-        role: "agent",
-        parts: [{ kind: "text", text: result.text }],
-        contextId: requestContext.contextId,
+      // Publish the initial Task object if one does not exist yet — required by ResultManager
+      // before any TaskArtifactUpdateEvent can be processed.
+      if (!task) {
+        const initialTask: Task = {
+          kind: "task",
+          id: taskId,
+          contextId,
+          status: { state: "submitted", timestamp: new Date().toISOString() },
+          history: [userMessage],
+        };
+        eventBus.publish(initialTask);
+      }
+
+      // Signal that the agent is working
+      const workingUpdate: TaskStatusUpdateEvent = {
+        kind: "status-update",
+        taskId,
+        contextId,
+        status: { state: "working", timestamp: new Date().toISOString() },
+        final: false,
       };
+      eventBus.publish(workingUpdate);
 
-      eventBus.publish(responseMessage);
+      // Stream the response and publish artifact chunks as they arrive
+      const result = await this.agent.stream({ prompt });
+      const artifactId = randomUUID();
+      let firstChunk = true;
+
+      for await (const chunk of result.textStream) {
+        if (chunk) {
+          const artifactUpdate: TaskArtifactUpdateEvent = {
+            kind: "artifact-update",
+            taskId,
+            contextId,
+            artifact: {
+              artifactId,
+              parts: [{ kind: "text", text: chunk }],
+            },
+            append: !firstChunk,
+          };
+          eventBus.publish(artifactUpdate);
+          firstChunk = false;
+        }
+      }
+
+      // Publish the final completed status
+      const completedUpdate: TaskStatusUpdateEvent = {
+        kind: "status-update",
+        taskId,
+        contextId,
+        status: { state: "completed", timestamp: new Date().toISOString() },
+        final: true,
+      };
+      eventBus.publish(completedUpdate);
       eventBus.finished();
     } catch (error) {
       // Handle errors by publishing an error message
@@ -48,7 +91,7 @@ export class ToolLoopAgentExecutor<TOOLS extends ToolSet = ToolSet> implements A
             text: `Error: ${error instanceof Error ? error.message : "An unknown error occurred"}`,
           },
         ],
-        contextId: requestContext.contextId,
+        contextId,
       };
 
       eventBus.publish(errorMessage);
@@ -62,16 +105,16 @@ export class ToolLoopAgentExecutor<TOOLS extends ToolSet = ToolSet> implements A
   }
 }
 
-export function getAgentCard(): AgentCard {
+export function getAgentCard(agentPath = "/agent"): AgentCard {
   const config = getAixyzConfigRuntime();
   return {
     name: config.name,
     description: config.description,
     protocolVersion: "0.3.0",
     version: config.version,
-    url: new URL("/agent", config.url).toString(),
+    url: new URL(agentPath, config.url).toString(),
     capabilities: {
-      streaming: false,
+      streaming: true,
       pushNotifications: false,
     },
     defaultInputModes: ["text/plain"],
@@ -86,6 +129,7 @@ export function useA2A<TOOLS extends ToolSet = ToolSet>(
     default: ToolLoopAgent<never, TOOLS>;
     accepts?: Accepts;
   },
+  prefix?: string,
   taskStore: TaskStore = new InMemoryTaskStore(),
 ): void {
   if (exports.accepts) {
@@ -97,22 +141,27 @@ export function useA2A<TOOLS extends ToolSet = ToolSet>(
     return;
   }
 
+  const agentPath: `/${string}` = prefix ? `/${prefix}/agent` : "/agent";
+  const wellKnownPath: `/${string}` = prefix
+    ? `/${prefix}/.well-known/agent-card.json`
+    : "/.well-known/agent-card.json";
+
   const agentExecutor = new ToolLoopAgentExecutor(exports.default);
-  const requestHandler = new DefaultRequestHandler(getAgentCard(), taskStore, agentExecutor);
+  const requestHandler = new DefaultRequestHandler(getAgentCard(agentPath), taskStore, agentExecutor);
 
   app.express.use(
-    "/.well-known/agent-card.json",
+    wellKnownPath,
     agentCardHandler({
       agentCardProvider: requestHandler,
     }),
   );
 
   if (exports.accepts.scheme === "exact") {
-    app.withX402Exact("POST /agent", exports.accepts);
+    app.withX402Exact(`POST ${agentPath}`, exports.accepts);
   }
 
   app.express.use(
-    "/agent",
+    agentPath,
     jsonRpcHandler({
       requestHandler,
       userBuilder: UserBuilder.noAuthentication,

package/server/adapters/erc-8004.ts

@@ -12,16 +12,16 @@ export function getAgentRegistrationFile(
   data: unknown,
   options: {
     mcp: boolean;
-    a2a: boolean;
+    a2a: string[];
   },
 ): StrictAgentRegistrationFile {
   const config = getAixyzConfigRuntime();
   const services: StrictAgentRegistrationFile["services"] = [];
 
-  if (options.a2a) {
+  for (const path of options.a2a) {
     services.push({
       name: "A2A",
-      endpoint: new URL("/.well-known/agent-card.json", config.url).toString(),
+      endpoint: new URL(path, config.url).toString(),
       version: "0.3.0",
     });
   }
@@ -53,7 +53,7 @@ export function useERC8004(
     default: unknown;
     options: {
       mcp: boolean;
-      a2a: boolean;
+      a2a: string[];
     };
   },
 ): void {