aixyz 0.12.0 → 0.13.0

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.12.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.12.0",
-    "@aixyz/config": "0.12.0",
-    "@aixyz/erc-8004": "0.12.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",