@agent-wall/core 0.1.0

package/src/types.test.ts

@@ -0,0 +1,152 @@
+/**
+ * Tests for types module — JSON-RPC message helpers.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  isRequest,
+  isResponse,
+  isNotification,
+  isToolCall,
+  isToolList,
+  getToolCallParams,
+  createDenyResponse,
+  createPromptResponse,
+  type JsonRpcMessage,
+  type JsonRpcRequest,
+} from "./types.js";
+
+describe("message type guards", () => {
+  const request: JsonRpcMessage = {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: { name: "read_file", arguments: { path: "/test" } },
+  };
+
+  const response: JsonRpcMessage = {
+    jsonrpc: "2.0",
+    id: 1,
+    result: { content: [{ type: "text", text: "hello" }] },
+  };
+
+  const notification: JsonRpcMessage = {
+    jsonrpc: "2.0",
+    method: "notifications/initialized",
+  };
+
+  it("isRequest should identify requests", () => {
+    expect(isRequest(request)).toBe(true);
+    expect(isRequest(response)).toBe(false);
+    expect(isRequest(notification)).toBe(false);
+  });
+
+  it("isResponse should identify responses", () => {
+    expect(isResponse(response)).toBe(true);
+    expect(isResponse(request)).toBe(false);
+    expect(isResponse(notification)).toBe(false);
+  });
+
+  it("isNotification should identify notifications", () => {
+    expect(isNotification(notification)).toBe(true);
+    expect(isNotification(request)).toBe(false);
+    expect(isNotification(response)).toBe(false);
+  });
+
+  it("isToolCall should identify tools/call requests", () => {
+    expect(isToolCall(request)).toBe(true);
+    expect(
+      isToolCall({ jsonrpc: "2.0", id: 1, method: "tools/list" })
+    ).toBe(false);
+    expect(isToolCall(response)).toBe(false);
+  });
+
+  it("isToolList should identify tools/list requests", () => {
+    expect(
+      isToolList({ jsonrpc: "2.0", id: 1, method: "tools/list" })
+    ).toBe(true);
+    expect(isToolList(request)).toBe(false);
+  });
+});
+
+describe("getToolCallParams", () => {
+  it("should extract tool name and arguments", () => {
+    const req: JsonRpcRequest = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: { name: "read_file", arguments: { path: "/test" } },
+    };
+
+    const result = getToolCallParams(req);
+    expect(result).toEqual({
+      name: "read_file",
+      arguments: { path: "/test" },
+    });
+  });
+
+  it("should return null for non-tools/call methods", () => {
+    const req: JsonRpcRequest = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/list",
+    };
+
+    expect(getToolCallParams(req)).toBeNull();
+  });
+
+  it("should return null when params missing", () => {
+    const req: JsonRpcRequest = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+    };
+
+    expect(getToolCallParams(req)).toBeNull();
+  });
+
+  it("should default arguments to empty object", () => {
+    const req: JsonRpcRequest = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: { name: "some_tool" },
+    };
+
+    const result = getToolCallParams(req);
+    expect(result).toEqual({ name: "some_tool", arguments: {} });
+  });
+});
+
+describe("createDenyResponse", () => {
+  it("should create a JSON-RPC error with custom code and message", () => {
+    const resp = createDenyResponse(42, "Access denied");
+    expect(resp).toEqual({
+      jsonrpc: "2.0",
+      id: 42,
+      error: {
+        code: -32001,
+        message: "Agent Wall: Access denied",
+      },
+    });
+  });
+
+  it("should work with string IDs", () => {
+    const resp = createDenyResponse("req-abc", "Blocked");
+    expect(resp.id).toBe("req-abc");
+  });
+});
+
+describe("createPromptResponse", () => {
+  it("should create a prompt-awaiting error response", () => {
+    const resp = createPromptResponse(7, "Requires approval");
+    expect(resp).toEqual({
+      jsonrpc: "2.0",
+      id: 7,
+      error: {
+        code: -32002,
+        message: "Agent Wall: Awaiting approval — Requires approval",
+      },
+    });
+  });
+});

package/src/types.ts

@@ -0,0 +1,146 @@
+/**
+ * Agent Wall JSON-RPC Types
+ *
+ * Mirrors the MCP protocol's JSON-RPC 2.0 message format.
+ * We define our own types instead of depending on the MCP SDK
+ * so Agent Wall has zero coupling to any specific MCP version.
+ */
+
+import { z } from "zod";
+
+// ── JSON-RPC 2.0 Base ──────────────────────────────────────────────
+
+export const JsonRpcRequestSchema = z.object({
+  jsonrpc: z.literal("2.0"),
+  id: z.union([z.string(), z.number()]),
+  method: z.string(),
+  params: z.record(z.unknown()).optional(),
+});
+
+export const JsonRpcNotificationSchema = z.object({
+  jsonrpc: z.literal("2.0"),
+  method: z.string(),
+  params: z.record(z.unknown()).optional(),
+});
+
+export const JsonRpcResponseSchema = z.object({
+  jsonrpc: z.literal("2.0"),
+  id: z.union([z.string(), z.number()]),
+  result: z.unknown().optional(),
+  error: z
+    .object({
+      code: z.number(),
+      message: z.string(),
+      data: z.unknown().optional(),
+    })
+    .optional(),
+});
+
+export const JsonRpcMessageSchema = z.union([
+  JsonRpcRequestSchema,
+  JsonRpcNotificationSchema,
+  JsonRpcResponseSchema,
+]);
+
+export type JsonRpcRequest = z.infer<typeof JsonRpcRequestSchema>;
+export type JsonRpcNotification = z.infer<typeof JsonRpcNotificationSchema>;
+export type JsonRpcResponse = z.infer<typeof JsonRpcResponseSchema>;
+export type JsonRpcMessage = z.infer<typeof JsonRpcMessageSchema>;
+
+// ── MCP-specific message types ──────────────────────────────────────
+
+/** MCP tools/call request params */
+export interface ToolCallParams {
+  name: string;
+  arguments?: Record<string, unknown>;
+}
+
+/** MCP tools/list result */
+export interface ToolListResult {
+  tools: Array<{
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    annotations?: Record<string, unknown>;
+  }>;
+  nextCursor?: string;
+}
+
+/** MCP response content block (text, image, resource) */
+export interface McpContentBlock {
+  type: string;
+  text?: string;
+  data?: string;
+  mimeType?: string;
+  [key: string]: unknown;
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+export function isRequest(msg: JsonRpcMessage): msg is JsonRpcRequest {
+  return "id" in msg && "method" in msg;
+}
+
+export function isNotification(
+  msg: JsonRpcMessage
+): msg is JsonRpcNotification {
+  return !("id" in msg) && "method" in msg;
+}
+
+export function isResponse(msg: JsonRpcMessage): msg is JsonRpcResponse {
+  return "id" in msg && !("method" in msg);
+}
+
+export function isToolCall(msg: JsonRpcMessage): boolean {
+  return isRequest(msg) && msg.method === "tools/call";
+}
+
+export function isToolList(msg: JsonRpcMessage): boolean {
+  return isRequest(msg) && msg.method === "tools/list";
+}
+
+export function getToolCallParams(
+  msg: JsonRpcRequest
+): ToolCallParams | null {
+  if (msg.method !== "tools/call" || !msg.params) return null;
+  const params = msg.params as Record<string, unknown>;
+  if (typeof params.name !== "string") return null;
+  return {
+    name: params.name,
+    arguments: (params.arguments as Record<string, unknown>) ?? {},
+  };
+}
+
+/**
+ * Create a JSON-RPC error response for a denied tool call.
+ */
+export function createDenyResponse(
+  id: string | number,
+  message: string
+): JsonRpcResponse {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: -32001, // Custom: policy denied
+      message: `Agent Wall: ${message}`,
+    },
+  };
+}
+
+/**
+ * Create a JSON-RPC error response for a tool call requiring approval.
+ */
+export function createPromptResponse(
+  id: string | number,
+  message: string
+): JsonRpcResponse {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: -32002, // Custom: awaiting approval
+      message: `Agent Wall: Awaiting approval — ${message}`,
+    },
+  };
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm"],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+});

package/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    // Live integration tests spawn real MCP servers and share filesystem
+    // state (kill switch file at cwd). Must run sequentially to prevent
+    // cross-contamination between test files.
+    fileParallelism: false,
+  },
+});