Add Kimi K2.5 text node

bchapuis · claude · bchapuis · commit 9aa13e9f8439 · 2026-03-28T00:58:45.000+01:00
Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/apps/api/src/runtime/cloudflare-node-registry.ts b/apps/api/src/runtime/cloudflare-node-registry.ts
@@ -407,6 +407,7 @@ import { DistilbertSst2Int8Node } from "@dafthunk/runtime/nodes/text/distilbert-
 import { Glm47FlashNode } from "@dafthunk/runtime/nodes/text/glm-4-7-flash-node";
 import { Hermes2ProMistral7BNode } from "@dafthunk/runtime/nodes/text/hermes-2-pro-mistral-7b-node";
 import { JsonStringTemplateNode } from "@dafthunk/runtime/nodes/text/json-string-template-node";
+import { KimiK25Node } from "@dafthunk/runtime/nodes/text/kimi-k2-5-node";
 import { Llama318BInstructFastNode } from "@dafthunk/runtime/nodes/text/llama-3-1-8b-instruct-fast-node";
 import { Llama3370BInstructFastNode } from "@dafthunk/runtime/nodes/text/llama-3-3-70b-instruct-fp8-fast-node";
 import { Llama4Scout17B16EInstructNode } from "@dafthunk/runtime/nodes/text/llama-4-scout-17b-16e-instruct-node";
