@sundaeswap/sprinkles 0.6.1 → 0.7.0

package/dist/cjs/Sprinkle/__tests__/mcp-adapter.test.js

@@ -0,0 +1,713 @@
+"use strict";
+
+var _bunTest = require("bun:test");
+var _typebox = require("@sinclair/typebox");
+var _index = require("../actions/index.js");
+// ---------------------------------------------------------------------------
+// typeboxToJsonSchema
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("typeboxToJsonSchema", () => {
+  // --- Primitive types ---
+
+  (0, _bunTest.test)("String schema -> { type: 'string' }", () => {
+    (0, _bunTest.expect)((0, _index.typeboxToJsonSchema)(_typebox.Type.String())).toEqual({
+      type: "string"
+    });
+  });
+  (0, _bunTest.test)("Number schema -> { type: 'number' }", () => {
+    (0, _bunTest.expect)((0, _index.typeboxToJsonSchema)(_typebox.Type.Number())).toEqual({
+      type: "number"
+    });
+  });
+  (0, _bunTest.test)("Integer schema -> { type: 'integer' }", () => {
+    (0, _bunTest.expect)((0, _index.typeboxToJsonSchema)(_typebox.Type.Integer())).toEqual({
+      type: "integer"
+    });
+  });
+  (0, _bunTest.test)("Boolean schema -> { type: 'boolean' }", () => {
+    (0, _bunTest.expect)((0, _index.typeboxToJsonSchema)(_typebox.Type.Boolean())).toEqual({
+      type: "boolean"
+    });
+  });
+  (0, _bunTest.test)("Null schema -> { type: 'null' }", () => {
+    (0, _bunTest.expect)((0, _index.typeboxToJsonSchema)(_typebox.Type.Null())).toEqual({
+      type: "null"
+    });
+  });
+
+  // --- BigInt ---
+
+  (0, _bunTest.test)("BigInt schema -> { type: 'string', pattern: '^-?[0-9]+$' } with description", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.BigInt());
+    (0, _bunTest.expect)(result).toEqual({
+      type: "string",
+      pattern: "^-?[0-9]+$",
+      description: "BigInt value as string"
+    });
+  });
+
+  // --- Sensitive string ---
+
+  (0, _bunTest.test)("Sensitive string schema includes writeOnly: true", () => {
+    const schema = _typebox.Type.String({
+      sensitive: true
+    });
+    const result = (0, _index.typeboxToJsonSchema)(schema);
+    (0, _bunTest.expect)(result.type).toBe("string");
+    (0, _bunTest.expect)(result.writeOnly).toBe(true);
+  });
+  (0, _bunTest.test)("Non-sensitive string does not include writeOnly", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.String());
+    (0, _bunTest.expect)("writeOnly" in result).toBe(false);
+  });
+
+  // --- Array ---
+
+  (0, _bunTest.test)("Array of strings -> { type: 'array', items: { type: 'string' } }", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.Array(_typebox.Type.String()));
+    (0, _bunTest.expect)(result).toEqual({
+      type: "array",
+      items: {
+        type: "string"
+      }
+    });
+  });
+  (0, _bunTest.test)("Array of integers -> { type: 'array', items: { type: 'integer' } }", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.Array(_typebox.Type.Integer()));
+    (0, _bunTest.expect)(result).toEqual({
+      type: "array",
+      items: {
+        type: "integer"
+      }
+    });
+  });
+  (0, _bunTest.test)("Array of BigInt -> items maps BigInt to string pattern", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.Array(_typebox.Type.BigInt()));
+    (0, _bunTest.expect)(result).toEqual({
+      type: "array",
+      items: {
+        type: "string",
+        pattern: "^-?[0-9]+$",
+        description: "BigInt value as string"
+      }
+    });
+  });
+
+  // --- Object ---
+
+  (0, _bunTest.test)("Nested object -> recursive properties with required array", () => {
+    const schema = _typebox.Type.Object({
+      name: _typebox.Type.String(),
+      count: _typebox.Type.Integer()
+    });
+    const result = (0, _index.typeboxToJsonSchema)(schema);
+    (0, _bunTest.expect)(result.type).toBe("object");
+    (0, _bunTest.expect)(result.properties).toEqual({
+      name: {
+        type: "string"
+      },
+      count: {
+        type: "integer"
+      }
+    });
+    (0, _bunTest.expect)(result.required).toEqual(_bunTest.expect.arrayContaining(["name", "count"]));
+  });
+  (0, _bunTest.test)("Nested object with nested object property converts recursively", () => {
+    const schema = _typebox.Type.Object({
+      outer: _typebox.Type.String(),
+      inner: _typebox.Type.Object({
+        x: _typebox.Type.Number()
+      })
+    });
+    const result = (0, _index.typeboxToJsonSchema)(schema);
+    const props = result.properties;
+    (0, _bunTest.expect)(props.inner).toEqual({
+      type: "object",
+      properties: {
+        x: {
+          type: "number"
+        }
+      },
+      required: ["x"]
+    });
+  });
+
+  // --- Optional fields ---
+
+  (0, _bunTest.test)("Optional field is not listed in required array", () => {
+    const schema = _typebox.Type.Object({
+      required: _typebox.Type.String(),
+      optional: _typebox.Type.Optional(_typebox.Type.String())
+    });
+    const result = (0, _index.typeboxToJsonSchema)(schema);
+    const required = result.required;
+    (0, _bunTest.expect)(required).toContain("required");
+    (0, _bunTest.expect)(required).not.toContain("optional");
+  });
+  (0, _bunTest.test)("Object with all optional fields has no required array (or empty)", () => {
+    const schema = _typebox.Type.Object({
+      a: _typebox.Type.Optional(_typebox.Type.String()),
+      b: _typebox.Type.Optional(_typebox.Type.Number())
+    });
+    const result = (0, _index.typeboxToJsonSchema)(schema);
+    // Either no 'required' key or empty array
+    const required = result.required;
+    (0, _bunTest.expect)(!required || required.length === 0).toBe(true);
+  });
+
+  // --- Union types ---
+
+  (0, _bunTest.test)("Union of string and number -> { anyOf: [...] }", () => {
+    const schema = _typebox.Type.Union([_typebox.Type.String(), _typebox.Type.Number()]);
+    const result = (0, _index.typeboxToJsonSchema)(schema);
+    (0, _bunTest.expect)(result.anyOf).toEqual([{
+      type: "string"
+    }, {
+      type: "number"
+    }]);
+  });
+  (0, _bunTest.test)("Union containing BigInt -> BigInt member maps to string pattern", () => {
+    const schema = _typebox.Type.Union([_typebox.Type.String(), _typebox.Type.BigInt()]);
+    const result = (0, _index.typeboxToJsonSchema)(schema);
+    const anyOf = result.anyOf;
+    const bigIntMember = anyOf.find(m => m.pattern === "^-?[0-9]+$");
+    (0, _bunTest.expect)(bigIntMember).toBeDefined();
+  });
+
+  // --- Literal types ---
+
+  (0, _bunTest.test)("String literal -> { type: 'string', const: value }", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.Literal("hello"));
+    (0, _bunTest.expect)(result).toEqual({
+      type: "string",
+      const: "hello"
+    });
+  });
+  (0, _bunTest.test)("Number literal -> { type: 'number', const: value }", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.Literal(42));
+    (0, _bunTest.expect)(result).toEqual({
+      type: "number",
+      const: 42
+    });
+  });
+  (0, _bunTest.test)("Boolean literal -> { type: 'boolean', const: value }", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.Literal(true));
+    (0, _bunTest.expect)(result).toEqual({
+      type: "boolean",
+      const: true
+    });
+  });
+
+  // --- Annotations: description, title, examples, default ---
+
+  (0, _bunTest.test)("String schema preserves description annotation", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.String({
+      description: "A name"
+    }));
+    (0, _bunTest.expect)(result.description).toBe("A name");
+  });
+  (0, _bunTest.test)("String schema preserves title annotation", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.String({
+      title: "My Title"
+    }));
+    (0, _bunTest.expect)(result.title).toBe("My Title");
+  });
+  (0, _bunTest.test)("String schema preserves examples annotation", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.String({
+      examples: ["foo", "bar"]
+    }));
+    (0, _bunTest.expect)(result.examples).toEqual(["foo", "bar"]);
+  });
+  (0, _bunTest.test)("String schema preserves default annotation", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.String({
+      default: "fallback"
+    }));
+    (0, _bunTest.expect)(result.default).toBe("fallback");
+  });
+  (0, _bunTest.test)("Number schema preserves description annotation", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.Number({
+      description: "A count"
+    }));
+    (0, _bunTest.expect)(result.description).toBe("A count");
+  });
+  (0, _bunTest.test)("Number schema preserves minimum and maximum", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.Number({
+      minimum: 0,
+      maximum: 100
+    }));
+    (0, _bunTest.expect)(result.minimum).toBe(0);
+    (0, _bunTest.expect)(result.maximum).toBe(100);
+  });
+  (0, _bunTest.test)("Integer schema preserves minimum and maximum", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.Integer({
+      minimum: 1,
+      maximum: 10
+    }));
+    (0, _bunTest.expect)(result.minimum).toBe(1);
+    (0, _bunTest.expect)(result.maximum).toBe(10);
+  });
+  (0, _bunTest.test)("Boolean schema preserves default annotation", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.Boolean({
+      default: false
+    }));
+    (0, _bunTest.expect)(result.default).toBe(false);
+  });
+
+  // --- TypeBox internals stripped ---
+
+  (0, _bunTest.test)("Output does not contain [Kind] symbol key", () => {
+    const result = (0, _index.typeboxToJsonSchema)(_typebox.Type.String());
+    const keys = Object.keys(result);
+    (0, _bunTest.expect)(keys.every(k => !k.startsWith("["))).toBe(true);
+  });
+  (0, _bunTest.test)("Output does not contain $id key", () => {
+    const schema = _typebox.Type.String();
+    // Force-add a $id to confirm it is not emitted
+    schema.$id = "some-id";
+    const result = (0, _index.typeboxToJsonSchema)(schema);
+    (0, _bunTest.expect)("$id" in result).toBe(false);
+  });
+
+  // --- Unknown / empty schema fallback ---
+
+  (0, _bunTest.test)("Unknown TypeBox kind emits empty schema {} with console.warn", () => {
+    const warnSpy = (0, _bunTest.spyOn)(console, "warn").mockImplementation(() => {});
+    const unknownSchema = {
+      [Symbol.for("TypeBox.Kind")]: "UnknownKind"
+    };
+    const result = (0, _index.typeboxToJsonSchema)(unknownSchema);
+    (0, _bunTest.expect)(result).toEqual({});
+    (0, _bunTest.expect)(warnSpy).toHaveBeenCalled();
+    warnSpy.mockRestore();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// coerceMcpInput
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("coerceMcpInput", () => {
+  // --- BigInt coercion ---
+
+  (0, _bunTest.test)("coerces BigInt string to BigInt when schema expects BigInt", () => {
+    const result = (0, _index.coerceMcpInput)("12345", _typebox.Type.BigInt());
+    (0, _bunTest.expect)(result).toBe(BigInt("12345"));
+  });
+  (0, _bunTest.test)("coerces negative BigInt string to BigInt", () => {
+    const result = (0, _index.coerceMcpInput)("-9876543210", _typebox.Type.BigInt());
+    (0, _bunTest.expect)(result).toBe(BigInt("-9876543210"));
+  });
+  (0, _bunTest.test)("coerces numeric input to BigInt via Math.trunc", () => {
+    const result = (0, _index.coerceMcpInput)(99.9, _typebox.Type.BigInt());
+    (0, _bunTest.expect)(result).toBe(BigInt(99));
+  });
+  (0, _bunTest.test)("passes through already-BigInt value unchanged", () => {
+    const result = (0, _index.coerceMcpInput)(BigInt(42), _typebox.Type.BigInt());
+    (0, _bunTest.expect)(result).toBe(BigInt(42));
+  });
+  (0, _bunTest.test)("non-numeric string left as-is for BigInt schema", () => {
+    const result = (0, _index.coerceMcpInput)("not-a-number", _typebox.Type.BigInt());
+    (0, _bunTest.expect)(result).toBe("not-a-number");
+  });
+
+  // --- Non-BigInt types passed through ---
+
+  (0, _bunTest.test)("string value passes through unchanged for String schema", () => {
+    const result = (0, _index.coerceMcpInput)("hello", _typebox.Type.String());
+    (0, _bunTest.expect)(result).toBe("hello");
+  });
+  (0, _bunTest.test)("number passes through unchanged for Number schema", () => {
+    const result = (0, _index.coerceMcpInput)(3.14, _typebox.Type.Number());
+    (0, _bunTest.expect)(result).toBe(3.14);
+  });
+  (0, _bunTest.test)("boolean passes through unchanged for Boolean schema", () => {
+    const result = (0, _index.coerceMcpInput)(true, _typebox.Type.Boolean());
+    (0, _bunTest.expect)(result).toBe(true);
+  });
+  (0, _bunTest.test)("null passes through unchanged", () => {
+    (0, _bunTest.expect)((0, _index.coerceMcpInput)(null, _typebox.Type.String())).toBeNull();
+  });
+  (0, _bunTest.test)("undefined passes through unchanged", () => {
+    (0, _bunTest.expect)((0, _index.coerceMcpInput)(undefined, _typebox.Type.String())).toBeUndefined();
+  });
+
+  // --- Nested objects ---
+
+  (0, _bunTest.test)("coerces BigInt fields within nested object", () => {
+    const schema = _typebox.Type.Object({
+      amount: _typebox.Type.BigInt(),
+      label: _typebox.Type.String()
+    });
+    const result = (0, _index.coerceMcpInput)({
+      amount: "99999999999999999",
+      label: "test"
+    }, schema);
+    (0, _bunTest.expect)(result.amount).toBe(BigInt("99999999999999999"));
+    (0, _bunTest.expect)(result.label).toBe("test");
+  });
+  (0, _bunTest.test)("non-BigInt fields in nested object pass through unchanged", () => {
+    const schema = _typebox.Type.Object({
+      name: _typebox.Type.String(),
+      count: _typebox.Type.Integer()
+    });
+    const input = {
+      name: "alice",
+      count: 5
+    };
+    const result = (0, _index.coerceMcpInput)(input, schema);
+    (0, _bunTest.expect)(result.name).toBe("alice");
+    (0, _bunTest.expect)(result.count).toBe(5);
+  });
+  (0, _bunTest.test)("coerces BigInt in nested object without touching other fields", () => {
+    const schema = _typebox.Type.Object({
+      stake: _typebox.Type.BigInt(),
+      fee: _typebox.Type.BigInt(),
+      memo: _typebox.Type.String()
+    });
+    const result = (0, _index.coerceMcpInput)({
+      stake: "1000",
+      fee: "50",
+      memo: "swap"
+    }, schema);
+    (0, _bunTest.expect)(result.stake).toBe(BigInt(1000));
+    (0, _bunTest.expect)(result.fee).toBe(BigInt(50));
+    (0, _bunTest.expect)(result.memo).toBe("swap");
+  });
+
+  // --- Arrays ---
+
+  (0, _bunTest.test)("coerces each BigInt string in array of BigInt", () => {
+    const schema = _typebox.Type.Array(_typebox.Type.BigInt());
+    const result = (0, _index.coerceMcpInput)(["100", "200", "300"], schema);
+    (0, _bunTest.expect)(result[0]).toBe(BigInt(100));
+    (0, _bunTest.expect)(result[1]).toBe(BigInt(200));
+    (0, _bunTest.expect)(result[2]).toBe(BigInt(300));
+  });
+  (0, _bunTest.test)("array of strings with String item schema passes through unchanged", () => {
+    const schema = _typebox.Type.Array(_typebox.Type.String());
+    const input = ["a", "b", "c"];
+    const result = (0, _index.coerceMcpInput)(input, schema);
+    (0, _bunTest.expect)(result).toEqual(["a", "b", "c"]);
+  });
+
+  // --- Union types ---
+
+  (0, _bunTest.test)("coerces BigInt string in Union containing BigInt", () => {
+    const schema = _typebox.Type.Union([_typebox.Type.String(), _typebox.Type.BigInt()]);
+    // A numeric string should be coerced to BigInt because there is a BigInt member
+    const result = (0, _index.coerceMcpInput)("12345", schema);
+    (0, _bunTest.expect)(result).toBe(BigInt(12345));
+  });
+  (0, _bunTest.test)("non-numeric string in Union passes through unchanged", () => {
+    const schema = _typebox.Type.Union([_typebox.Type.String(), _typebox.Type.BigInt()]);
+    const result = (0, _index.coerceMcpInput)("not-a-number", schema);
+    (0, _bunTest.expect)(result).toBe("not-a-number");
+  });
+  (0, _bunTest.test)("value in Union without BigInt member passes through unchanged", () => {
+    const schema = _typebox.Type.Union([_typebox.Type.String(), _typebox.Type.Number()]);
+    const result = (0, _index.coerceMcpInput)("hello", schema);
+    (0, _bunTest.expect)(result).toBe("hello");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getMcpSdk -- lazy import and error handling
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("getMcpSdk", () => {
+  (0, _bunTest.test)("returns an object with McpServer class when SDK is available", async () => {
+    // The SDK is installed as a dev dependency, so this should succeed
+    const sdk = await (0, _index.getMcpSdk)();
+    (0, _bunTest.expect)(sdk).toBeDefined();
+    (0, _bunTest.expect)(typeof sdk.McpServer).toBe("function");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createMcpServer -- integration tests with mocked McpServer
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("createMcpServer", () => {
+  // We mock the MCP SDK so that createMcpServer does not need a real stdio
+  // transport. The mock captures all tool registrations.
+
+  let registeredTools;
+  let mockMcpServer;
+  let MockMcpServerClass;
+  (0, _bunTest.beforeEach)(() => {
+    registeredTools = [];
+    mockMcpServer = {
+      tool: (name, description, schema, handler) => {
+        registeredTools.push({
+          name,
+          description,
+          schema,
+          handler
+        });
+      }
+    };
+    MockMcpServerClass = (0, _bunTest.mock)(() => mockMcpServer);
+    _bunTest.mock.module("@modelcontextprotocol/sdk/server/mcp.js", () => ({
+      McpServer: MockMcpServerClass
+    }));
+  });
+
+  // Helper: build a minimal Sprinkle-like mock
+  function makeMockSprinkle(actions) {
+    const actionMap = new Map(actions.map(a => [a.name, a]));
+    return {
+      listActions: () => actions,
+      getAction: name => actionMap.get(name),
+      settings: {}
+    };
+  }
+
+  // --- Tool registration ---
+
+  (0, _bunTest.test)("registers one MCP tool per action", async () => {
+    const sprinkle = makeMockSprinkle([{
+      name: "greet",
+      description: "Greets someone",
+      inputSchema: _typebox.Type.Object({
+        who: _typebox.Type.String()
+      }),
+      outputSchema: _typebox.Type.Object({
+        greeting: _typebox.Type.String()
+      }),
+      execute: async input => ({
+        greeting: `Hello, ${input.who}!`
+      })
+    }]);
+    await (0, _index.createMcpServer)(sprinkle, "test-server");
+    (0, _bunTest.expect)(registeredTools).toHaveLength(1);
+  });
+  (0, _bunTest.test)("tool name matches action name", async () => {
+    const sprinkle = makeMockSprinkle([{
+      name: "send-tx",
+      description: "Sends a transaction",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({}),
+      execute: async () => ({})
+    }]);
+    await (0, _index.createMcpServer)(sprinkle, "test-server");
+    (0, _bunTest.expect)(registeredTools[0].name).toBe("send-tx");
+  });
+  (0, _bunTest.test)("tool description matches action description", async () => {
+    const sprinkle = makeMockSprinkle([{
+      name: "get-balance",
+      description: "Gets the wallet balance",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({
+        balance: _typebox.Type.Number()
+      }),
+      execute: async () => ({
+        balance: 100
+      })
+    }]);
+    await (0, _index.createMcpServer)(sprinkle, "test-server");
+    (0, _bunTest.expect)(registeredTools[0].description).toBe("Gets the wallet balance");
+  });
+  (0, _bunTest.test)("registers all actions when multiple actions are provided", async () => {
+    const sprinkle = makeMockSprinkle([{
+      name: "action-one",
+      description: "First action",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({}),
+      execute: async () => ({})
+    }, {
+      name: "action-two",
+      description: "Second action",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({}),
+      execute: async () => ({})
+    }, {
+      name: "action-three",
+      description: "Third action",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({}),
+      execute: async () => ({})
+    }]);
+    await (0, _index.createMcpServer)(sprinkle, "test-server");
+    (0, _bunTest.expect)(registeredTools).toHaveLength(3);
+    const names = registeredTools.map(t => t.name);
+    (0, _bunTest.expect)(names).toContain("action-one");
+    (0, _bunTest.expect)(names).toContain("action-two");
+    (0, _bunTest.expect)(names).toContain("action-three");
+  });
+
+  // --- Empty action registry ---
+
+  (0, _bunTest.test)("server is created with no tools when action registry is empty", async () => {
+    const sprinkle = makeMockSprinkle([]);
+    await (0, _index.createMcpServer)(sprinkle, "test-server");
+    (0, _bunTest.expect)(registeredTools).toHaveLength(0);
+  });
+
+  // --- Tool input schema ---
+
+  (0, _bunTest.test)("tool input schema is the JSON Schema conversion of the action inputSchema", async () => {
+    const sprinkle = makeMockSprinkle([{
+      name: "typed-action",
+      description: "Has a typed input",
+      inputSchema: _typebox.Type.Object({
+        name: _typebox.Type.String(),
+        count: _typebox.Type.Integer()
+      }),
+      outputSchema: _typebox.Type.Object({}),
+      execute: async () => ({})
+    }]);
+    await (0, _index.createMcpServer)(sprinkle, "test-server");
+    const schema = registeredTools[0].schema;
+    (0, _bunTest.expect)(schema.type).toBe("object");
+    const props = schema.properties;
+    (0, _bunTest.expect)(props.name).toEqual({
+      type: "string"
+    });
+    (0, _bunTest.expect)(props.count).toEqual({
+      type: "integer"
+    });
+  });
+
+  // --- Tool handler: successful execution ---
+
+  (0, _bunTest.test)("tool handler returns content with JSON text on successful execution", async () => {
+    const sprinkle = makeMockSprinkle([{
+      name: "echo",
+      description: "Echoes input",
+      inputSchema: _typebox.Type.Object({
+        message: _typebox.Type.String()
+      }),
+      outputSchema: _typebox.Type.Object({
+        message: _typebox.Type.String()
+      }),
+      execute: async input => ({
+        message: input.message
+      })
+    }]);
+    await (0, _index.createMcpServer)(sprinkle, "test-server");
+    const handler = registeredTools[0].handler;
+    const response = await handler({
+      message: "hello"
+    });
+    (0, _bunTest.expect)(response.content).toHaveLength(1);
+    (0, _bunTest.expect)(response.content[0].type).toBe("text");
+    const data = JSON.parse(response.content[0].text);
+    (0, _bunTest.expect)(data.message).toBe("hello");
+  });
+  (0, _bunTest.test)("tool handler response does not include isError on success", async () => {
+    const sprinkle = makeMockSprinkle([{
+      name: "ok-action",
+      description: "Succeeds",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({
+        ok: _typebox.Type.Boolean()
+      }),
+      execute: async () => ({
+        ok: true
+      })
+    }]);
+    await (0, _index.createMcpServer)(sprinkle, "test-server");
+    const response = await registeredTools[0].handler({});
+    (0, _bunTest.expect)(response.isError).toBeUndefined();
+  });
+
+  // --- Tool handler: failed execution ---
+
+  (0, _bunTest.test)("tool handler returns isError: true on action failure", async () => {
+    const sprinkle = makeMockSprinkle([{
+      name: "fail-action",
+      description: "Always fails",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({}),
+      execute: async () => {
+        throw new Error("deliberate failure");
+      }
+    }]);
+    await (0, _index.createMcpServer)(sprinkle, "test-server");
+    const response = await registeredTools[0].handler({});
+    (0, _bunTest.expect)(response.isError).toBe(true);
+  });
+  (0, _bunTest.test)("tool handler error response contains error details in content text", async () => {
+    const sprinkle = makeMockSprinkle([{
+      name: "fail-action",
+      description: "Always fails",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({}),
+      execute: async () => {
+        throw new Error("something broke");
+      }
+    }]);
+    await (0, _index.createMcpServer)(sprinkle, "test-server");
+    const response = await registeredTools[0].handler({});
+    (0, _bunTest.expect)(response.content[0].type).toBe("text");
+    const errorData = JSON.parse(response.content[0].text);
+    (0, _bunTest.expect)(errorData.error).toBeDefined();
+    (0, _bunTest.expect)(errorData.error.message).toContain("something broke");
+  });
+  (0, _bunTest.test)("tool handler error response content has type: 'text'", async () => {
+    const sprinkle = makeMockSprinkle([{
+      name: "fail-action",
+      description: "Always fails",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({}),
+      execute: async () => {
+        throw new Error("oops");
+      }
+    }]);
+    await (0, _index.createMcpServer)(sprinkle, "test-server");
+    const response = await registeredTools[0].handler({});
+    (0, _bunTest.expect)(response.content[0].type).toBe("text");
+  });
+
+  // --- BigInt coercion in tool input ---
+
+  (0, _bunTest.test)("tool handler coerces BigInt string input before executing action", async () => {
+    let capturedInput;
+    const sprinkle = makeMockSprinkle([{
+      name: "bigint-action",
+      description: "Takes BigInt input",
+      inputSchema: _typebox.Type.Object({
+        amount: _typebox.Type.BigInt()
+      }),
+      outputSchema: _typebox.Type.Object({
+        amount: _typebox.Type.BigInt()
+      }),
+      execute: async input => {
+        capturedInput = input;
+        return {
+          amount: input.amount
+        };
+      }
+    }]);
+    await (0, _index.createMcpServer)(sprinkle, "test-server");
+    await registeredTools[0].handler({
+      amount: "999999999999999999"
+    });
+    (0, _bunTest.expect)(capturedInput.amount).toBe(BigInt("999999999999999999"));
+  });
+
+  // --- BigInt serialization in tool response ---
+
+  (0, _bunTest.test)("tool handler serializes BigInt values in response text", async () => {
+    const sprinkle = makeMockSprinkle([{
+      name: "bigint-return",
+      description: "Returns BigInt",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({
+        value: _typebox.Type.BigInt()
+      }),
+      execute: async () => ({
+        value: BigInt("9007199254740993")
+      })
+    }]);
+    await (0, _index.createMcpServer)(sprinkle, "test-server");
+    const response = await registeredTools[0].handler({});
+
+    // BigInt values cannot be JSON.stringify'd without a replacer.
+    // bigIntReplacer converts them to "Xn" strings.
+    const text = response.content[0].text;
+    (0, _bunTest.expect)(text).toContain("9007199254740993");
+  });
+});
+//# sourceMappingURL=mcp-adapter.test.js.map