aixyz 0.11.0 → 0.13.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/model.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from "bun:test";
+import { fake, type Prompt } from "./model";
+
+const makeUserPrompt = (text: string) => [{ role: "user", content: [{ type: "text", text }] }];
+
+const identity = (input: string) => input;
+
+describe("fake model", () => {
+  test("has correct metadata", () => {
+    const model = fake(identity);
+    expect(model.specificationVersion).toBe("v3");
+    expect(model.provider).toBe("aixyz/fake");
+    expect(model.modelId).toBe("aixyz/fake");
+    expect(model.supportedUrls).toEqual({});
+  });
+
+  describe("doGenerate", () => {
+    test("echoes back the last user text with identity transform", async () => {
+      const model = fake(identity);
+      const result = await model.doGenerate({ prompt: makeUserPrompt("hello world") });
+      expect(result.content).toEqual([{ type: "text", text: "hello world" }]);
+      expect(result.finishReason).toBe("stop");
+      expect(result.warnings).toEqual([]);
+    });
+
+    test("applies custom transform to the last user text", async () => {
+      const model = fake((input) => `hello, ${input}`);
+      const result = await model.doGenerate({ prompt: makeUserPrompt("world") });
+      expect(result.content[0].text).toBe("hello, world");
+    });
+
+    test("applies custom transform to the last user message when multiple messages exist", async () => {
+      const model = fake((input) => `hello, ${input}`);
+      const prompt = [
+        { role: "user", content: [{ type: "text", text: "first" }] },
+        { role: "assistant", content: [{ type: "text", text: "reply" }] },
+        { role: "user", content: [{ type: "text", text: "you" }] },
+      ];
+      const result = await model.doGenerate({ prompt });
+      expect(result.content[0].text).toBe("hello, you");
+    });
+
+    test("passes full prompt as second argument to transform", async () => {
+      const model = fake((_input: string, prompt: Prompt) => `${prompt.length} turns`);
+      const prompt = [
+        { role: "user", content: [{ type: "text", text: "first" }] },
+        { role: "assistant", content: [{ type: "text", text: "reply" }] },
+        { role: "user", content: [{ type: "text", text: "second" }] },
+      ];
+      const result = await model.doGenerate({ prompt });
+      expect(result.content[0].text).toBe("3 turns");
+    });
+
+    test("returns zero usage", async () => {
+      const model = fake(identity);
+      const result = await model.doGenerate({ prompt: makeUserPrompt("hi") });
+      expect(result.usage.inputTokens.total).toBe(0);
+      expect(result.usage.outputTokens.total).toBe(0);
+    });
+
+    test("returns empty string when no user message", async () => {
+      const model = fake(identity);
+      const result = await model.doGenerate({ prompt: [] });
+      expect(result.content[0].text).toBe("");
+    });
+  });
+
+  describe("doStream", () => {
+    test("streams back the last user text with identity transform", async () => {
+      const model = fake(identity);
+      const { stream } = await model.doStream({ prompt: makeUserPrompt("stream me") });
+      const chunks: unknown[] = [];
+      for await (const chunk of stream) {
+        chunks.push(chunk);
+      }
+      expect(chunks[0]).toEqual({ type: "stream-start", warnings: [] });
+      expect(chunks[1]).toEqual({ type: "text-start", id: "1" });
+      expect(chunks[2]).toEqual({ type: "text-delta", id: "1", delta: "stream me" });
+      expect(chunks[3]).toEqual({ type: "text-end", id: "1" });
+      expect((chunks[4] as { type: string; finishReason: string }).finishReason).toBe("stop");
+    });
+
+    test("applies custom transform when streaming", async () => {
+      const model = fake((input) => `hello, ${input}`);
+      const { stream } = await model.doStream({ prompt: makeUserPrompt("you") });
+      const chunks: unknown[] = [];
+      for await (const chunk of stream) {
+        chunks.push(chunk);
+      }
+      expect(chunks[2]).toEqual({ type: "text-delta", id: "1", delta: "hello, you" });
+    });
+
+    test("stream contains finish chunk with zero usage", async () => {
+      const model = fake(identity);
+      const { stream } = await model.doStream({ prompt: makeUserPrompt("hi") });
+      const chunks: unknown[] = [];
+      for await (const chunk of stream) {
+        chunks.push(chunk);
+      }
+      const finish = chunks[4] as { type: string; usage: { inputTokens: { total: number } } };
+      expect(finish.type).toBe("finish");
+      expect(finish.usage.inputTokens.total).toBe(0);
+    });
+  });
+});

package/model.ts

@@ -0,0 +1,77 @@
+export type Prompt = Array<{ role: string; content: Array<{ type: string; text?: string }> }>;
+
+/**
+ * Returns the text of the last user message in the prompt, or an empty string if none exists.
+ * Searches backward through the prompt array for the last user role entry and returns the first
+ * text part found within it.
+ */
+function lastUserText(prompt: Prompt): string {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    if (prompt[i].role === "user") {
+      for (const part of prompt[i].content) {
+        if (part.type === "text" && part.text) {
+          return part.text;
+        }
+      }
+    }
+  }
+  return "";
+}
+
+/**
+ * Creates a fake language model for testing and development.
+ * Conforms to the LanguageModelV2 v3 specification with zero token usage.
+ *
+ * The `transform` function receives the last user message text and the full prompt,
+ * and returns the model output string.
+ *
+ * @example
+ * import { fake } from "aixyz/model";
+ *
+ * // custom transform using last message only
+ * const helloModel = fake((input) => `hello, ${input}`);
+ *
+ * // custom transform using full prompt context
+ * const contextModel = fake((input, prompt) => `${prompt.length} turns: ${input}`);
+ */
+export function fake(transform: (lastMessage: string, prompt: Prompt) => string) {
+  return {
+    specificationVersion: "v3" as const,
+    provider: "aixyz/fake",
+    modelId: "aixyz/fake",
+    supportedUrls: {},
+    doGenerate(options: { prompt: Prompt }) {
+      const text = transform(lastUserText(options.prompt), options.prompt);
+      return Promise.resolve({
+        content: [{ type: "text" as const, text }],
+        finishReason: "stop" as const,
+        usage: {
+          inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+          outputTokens: { total: 0, text: 0, reasoning: 0 },
+        },
+        warnings: [],
+      });
+    },
+    doStream(options: { prompt: Prompt }) {
+      const text = transform(lastUserText(options.prompt), options.prompt);
+      const stream = new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "stream-start" as const, warnings: [] });
+          controller.enqueue({ type: "text-start" as const, id: "1" });
+          controller.enqueue({ type: "text-delta" as const, id: "1", delta: text });
+          controller.enqueue({ type: "text-end" as const, id: "1" });
+          controller.enqueue({
+            type: "finish" as const,
+            finishReason: "stop" as const,
+            usage: {
+              inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+              outputTokens: { total: 0, text: 0, reasoning: 0 },
+            },
+          });
+          controller.close();
+        },
+      });
+      return Promise.resolve({ stream });
+    },
+  };
+}

package/package.json

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

package/server/adapters/a2a.ts

@@ -105,14 +105,14 @@ 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: true,
       pushNotifications: false,
@@ -129,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) {
@@ -140,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 {