@tpsdev-ai/agent 0.5.2 → 0.5.4

package/test/provider.test.ts

@@ -0,0 +1,428 @@
+import { describe, expect, test } from "bun:test";
+import { ProviderManager } from "../src/llm/provider.js";
+
+// We test the response mappers by calling complete() with mocked fetch.
+// Each provider has a distinct response format — these tests ensure
+// tool calls are normalized correctly into { id, name, input }.
+
+function makeProvider(provider: "anthropic" | "openai" | "ollama" | "google") {
+  return new ProviderManager({
+    provider,
+    model: "test-model",
+    apiKey: "test-key",
+  });
+}
+
+// --- Anthropic ---
+
+describe("Anthropic response mapping", () => {
+  test("parses tool_use blocks", async () => {
+    const pm = makeProvider("anthropic");
+    const raw = {
+      content: [
+        { type: "text", text: "I'll write that file." },
+        {
+          type: "tool_use",
+          id: "toolu_123",
+          name: "write",
+          input: { path: "hello.txt", content: "Hello!" },
+        },
+      ],
+      usage: { input_tokens: 100, output_tokens: 50 },
+    };
+
+    globalThis.fetch = async () =>
+      new Response(JSON.stringify(raw), { status: 200 });
+
+    const res = await pm.complete({
+      messages: [{ role: "user", content: "test" }],
+      tools: [{ name: "write", description: "Write a file", input_schema: { type: "object", properties: {} } }],
+    });
+
+    expect(res.content).toBe("I'll write that file.");
+    expect(res.toolCalls).toHaveLength(1);
+    expect(res.toolCalls![0].id).toBe("toolu_123");
+    expect(res.toolCalls![0].name).toBe("write");
+    expect(res.toolCalls![0].input).toEqual({ path: "hello.txt", content: "Hello!" });
+    expect(res.inputTokens).toBe(100);
+    expect(res.outputTokens).toBe(50);
+  });
+
+  test("handles text-only response (no tools)", async () => {
+    const pm = makeProvider("anthropic");
+    const raw = {
+      content: [{ type: "text", text: "Done." }],
+      usage: { input_tokens: 10, output_tokens: 5 },
+    };
+
+    globalThis.fetch = async () =>
+      new Response(JSON.stringify(raw), { status: 200 });
+
+    const res = await pm.complete({
+      messages: [{ role: "user", content: "test" }],
+      tools: [],
+    });
+
+    expect(res.content).toBe("Done.");
+    expect(res.toolCalls).toBeUndefined();
+  });
+
+  test("handles multiple tool calls", async () => {
+    const pm = makeProvider("anthropic");
+    const raw = {
+      content: [
+        { type: "tool_use", id: "t1", name: "read", input: { path: "a.txt" } },
+        { type: "tool_use", id: "t2", name: "write", input: { path: "b.txt", content: "hi" } },
+      ],
+      usage: { input_tokens: 0, output_tokens: 0 },
+    };
+
+    globalThis.fetch = async () =>
+      new Response(JSON.stringify(raw), { status: 200 });
+
+    const res = await pm.complete({
+      messages: [{ role: "user", content: "test" }],
+      tools: [],
+    });
+
+    expect(res.toolCalls).toHaveLength(2);
+    expect(res.toolCalls![0].name).toBe("read");
+    expect(res.toolCalls![1].name).toBe("write");
+  });
+});
+
+// --- OpenAI ---
+
+describe("OpenAI response mapping", () => {
+  test("parses function tool calls", async () => {
+    const pm = makeProvider("openai");
+    const raw = {
+      choices: [
+        {
+          message: {
+            content: "",
+            tool_calls: [
+              {
+                id: "call_abc",
+                function: {
+                  name: "exec",
+                  arguments: '{"command":"ls -la"}',
+                },
+              },
+            ],
+          },
+        },
+      ],
+      usage: { prompt_tokens: 200, completion_tokens: 30 },
+    };
+
+    globalThis.fetch = async () =>
+      new Response(JSON.stringify(raw), { status: 200 });
+
+    const res = await pm.complete({
+      messages: [{ role: "user", content: "test" }],
+      tools: [{ name: "exec", description: "Run command", input_schema: { type: "object", properties: {} } }],
+    });
+
+    expect(res.toolCalls).toHaveLength(1);
+    expect(res.toolCalls![0].id).toBe("call_abc");
+    expect(res.toolCalls![0].name).toBe("exec");
+    expect(res.toolCalls![0].input).toEqual({ command: "ls -la" });
+    expect(res.inputTokens).toBe(200);
+    expect(res.outputTokens).toBe(30);
+  });
+
+  test("handles text-only response", async () => {
+    const pm = makeProvider("openai");
+    const raw = {
+      choices: [{ message: { content: "All done.", tool_calls: undefined } }],
+      usage: { prompt_tokens: 10, completion_tokens: 5 },
+    };
+
+    globalThis.fetch = async () =>
+      new Response(JSON.stringify(raw), { status: 200 });
+
+    const res = await pm.complete({
+      messages: [{ role: "user", content: "test" }],
+      tools: [],
+    });
+
+    expect(res.content).toBe("All done.");
+    expect(res.toolCalls).toBeUndefined();
+  });
+});
+
+// --- Ollama ---
+
+describe("Ollama response mapping", () => {
+  test("parses function tool calls (object arguments)", async () => {
+    const pm = makeProvider("ollama");
+    const raw = {
+      message: {
+        role: "assistant",
+        content: "",
+        tool_calls: [
+          {
+            id: "call_xyz",
+            function: {
+              name: "write",
+              arguments: { path: "test.txt", content: "hello" },
+            },
+          },
+        ],
+      },
+      prompt_eval_count: 143,
+      eval_count: 100,
+    };
+
+    globalThis.fetch = async () =>
+      new Response(JSON.stringify(raw), { status: 200 });
+
+    const res = await pm.complete({
+      messages: [{ role: "user", content: "test" }],
+      tools: [{ name: "write", description: "Write a file", input_schema: { type: "object", properties: {} } }],
+    });
+
+    expect(res.toolCalls).toHaveLength(1);
+    expect(res.toolCalls![0].name).toBe("write");
+    expect(res.toolCalls![0].input).toEqual({ path: "test.txt", content: "hello" });
+    expect(res.inputTokens).toBe(143);
+    expect(res.outputTokens).toBe(100);
+  });
+
+  test("parses function tool calls (string arguments)", async () => {
+    const pm = makeProvider("ollama");
+    const raw = {
+      message: {
+        role: "assistant",
+        content: "",
+        tool_calls: [
+          {
+            id: "call_str",
+            function: {
+              name: "read",
+              arguments: '{"path":"config.yaml"}',
+            },
+          },
+        ],
+      },
+      prompt_eval_count: 50,
+      eval_count: 20,
+    };
+
+    globalThis.fetch = async () =>
+      new Response(JSON.stringify(raw), { status: 200 });
+
+    const res = await pm.complete({
+      messages: [{ role: "user", content: "test" }],
+      tools: [{ name: "read", description: "Read a file", input_schema: { type: "object", properties: {} } }],
+    });
+
+    expect(res.toolCalls).toHaveLength(1);
+    expect(res.toolCalls![0].name).toBe("read");
+    expect(res.toolCalls![0].input).toEqual({ path: "config.yaml" });
+  });
+
+  test("handles text-only response", async () => {
+    const pm = makeProvider("ollama");
+    const raw = {
+      message: { role: "assistant", content: "File written." },
+      prompt_eval_count: 10,
+      eval_count: 5,
+    };
+
+    globalThis.fetch = async () =>
+      new Response(JSON.stringify(raw), { status: 200 });
+
+    const res = await pm.complete({
+      messages: [{ role: "user", content: "test" }],
+      tools: [],
+    });
+
+    expect(res.content).toBe("File written.");
+    expect(res.toolCalls).toBeUndefined();
+  });
+});
+
+// --- Google ---
+
+describe("Google response mapping", () => {
+  test("parses functionCall parts", async () => {
+    const pm = makeProvider("google");
+    const raw = {
+      candidates: [
+        {
+          content: {
+            parts: [
+              {
+                functionCall: {
+                  name: "write",
+                  args: { path: "out.txt", content: "data" },
+                },
+              },
+            ],
+          },
+        },
+      ],
+      usageMetadata: { promptTokenCount: 80, candidatesTokenCount: 40 },
+    };
+
+    globalThis.fetch = async () =>
+      new Response(JSON.stringify(raw), { status: 200 });
+
+    const res = await pm.complete({
+      messages: [{ role: "user", content: "test" }],
+      tools: [{ name: "write", description: "Write", input_schema: { type: "object", properties: {} } }],
+    });
+
+    expect(res.toolCalls).toHaveLength(1);
+    expect(res.toolCalls![0].name).toBe("write");
+    expect(res.toolCalls![0].input).toEqual({ path: "out.txt", content: "data" });
+    expect(res.inputTokens).toBe(80);
+    expect(res.outputTokens).toBe(40);
+  });
+
+  test("parses text-only response", async () => {
+    const pm = makeProvider("google");
+    const raw = {
+      candidates: [
+        {
+          content: {
+            parts: [{ text: "Here's your answer." }],
+          },
+        },
+      ],
+      usageMetadata: { promptTokenCount: 10, candidatesTokenCount: 8 },
+    };
+
+    globalThis.fetch = async () =>
+      new Response(JSON.stringify(raw), { status: 200 });
+
+    const res = await pm.complete({
+      messages: [{ role: "user", content: "test" }],
+      tools: [],
+    });
+
+    expect(res.content).toBe("Here's your answer.");
+    expect(res.toolCalls).toBeUndefined();
+  });
+
+  test("handles mixed text + functionCall parts", async () => {
+    const pm = makeProvider("google");
+    const raw = {
+      candidates: [
+        {
+          content: {
+            parts: [
+              { text: "Let me check." },
+              { functionCall: { name: "read", args: { path: "data.json" } } },
+            ],
+          },
+        },
+      ],
+      usageMetadata: { promptTokenCount: 0, candidatesTokenCount: 0 },
+    };
+
+    globalThis.fetch = async () =>
+      new Response(JSON.stringify(raw), { status: 200 });
+
+    const res = await pm.complete({
+      messages: [{ role: "user", content: "test" }],
+      tools: [],
+    });
+
+    expect(res.content).toBe("Let me check.");
+    expect(res.toolCalls).toHaveLength(1);
+    expect(res.toolCalls![0].name).toBe("read");
+  });
+});
+
+// --- Tool schema formatting ---
+
+describe("Tool schema formatting", () => {
+  const spec = {
+    name: "write",
+    description: "Write a file",
+    input_schema: { type: "object", properties: { path: { type: "string" } } },
+  };
+
+  test("Anthropic format", () => {
+    const pm = makeProvider("anthropic");
+    const fn = pm.toolInputSchemaFor("anthropic");
+    const result = fn([spec]) as any[];
+    expect(result[0].name).toBe("write");
+    expect(result[0].input_schema).toBeDefined();
+    expect(result[0].function).toBeUndefined();
+  });
+
+  test("OpenAI format wraps in function object", () => {
+    const pm = makeProvider("openai");
+    const fn = pm.toolInputSchemaFor("openai");
+    const result = fn([spec]) as any[];
+    expect(result[0].type).toBe("function");
+    expect(result[0].function.name).toBe("write");
+    expect(result[0].function.parameters).toBeDefined();
+  });
+
+  test("Ollama uses OpenAI format", () => {
+    const pm = makeProvider("ollama");
+    const fn = pm.toolInputSchemaFor("ollama");
+    const result = fn([spec]) as any[];
+    expect(result[0].type).toBe("function");
+    expect(result[0].function.name).toBe("write");
+  });
+
+  test("Google format uses functionDeclarations", () => {
+    const pm = makeProvider("google");
+    const fn = pm.toolInputSchemaFor("google");
+    const result = fn([spec]) as any;
+    expect(result.functionDeclarations).toHaveLength(1);
+    expect(result.functionDeclarations[0].name).toBe("write");
+  });
+});
+
+// --- Edge cases ---
+
+describe("Edge cases", () => {
+  test("safeJson handles malformed string", async () => {
+    const pm = makeProvider("openai");
+    const raw = {
+      choices: [
+        {
+          message: {
+            tool_calls: [
+              { id: "c1", function: { name: "exec", arguments: "not json{" } },
+            ],
+          },
+        },
+      ],
+      usage: { prompt_tokens: 0, completion_tokens: 0 },
+    };
+
+    globalThis.fetch = async () =>
+      new Response(JSON.stringify(raw), { status: 200 });
+
+    const res = await pm.complete({
+      messages: [{ role: "user", content: "test" }],
+      tools: [],
+    });
+
+    expect(res.toolCalls![0].input).toEqual({});
+  });
+
+  test("handles empty/missing content gracefully", async () => {
+    const pm = makeProvider("anthropic");
+    const raw = { content: [], usage: {} };
+
+    globalThis.fetch = async () =>
+      new Response(JSON.stringify(raw), { status: 200 });
+
+    const res = await pm.complete({
+      messages: [{ role: "user", content: "test" }],
+      tools: [],
+    });
+
+    expect(res.content).toBe("");
+    expect(res.toolCalls).toBeUndefined();
+  });
+});