@@ -548,6 +549,7 @@ export class CloudflareNodeRegistry extends BaseNodeRegistry<Bindings> {
     this.registerImplementation(Glm47FlashNode);
     this.registerImplementation(Qwq32BNode);
     this.registerImplementation(Qwen330BA3BFp8Node);
+    this.registerImplementation(KimiK25Node);
     this.registerImplementation(WhisperNode);
     this.registerImplementation(WhisperLargeV3TurboNode);
     this.registerImplementation(WhisperTinyEnNode);
diff --git a/packages/runtime/src/nodes/text/kimi-k2-5-node.test.ts b/packages/runtime/src/nodes/text/kimi-k2-5-node.test.ts
@@ -0,0 +1,215 @@
+import type { NodeContext } from "@dafthunk/runtime";
+import type { Node } from "@dafthunk/types";
+import { describe, expect, it } from "vitest";
+import { KimiK25Node } from "./kimi-k2-5-node";
+
+describe("KimiK25Node", () => {
+  const createContext = (
+    inputs: Record<string, unknown>,
+    aiResponse?: Record<string, unknown>
+  ): NodeContext => {
+    const mockAI = {
+      run: async () =>
+        aiResponse ?? {
+          choices: [
+            {
+              message: {
+                content: "Hello! How can I help you?",
+                reasoning_content: "The user greeted me.",
+              },
+            },
+          ],
+          usage: {
+            prompt_tokens: 10,
+            completion_tokens: 20,
+          },
+        },
+    };
+
+    return {
+      nodeId: "kimi-k2-5",
+      inputs,
+      getIntegration: async () => {
+        throw new Error("No integrations in test");
+      },
+      env: {
+        AI: mockAI,
+        AI_OPTIONS: {},
+      },
+    } as unknown as NodeContext;
+  };
+
+  it("should have correct node type metadata", () => {
+    expect(KimiK25Node.nodeType.id).toBe("kimi-k2-5");
+    expect(KimiK25Node.nodeType.name).toBe("Kimi K2.5");
+    expect(KimiK25Node.nodeType.icon).toBe("sparkles");
+    expect(KimiK25Node.nodeType.functionCalling).toBe(true);
+    expect(KimiK25Node.nodeType.usage).toBe(1);
+  });
+
+  it("should generate text from a prompt", async () => {
+    const node = new KimiK25Node({
+      nodeId: "kimi-k2-5",
+    } as unknown as Node);
+    const result = await node.execute(createContext({ prompt: "Hello" }));
+
+    expect(result.status).toBe("completed");
+    expect(result.outputs?.response).toBe("Hello! How can I help you?");
+    expect(result.outputs?.reasoning).toBe("The user greeted me.");
+  });
+
+  it("should generate text from messages JSON", async () => {
+    const messages = JSON.stringify([
+      { role: "user", content: "What is 2+2?" },
+    ]);
+    const node = new KimiK25Node({
+      nodeId: "kimi-k2-5",
+    } as unknown as Node);
+    const result = await node.execute(
+      createContext({ prompt: "fallback", messages })
+    );
+
+    expect(result.status).toBe("completed");
+    expect(result.outputs?.response).toBe("Hello! How can I help you?");
+  });
+
+  it("should fall back to prompt when messages JSON is invalid", async () => {
+    const node = new KimiK25Node({
+      nodeId: "kimi-k2-5",
+    } as unknown as Node);
+    const result = await node.execute(
+      createContext({ prompt: "Hello", messages: "not-valid-json" })
+    );
+
+    expect(result.status).toBe("completed");
+    expect(result.outputs?.response).toBe("Hello! How can I help you?");
+  });
+
+  it("should return error when AI service is not available", async () => {
+    const node = new KimiK25Node({
+      nodeId: "kimi-k2-5",
+    } as unknown as Node);
+    const context = {
+      nodeId: "kimi-k2-5",
+      inputs: { prompt: "Hello" },
+      getIntegration: async () => {
+        throw new Error("No integrations in test");
+      },
+      env: {},
+    } as unknown as NodeContext;
+
+    const result = await node.execute(context);
+    expect(result.status).toBe("error");
+    expect(result.error).toContain("AI service is not available");
+  });
+
+  it("should return error when neither prompt nor messages provided", async () => {
+    const node = new KimiK25Node({
+      nodeId: "kimi-k2-5",
+    } as unknown as Node);
+    const result = await node.execute(createContext({}));
+
+    expect(result.status).toBe("error");
+    expect(result.error).toContain(
+      "Either prompt or messages must be provided"
+    );
+  });
+
+  it("should handle response without reasoning content", async () => {
+    const node = new KimiK25Node({
+      nodeId: "kimi-k2-5",
+    } as unknown as Node);
+    const result = await node.execute(
+      createContext(
+        { prompt: "Hello" },
+        {
+          choices: [
+            {
+              message: {
+                content: "Hi there!",
+              },
+            },
+          ],
+          usage: {
+            prompt_tokens: 5,
+            completion_tokens: 10,
+          },
+        }
+      )
+    );
+
+    expect(result.status).toBe("completed");
+    expect(result.outputs?.response).toBe("Hi there!");
+    expect(result.outputs?.reasoning).toBeUndefined();
+  });
+
+  it("should handle empty response from model", async () => {
+    const node = new KimiK25Node({
+      nodeId: "kimi-k2-5",
+    } as unknown as Node);
+    const result = await node.execute(
+      createContext(
+        { prompt: "Hello" },
+        {
+          choices: [{ message: {} }],
+          usage: {
+            prompt_tokens: 5,
+            completion_tokens: 0,
+          },
+        }
+      )
+    );
+
+    expect(result.status).toBe("completed");
+    expect(result.outputs?.response).toBe("");
+  });
+
+  it("should handle AI.run throwing an error", async () => {
+    const node = new KimiK25Node({
+      nodeId: "kimi-k2-5",
+    } as unknown as Node);
+    const context = {
+      nodeId: "kimi-k2-5",
+      inputs: { prompt: "Hello" },
+      getIntegration: async () => {
+        throw new Error("No integrations in test");
+      },
+      env: {
+        AI: {
+          run: async () => {
+            throw new Error("Model inference failed");
+          },
+        },
+        AI_OPTIONS: {},
+      },
+    } as unknown as NodeContext;
+
+    const result = await node.execute(context);
+    expect(result.status).toBe("error");
+    expect(result.error).toContain("Model inference failed");
+  });
+
+  it("should fall back to text estimation when usage is not available", async () => {
+    const node = new KimiK25Node({
+      nodeId: "kimi-k2-5",
+    } as unknown as Node);
+    const result = await node.execute(
+      createContext(
+        { prompt: "Hello" },
+        {
+          choices: [
+            {
+              message: {
+                content: "Response text",
+              },
+            },
+          ],
+        }
+      )
+    );
+
+    expect(result.status).toBe("completed");
+    expect(result.outputs?.response).toBe("Response text");
+    expect(result.usage).toBeGreaterThanOrEqual(1);
+  });
+});
diff --git a/packages/runtime/src/nodes/text/kimi-k2-5-node.ts b/packages/runtime/src/nodes/text/kimi-k2-5-node.ts
@@ -0,0 +1,139 @@
+import { ExecutableNode, type NodeContext } from "@dafthunk/runtime";
+import type { NodeExecution, NodeType } from "@dafthunk/types";
+import type { TokenPricing } from "../../utils/usage";
+import { executeWorkersAiTextModel } from "./execute-workers-ai-text-model";
+
+// https://developers.cloudflare.com/workers-ai/platform/pricing/
+const PRICING: TokenPricing = {
+  inputCostPerMillion: 0.6,
+  outputCostPerMillion: 3.0,
+};
+
+/**
+ * Kimi K2.5 Node implementation with function calling support.
+ * Returns OpenAI chat-completions format (not standard Workers AI format).
+ */
+export class KimiK25Node extends ExecutableNode {
+  public static readonly nodeType: NodeType = {
+    id: "kimi-k2-5",
+    name: "Kimi K2.5",
+    type: "kimi-k2-5",
+    description:
+      "Generates text with function calling support using Kimi K2.5 model",
+    tags: ["AI", "LLM", "Cloudflare", "Kimi", "Moonshot", "Reasoning"],
+    icon: "sparkles",
+    documentation:
+      "This node generates text with function calling support using the Kimi K2.5 model by Moonshot AI. It features strong reasoning capabilities, multilingual support, and tool use.",
+    referenceUrl:
+      "https://developers.cloudflare.com/workers-ai/models/kimi-k2.5/",
+    usage: 1,
+    functionCalling: true,
+    inputs: [
+      {
+        name: "prompt",
+        type: "string",
+        description: "The input text prompt for the LLM",
+        required: true,
+      },
+      {
+        name: "messages",
+        type: "string",
+        description: "JSON string of conversation messages",
+        required: false,
+      },
+      {
+        name: "tools",
+        type: "json",
+        description: "Array of tool references for function calling",
+        hidden: true,
+        value: [] as any,
+      },
+      {
+        name: "temperature",
+        type: "number",
+        description: "Controls randomness in the output (0.0 to 5.0)",
+        hidden: true,
+        value: 0.7,
+      },
+      {
+        name: "max_tokens",
+        type: "number",
+        description:
+          "Maximum number of tokens to generate (includes reasoning tokens)",
+        hidden: true,
+        value: 2048,
+      },
+      {
+        name: "top_p",
+        type: "number",
+        description: "Controls diversity via nucleus sampling (0.0 to 1.0)",
+        hidden: true,
+        value: 1.0,
+      },
+      {
+        name: "seed",
+        type: "number",
+        description: "Random seed for deterministic generation",
+        hidden: true,
+      },
+      {
+        name: "frequency_penalty",
+        type: "number",
+        description: "Penalty for frequency of tokens (0.0 to 2.0)",
+        hidden: true,
+        value: 0.0,
+      },
+      {
+        name: "presence_penalty",
+        type: "number",
+        description: "Penalty for presence of tokens (0.0 to 2.0)",
+        hidden: true,
+        value: 0.0,
+      },
+    ],
+    outputs: [
+      {
+        name: "response",
+        type: "string",
+        description: "Generated text response",
+      },
+      {
+        name: "reasoning",
+        type: "string",
+        description: "Model's reasoning process",
+        hidden: true,
+      },
+      {
+        name: "tool_calls",
+        type: "json",
+        description: "Function calls made by the model",
+        hidden: true,
+      },
+    ],
+  };
+
+  async execute(context: NodeContext): Promise<NodeExecution> {
+    const {
+      temperature,
+      max_tokens,
+      top_p,
+      seed,
+      frequency_penalty,
+      presence_penalty,
+    } = context.inputs;
+
+    return executeWorkersAiTextModel(this, context, {
+      modelId: "@cf/moonshotai/kimi-k2.5",
+      pricing: PRICING,
+      params: {
+        temperature,
+        max_completion_tokens: max_tokens,
+        top_p,
+        seed,
+        frequency_penalty,
+        presence_penalty,
+        stream: false,
+      },
+    });
+  }
+}