package/test/security/mail-trust.test.ts

@@ -0,0 +1,266 @@
+/**
+ * Security regression tests for mail trust and capability scoping.
+ * Each test maps to a finding in SECURITY.md.
+ */
+import { describe, test, expect, mock, beforeEach } from "bun:test";
+import { EventLoop } from "../../src/runtime/event-loop.js";
+import type { AgentConfig, LLMMessage, ToolSpec, CompletionResponse } from "../../src/runtime/types.js";
+import type { MemoryStore } from "../../src/io/memory.js";
+import type { ContextManager } from "../../src/io/context.js";
+import type { ProviderManager } from "../../src/llm/provider.js";
+import { ToolRegistry } from "../../src/tools/registry.js";
+
+function makeConfig(overrides: Partial<AgentConfig> = {}): AgentConfig {
+  return {
+    name: "test-agent",
+    agentId: "test",
+    workspace: "/tmp/test-workspace",
+    provider: "anthropic",
+    model: "test",
+    maxToolTurns: 5,
+    ...overrides,
+  } as AgentConfig;
+}
+
+function makeMemory(): MemoryStore {
+  return { append: mock(() => Promise.resolve()) } as any;
+}
+
+function makeContext(): ContextManager {
+  return {} as any;
+}
+
+/**
+ * Build a provider mock that captures what tools were passed to it.
+ */
+function makeProvider(capturedTools: ToolSpec[][]): ProviderManager {
+  return {
+    complete: mock((req: any) => {
+      capturedTools.push([...req.tools]);
+      return Promise.resolve({
+        content: "Done.",
+        toolCalls: undefined,
+        inputTokens: 10,
+        outputTokens: 5,
+      } as CompletionResponse);
+    }),
+  } as any;
+}
+
+function makeToolRegistry(): ToolRegistry {
+  const reg = new ToolRegistry();
+  reg.register({
+    name: "read",
+    description: "Read a file",
+    input_schema: { path: { type: "string" } },
+    execute: async () => ({ content: "file contents" }),
+  });
+  reg.register({
+    name: "write",
+    description: "Write a file",
+    input_schema: { path: { type: "string" }, content: { type: "string" } },
+    execute: async () => ({ content: "ok" }),
+  });
+  reg.register({
+    name: "edit",
+    description: "Edit a file",
+    input_schema: { path: { type: "string" }, old_string: { type: "string" }, new_string: { type: "string" } },
+    execute: async () => ({ content: "ok" }),
+  });
+  reg.register({
+    name: "exec",
+    description: "Execute a command",
+    input_schema: { command: { type: "string" } },
+    execute: async () => ({ content: "output" }),
+  });
+  reg.register({
+    name: "mail",
+    description: "Send mail",
+    input_schema: { to: { type: "string" }, body: { type: "string" } },
+    execute: async () => ({ content: "sent" }),
+  });
+  return reg;
+}
+
+describe("S43-A: internal mail drops exec", () => {
+  test("user trust gets exec", async () => {
+    const captured: ToolSpec[][] = [];
+    const loop = new EventLoop({
+      config: makeConfig(),
+      memory: makeMemory(),
+      context: makeContext(),
+      provider: makeProvider(captured),
+      tools: makeToolRegistry(),
+    });
+
+    await loop.runOnce("hello"); // runOnce uses trust=user
+    expect(captured.length).toBeGreaterThan(0);
+    const toolNames = captured[0].map((t) => t.name);
+    expect(toolNames).toContain("exec");
+  });
+
+  test("internal trust does NOT get exec", async () => {
+    const captured: ToolSpec[][] = [];
+    const loop = new EventLoop({
+      config: makeConfig(),
+      memory: makeMemory(),
+      context: makeContext(),
+      provider: makeProvider(captured),
+      tools: makeToolRegistry(),
+    });
+
+    // Simulate internal mail
+    const mail = {
+      body: "do something",
+      headers: { "X-TPS-Trust": "internal", "X-TPS-Sender": "agent-coder" },
+    };
+
+    // Access private processMail via run() with injected inbox
+    let callCount = 0;
+    await loop.run(async () => {
+      if (callCount++ === 0) return [mail as any];
+      await loop.stop();
+      return [];
+    });
+
+    expect(captured.length).toBeGreaterThan(0);
+    const toolNames = captured[0].map((t) => t.name);
+    expect(toolNames).not.toContain("exec");
+    expect(toolNames).toContain("read");
+    expect(toolNames).toContain("write");
+    expect(toolNames).toContain("mail");
+  });
+
+  test("external trust does NOT get exec", async () => {
+    const captured: ToolSpec[][] = [];
+    const loop = new EventLoop({
+      config: makeConfig(),
+      memory: makeMemory(),
+      context: makeContext(),
+      provider: makeProvider(captured),
+      tools: makeToolRegistry(),
+    });
+
+    const mail = {
+      body: "do something",
+      headers: { "X-TPS-Trust": "external", "X-TPS-Sender": "unknown" },
+    };
+
+    let callCount = 0;
+    await loop.run(async () => {
+      if (callCount++ === 0) return [mail as any];
+      await loop.stop();
+      return [];
+    });
+
+    expect(captured.length).toBeGreaterThan(0);
+    const toolNames = captured[0].map((t) => t.name);
+    expect(toolNames).not.toContain("exec");
+  });
+});
+
+describe("S43-D: scratch path traversal", () => {
+  test("external mail write to scratch/file.txt is allowed", async () => {
+    const memory = makeMemory();
+    const tools = makeToolRegistry();
+    const writeResults: string[] = [];
+
+    // Override write tool to capture calls
+    tools.register({
+      name: "write",
+      description: "Write a file",
+      input_schema: { path: { type: "string" }, content: { type: "string" } },
+      execute: async (input: any) => {
+        writeResults.push(input.path);
+        return { content: "ok" };
+      },
+    });
+
+    const provider = {
+      complete: mock(async (req: any) => {
+        // First call: request a write to scratch/file.txt
+        if ((provider.complete as any).mock.calls.length <= 1) {
+          return {
+            content: "",
+            toolCalls: [{ id: "1", name: "write", input: { path: "scratch/file.txt", content: "hello" } }],
+            inputTokens: 10,
+            outputTokens: 5,
+          };
+        }
+        return { content: "Done.", toolCalls: undefined, inputTokens: 10, outputTokens: 5 };
+      }),
+    } as any;
+
+    const loop = new EventLoop({
+      config: makeConfig(),
+      memory,
+      context: makeContext(),
+      provider,
+      tools,
+    });
+
+    const mail = {
+      body: "write a file",
+      headers: { "X-TPS-Trust": "external", "X-TPS-Sender": "outsider" },
+    };
+
+    let callCount = 0;
+    await loop.run(async () => {
+      if (callCount++ === 0) return [mail as any];
+      await loop.stop();
+      return [];
+    });
+
+    expect(writeResults).toContain("scratch/file.txt");
+  });
+
+  test("external mail write to scratch/../../etc/passwd is BLOCKED", async () => {
+    const memory = makeMemory();
+    const memoryAppendCalls: any[] = [];
+    (memory.append as any).mockImplementation((entry: any) => {
+      memoryAppendCalls.push(entry);
+      return Promise.resolve();
+    });
+
+    const provider = {
+      complete: mock(async (req: any) => {
+        if ((provider.complete as any).mock.calls.length <= 1) {
+          return {
+            content: "",
+            toolCalls: [{ id: "1", name: "write", input: { path: "scratch/../../etc/passwd", content: "pwned" } }],
+            inputTokens: 10,
+            outputTokens: 5,
+          };
+        }
+        return { content: "Done.", toolCalls: undefined, inputTokens: 10, outputTokens: 5 };
+      }),
+    } as any;
+
+    const loop = new EventLoop({
+      config: makeConfig(),
+      memory,
+      context: makeContext(),
+      provider,
+      tools: makeToolRegistry(),
+    });
+
+    const mail = {
+      body: "write a file",
+      headers: { "X-TPS-Trust": "external", "X-TPS-Sender": "attacker" },
+    };
+
+    let callCount = 0;
+    await loop.run(async () => {
+      if (callCount++ === 0) return [mail as any];
+      await loop.stop();
+      return [];
+    });
+
+    // Should have logged a permission denied error
+    const denials = memoryAppendCalls.filter(
+      (e: any) => e.type === "tool_result" && e.data?.result?.isError,
+    );
+    expect(denials.length).toBeGreaterThan(0);
+    expect(denials[0].data.result.content).toContain("Permission denied");
+  });
+});