@contractspec/example.agent-console 1.57.0 → 1.59.0

package/dist/browser/handlers/index.js

@@ -0,0 +1,799 @@
+// src/shared/mock-agents.ts
+var MOCK_AGENTS = [
+  {
+    id: "agent-1",
+    organizationId: "demo-org",
+    name: "Customer Support Bot",
+    slug: "customer-support-bot",
+    description: "Handles tier-1 customer inquiries and routes complex issues.",
+    status: "ACTIVE",
+    modelProvider: "OPENAI",
+    modelName: "gpt-4o-mini",
+    modelConfig: { temperature: 0.7 },
+    systemPrompt: "You are a helpful customer support assistant.",
+    toolChoice: "auto",
+    maxIterations: 10,
+    timeoutMs: 120000,
+    version: "1.0.0",
+    tags: ["support", "tier-1"],
+    createdAt: new Date("2024-01-15T10:00:00Z"),
+    updatedAt: new Date("2024-03-20T14:30:00Z")
+  },
+  {
+    id: "agent-2",
+    organizationId: "demo-org",
+    name: "Code Review Assistant",
+    slug: "code-review-assistant",
+    description: "Reviews pull requests and provides actionable feedback.",
+    status: "ACTIVE",
+    modelProvider: "ANTHROPIC",
+    modelName: "claude-sonnet-4-20250514",
+    modelConfig: { temperature: 0.3 },
+    systemPrompt: "You are a code review expert.",
+    toolChoice: "auto",
+    maxIterations: 15,
+    timeoutMs: 180000,
+    version: "2.1.0",
+    tags: ["code", "review", "dev"],
+    createdAt: new Date("2024-02-10T09:00:00Z"),
+    updatedAt: new Date("2024-04-05T11:15:00Z")
+  },
+  {
+    id: "agent-3",
+    organizationId: "demo-org",
+    name: "Data Analyst",
+    slug: "data-analyst",
+    description: "Queries databases and generates insights from data.",
+    status: "PAUSED",
+    modelProvider: "OPENAI",
+    modelName: "gpt-4o",
+    modelConfig: { temperature: 0.5 },
+    systemPrompt: "You are a data analyst expert in SQL and analytics.",
+    toolChoice: "required",
+    maxIterations: 20,
+    timeoutMs: 300000,
+    version: "1.2.0",
+    tags: ["data", "analytics", "sql"],
+    createdAt: new Date("2024-03-01T08:00:00Z"),
+    updatedAt: new Date("2024-04-10T16:45:00Z")
+  },
+  {
+    id: "agent-4",
+    organizationId: "demo-org",
+    name: "Meeting Scheduler",
+    slug: "meeting-scheduler",
+    description: "Schedules meetings and manages calendar conflicts.",
+    status: "DRAFT",
+    modelProvider: "GOOGLE",
+    modelName: "gemini-2.0-flash",
+    modelConfig: { temperature: 0.2 },
+    systemPrompt: "You help schedule and organize meetings efficiently.",
+    toolChoice: "auto",
+    maxIterations: 5,
+    timeoutMs: 60000,
+    version: "0.1.0",
+    tags: ["calendar", "scheduling"],
+    createdAt: new Date("2024-04-01T12:00:00Z"),
+    updatedAt: new Date("2024-04-01T12:00:00Z")
+  }
+];
+
+// src/shared/mock-tools.ts
+var MOCK_TOOLS = [
+  {
+    id: "tool-1",
+    organizationId: "demo-org",
+    name: "Web Search",
+    slug: "web-search",
+    description: "Search the web for real-time information using Brave API.",
+    category: "RETRIEVAL",
+    status: "ACTIVE",
+    parametersSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query" },
+        numResults: { type: "number", default: 10 }
+      },
+      required: ["query"]
+    },
+    outputSchema: { type: "array", items: { type: "object" } },
+    implementationType: "http",
+    implementationConfig: {
+      url: "https://api.brave.com/search",
+      method: "GET"
+    },
+    maxInvocationsPerMinute: 60,
+    timeoutMs: 30000,
+    version: "1.0.0",
+    tags: ["search", "web"],
+    createdAt: new Date("2024-01-01T00:00:00Z"),
+    updatedAt: new Date("2024-02-15T10:00:00Z")
+  },
+  {
+    id: "tool-2",
+    organizationId: "demo-org",
+    name: "SQL Query",
+    slug: "sql-query",
+    description: "Execute read-only SQL queries against the data warehouse.",
+    category: "RETRIEVAL",
+    status: "ACTIVE",
+    parametersSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "SQL query" },
+        maxRows: { type: "number", default: 100 }
+      },
+      required: ["query"]
+    },
+    outputSchema: { type: "object" },
+    implementationType: "function",
+    implementationConfig: { handler: "executeSqlQuery" },
+    maxInvocationsPerMinute: 30,
+    timeoutMs: 60000,
+    version: "1.1.0",
+    tags: ["sql", "database"],
+    createdAt: new Date("2024-01-05T00:00:00Z"),
+    updatedAt: new Date("2024-03-10T14:00:00Z")
+  },
+  {
+    id: "tool-3",
+    organizationId: "demo-org",
+    name: "Email Sender",
+    slug: "email-sender",
+    description: "Send emails via SMTP or API.",
+    category: "COMMUNICATION",
+    status: "ACTIVE",
+    parametersSchema: {
+      type: "object",
+      properties: {
+        to: { type: "string" },
+        subject: { type: "string" },
+        body: { type: "string" }
+      },
+      required: ["to", "subject", "body"]
+    },
+    implementationType: "http",
+    implementationConfig: { url: "/api/send-email", method: "POST" },
+    maxInvocationsPerMinute: 10,
+    timeoutMs: 30000,
+    version: "1.0.0",
+    tags: ["email", "communication"],
+    createdAt: new Date("2024-02-01T00:00:00Z"),
+    updatedAt: new Date("2024-02-01T00:00:00Z")
+  },
+  {
+    id: "tool-4",
+    organizationId: "demo-org",
+    name: "GitHub Integration",
+    slug: "github-integration",
+    description: "Interact with GitHub repositories, PRs, and issues.",
+    category: "INTEGRATION",
+    status: "ACTIVE",
+    parametersSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list_prs", "get_pr", "create_comment"]
+        },
+        repo: { type: "string" },
+        params: { type: "object" }
+      },
+      required: ["action", "repo"]
+    },
+    implementationType: "http",
+    implementationConfig: { url: "https://api.github.com", auth: "token" },
+    maxInvocationsPerMinute: 100,
+    timeoutMs: 15000,
+    version: "2.0.0",
+    tags: ["github", "integration", "code"],
+    createdAt: new Date("2024-02-20T00:00:00Z"),
+    updatedAt: new Date("2024-04-01T09:00:00Z")
+  },
+  {
+    id: "tool-5",
+    organizationId: "demo-org",
+    name: "Calculator",
+    slug: "calculator",
+    description: "Perform mathematical calculations.",
+    category: "COMPUTATION",
+    status: "ACTIVE",
+    parametersSchema: {
+      type: "object",
+      properties: {
+        expression: {
+          type: "string",
+          description: "Math expression to evaluate"
+        }
+      },
+      required: ["expression"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: { result: { type: "number" } }
+    },
+    implementationType: "function",
+    implementationConfig: { handler: "evaluateMath" },
+    timeoutMs: 5000,
+    version: "1.0.0",
+    tags: ["math", "utility"],
+    createdAt: new Date("2024-01-10T00:00:00Z"),
+    updatedAt: new Date("2024-01-10T00:00:00Z")
+  }
+];
+
+// src/agent/agent.handler.ts
+async function mockListAgentsHandler(input) {
+  const {
+    organizationId,
+    status,
+    modelProvider,
+    search,
+    limit = 20,
+    offset = 0
+  } = input;
+  let filtered = MOCK_AGENTS.filter((a) => a.organizationId === organizationId);
+  if (status)
+    filtered = filtered.filter((a) => a.status === status);
+  if (modelProvider)
+    filtered = filtered.filter((a) => a.modelProvider === modelProvider);
+  if (search) {
+    const q = search.toLowerCase();
+    filtered = filtered.filter((a) => a.name.toLowerCase().includes(q) || a.description?.toLowerCase().includes(q) || a.tags?.some((t) => t.toLowerCase().includes(q)));
+  }
+  const total = filtered.length;
+  const items = filtered.slice(offset, offset + limit).map((a) => ({
+    id: a.id,
+    name: a.name,
+    slug: a.slug,
+    description: a.description,
+    status: a.status,
+    modelProvider: a.modelProvider,
+    modelName: a.modelName,
+    version: a.version,
+    createdAt: a.createdAt
+  }));
+  return { items, total, hasMore: offset + limit < total };
+}
+async function mockGetAgentHandler(input) {
+  const agent = MOCK_AGENTS.find((a) => a.id === input.agentId);
+  if (!agent)
+    throw new Error("AGENT_NOT_FOUND");
+  const result = { ...agent, toolIds: ["tool-1", "tool-2"] };
+  if (input.includeTools) {
+    result.tools = MOCK_TOOLS.slice(0, 2).map((t) => ({
+      id: t.id,
+      name: t.name,
+      slug: t.slug,
+      description: t.description,
+      category: t.category
+    }));
+  }
+  return result;
+}
+async function mockCreateAgentHandler(input) {
+  const exists = MOCK_AGENTS.some((a) => a.organizationId === input.organizationId && a.slug === input.slug);
+  if (exists)
+    throw new Error("SLUG_EXISTS");
+  return {
+    id: `agent-${Date.now()}`,
+    name: input.name,
+    slug: input.slug,
+    status: "DRAFT"
+  };
+}
+async function mockUpdateAgentHandler(input) {
+  const agent = MOCK_AGENTS.find((a) => a.id === input.agentId);
+  if (!agent)
+    throw new Error("AGENT_NOT_FOUND");
+  return {
+    id: agent.id,
+    name: input.name ?? agent.name,
+    status: input.status ?? agent.status,
+    updatedAt: new Date
+  };
+}
+
+// src/handlers/agent.handlers.ts
+import { web } from "@contractspec/lib.runtime-sandbox";
+var { generateId } = web;
+function rowToAgent(row) {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    organizationId: row.organizationId,
+    name: row.name,
+    description: row.description ?? undefined,
+    modelProvider: row.modelProvider,
+    modelName: row.modelName,
+    systemPrompt: row.systemPrompt ?? undefined,
+    temperature: row.temperature,
+    maxTokens: row.maxTokens,
+    status: row.status,
+    createdAt: new Date(row.createdAt),
+    updatedAt: new Date(row.updatedAt)
+  };
+}
+function rowToTool(row) {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    organizationId: row.organizationId,
+    name: row.name,
+    description: row.description ?? undefined,
+    version: row.version,
+    category: row.category,
+    status: row.status,
+    inputSchema: row.inputSchema ?? undefined,
+    outputSchema: row.outputSchema ?? undefined,
+    endpoint: row.endpoint ?? undefined,
+    createdAt: new Date(row.createdAt),
+    updatedAt: new Date(row.updatedAt)
+  };
+}
+function rowToRun(row, agentName) {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    agentId: row.agentId,
+    agentName,
+    status: row.status,
+    input: row.input ?? undefined,
+    output: row.output ?? undefined,
+    totalTokens: row.totalTokens,
+    promptTokens: row.promptTokens,
+    completionTokens: row.completionTokens,
+    estimatedCostUsd: row.estimatedCostUsd,
+    durationMs: row.durationMs ?? undefined,
+    errorMessage: row.errorMessage ?? undefined,
+    queuedAt: new Date(row.queuedAt),
+    startedAt: row.startedAt ? new Date(row.startedAt) : undefined,
+    completedAt: row.completedAt ? new Date(row.completedAt) : undefined
+  };
+}
+function createAgentHandlers(db) {
+  async function listAgents(input) {
+    const {
+      projectId,
+      organizationId,
+      status,
+      search,
+      limit = 20,
+      offset = 0
+    } = input;
+    let whereClause = "WHERE projectId = ?";
+    const params = [projectId];
+    if (organizationId) {
+      whereClause += " AND organizationId = ?";
+      params.push(organizationId);
+    }
+    if (status && status !== "all") {
+      whereClause += " AND status = ?";
+      params.push(status);
+    }
+    if (search) {
+      whereClause += " AND (name LIKE ? OR description LIKE ?)";
+      params.push(`%${search}%`, `%${search}%`);
+    }
+    const countResult = (await db.query(`SELECT COUNT(*) as count FROM agent_definition ${whereClause}`, params)).rows;
+    const total = countResult[0]?.count ?? 0;
+    const rows = (await db.query(`SELECT * FROM agent_definition ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`, [...params, limit, offset])).rows;
+    return {
+      items: rows.map(rowToAgent),
+      total,
+      hasMore: offset + rows.length < total
+    };
+  }
+  async function getAgent(id) {
+    const rows = (await db.query(`SELECT * FROM agent_definition WHERE id = ?`, [id])).rows;
+    return rows[0] ? rowToAgent(rows[0]) : null;
+  }
+  async function createAgent(input, context) {
+    const id = generateId("agent");
+    const now = new Date().toISOString();
+    await db.execute(`INSERT INTO agent_definition (id, projectId, organizationId, name, description, modelProvider, modelName, systemPrompt, temperature, maxTokens, status, createdAt, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      id,
+      context.projectId,
+      context.organizationId,
+      input.name,
+      input.description ?? null,
+      input.modelProvider ?? "openai",
+      input.modelName ?? "gpt-4",
+      input.systemPrompt ?? null,
+      input.temperature ?? 0.7,
+      input.maxTokens ?? 4096,
+      "DRAFT",
+      now,
+      now
+    ]);
+    const rows = (await db.query(`SELECT * FROM agent_definition WHERE id = ?`, [id])).rows;
+    const row = rows[0];
+    if (!row) {
+      throw new Error("Failed to retrieve created agent");
+    }
+    return rowToAgent(row);
+  }
+  async function updateAgent(input) {
+    const now = new Date().toISOString();
+    const updates = ["updatedAt = ?"];
+    const params = [now];
+    if (input.name !== undefined) {
+      updates.push("name = ?");
+      params.push(input.name);
+    }
+    if (input.description !== undefined) {
+      updates.push("description = ?");
+      params.push(input.description);
+    }
+    if (input.status !== undefined) {
+      updates.push("status = ?");
+      params.push(input.status);
+    }
+    params.push(input.id);
+    await db.execute(`UPDATE agent_definition SET ${updates.join(", ")} WHERE id = ?`, params);
+    const rows = (await db.query(`SELECT * FROM agent_definition WHERE id = ?`, [input.id])).rows;
+    if (!rows[0]) {
+      throw new Error("NOT_FOUND");
+    }
+    return rowToAgent(rows[0]);
+  }
+  async function listTools(input) {
+    const {
+      projectId,
+      organizationId,
+      category,
+      status,
+      search,
+      limit = 50,
+      offset = 0
+    } = input;
+    let whereClause = "WHERE projectId = ?";
+    const params = [projectId];
+    if (organizationId) {
+      whereClause += " AND organizationId = ?";
+      params.push(organizationId);
+    }
+    if (category && category !== "all") {
+      whereClause += " AND category = ?";
+      params.push(category);
+    }
+    if (status && status !== "all") {
+      whereClause += " AND status = ?";
+      params.push(status);
+    }
+    if (search) {
+      whereClause += " AND (name LIKE ? OR description LIKE ?)";
+      params.push(`%${search}%`, `%${search}%`);
+    }
+    const countResult = (await db.query(`SELECT COUNT(*) as count FROM agent_tool ${whereClause}`, params)).rows;
+    const total = countResult[0]?.count ?? 0;
+    const rows = (await db.query(`SELECT * FROM agent_tool ${whereClause} ORDER BY name ASC LIMIT ? OFFSET ?`, [...params, limit, offset])).rows;
+    return {
+      items: rows.map(rowToTool),
+      total,
+      hasMore: offset + rows.length < total
+    };
+  }
+  async function listRuns(input) {
+    const { projectId, agentId, status, limit = 20, offset = 0 } = input;
+    let whereClause = "WHERE r.projectId = ?";
+    const params = [projectId];
+    if (agentId) {
+      whereClause += " AND r.agentId = ?";
+      params.push(agentId);
+    }
+    if (status && status !== "all") {
+      whereClause += " AND r.status = ?";
+      params.push(status);
+    }
+    const countResult = (await db.query(`SELECT COUNT(*) as count FROM agent_run r ${whereClause}`, params)).rows;
+    const total = countResult[0]?.count ?? 0;
+    const rows = (await db.query(`SELECT r.*, a.name as agentName 
+       FROM agent_run r 
+       LEFT JOIN agent_definition a ON r.agentId = a.id 
+       ${whereClause} 
+       ORDER BY r.queuedAt DESC LIMIT ? OFFSET ?`, [...params, limit, offset])).rows;
+    return {
+      items: rows.map((r) => rowToRun(r, r.agentName)),
+      total,
+      hasMore: offset + rows.length < total
+    };
+  }
+  async function getRunMetrics(input) {
+    let whereClause = "WHERE projectId = ?";
+    const params = [input.projectId];
+    if (input.agentId) {
+      whereClause += " AND agentId = ?";
+      params.push(input.agentId);
+    }
+    if (input.startDate) {
+      whereClause += " AND queuedAt >= ?";
+      params.push(input.startDate.toISOString());
+    }
+    if (input.endDate) {
+      whereClause += " AND queuedAt <= ?";
+      params.push(input.endDate.toISOString());
+    }
+    const result = (await db.query(`SELECT 
+        COUNT(*) as totalRuns,
+        SUM(CASE WHEN status = 'COMPLETED' THEN 1 ELSE 0 END) as completedRuns,
+        AVG(CASE WHEN status = 'COMPLETED' THEN durationMs ELSE NULL END) as avgDuration,
+        COALESCE(SUM(totalTokens), 0) as totalTokens,
+        COALESCE(SUM(estimatedCostUsd), 0) as totalCost
+       FROM agent_run ${whereClause}`, params)).rows;
+    const data = result[0];
+    const totalRuns = data?.totalRuns ?? 0;
+    const completedRuns = data?.completedRuns ?? 0;
+    return {
+      totalRuns,
+      successRate: totalRuns > 0 ? completedRuns / totalRuns : 0,
+      averageDurationMs: data?.avgDuration ?? 0,
+      totalTokens: data?.totalTokens ?? 0,
+      totalCostUsd: data?.totalCost ?? 0
+    };
+  }
+  return {
+    listAgents,
+    getAgent,
+    createAgent,
+    updateAgent,
+    listTools,
+    listRuns,
+    getRunMetrics
+  };
+}
+
+// src/shared/mock-runs.ts
+var MOCK_RUNS = [
+  {
+    id: "run-1",
+    organizationId: "demo-org",
+    agentId: "agent-1",
+    agentName: "Customer Support Bot",
+    userId: "user-1",
+    sessionId: "session-1",
+    input: { message: "How do I reset my password?", context: {} },
+    output: { response: "You can reset your password by clicking..." },
+    status: "COMPLETED",
+    totalTokens: 1250,
+    promptTokens: 800,
+    completionTokens: 450,
+    totalIterations: 3,
+    durationMs: 4500,
+    estimatedCostUsd: 0.0025,
+    queuedAt: new Date("2024-04-15T10:00:00Z"),
+    startedAt: new Date("2024-04-15T10:00:01Z"),
+    completedAt: new Date("2024-04-15T10:00:05Z"),
+    steps: [],
+    logs: []
+  },
+  {
+    id: "run-2",
+    organizationId: "demo-org",
+    agentId: "agent-2",
+    agentName: "Code Review Assistant",
+    userId: "user-2",
+    input: { message: "Review PR #123", context: { prNumber: 123 } },
+    status: "IN_PROGRESS",
+    totalTokens: 3500,
+    promptTokens: 3000,
+    completionTokens: 500,
+    totalIterations: 5,
+    queuedAt: new Date("2024-04-15T10:30:00Z"),
+    startedAt: new Date("2024-04-15T10:30:02Z"),
+    steps: [],
+    logs: []
+  },
+  {
+    id: "run-3",
+    organizationId: "demo-org",
+    agentId: "agent-1",
+    agentName: "Customer Support Bot",
+    userId: "user-1",
+    input: { message: "What are your business hours?" },
+    output: { response: "Our business hours are 9 AM to 5 PM EST..." },
+    status: "COMPLETED",
+    totalTokens: 800,
+    promptTokens: 500,
+    completionTokens: 300,
+    totalIterations: 2,
+    durationMs: 2100,
+    estimatedCostUsd: 0.0012,
+    queuedAt: new Date("2024-04-15T09:00:00Z"),
+    startedAt: new Date("2024-04-15T09:00:01Z"),
+    completedAt: new Date("2024-04-15T09:00:03Z"),
+    steps: [],
+    logs: []
+  },
+  {
+    id: "run-4",
+    organizationId: "demo-org",
+    agentId: "agent-3",
+    agentName: "Data Analyst",
+    userId: "user-3",
+    input: { message: "Generate sales report for Q1" },
+    status: "FAILED",
+    errorMessage: "Database connection timeout",
+    errorCode: "DB_TIMEOUT",
+    totalTokens: 2000,
+    promptTokens: 1500,
+    completionTokens: 500,
+    totalIterations: 8,
+    durationMs: 45000,
+    queuedAt: new Date("2024-04-14T15:00:00Z"),
+    startedAt: new Date("2024-04-14T15:00:05Z"),
+    completedAt: new Date("2024-04-14T15:00:50Z"),
+    steps: [],
+    logs: []
+  },
+  {
+    id: "run-5",
+    organizationId: "demo-org",
+    agentId: "agent-2",
+    agentName: "Code Review Assistant",
+    userId: "user-2",
+    input: { message: "Review PR #120" },
+    output: { response: "Code review complete. 3 suggestions..." },
+    status: "COMPLETED",
+    totalTokens: 5200,
+    promptTokens: 4000,
+    completionTokens: 1200,
+    totalIterations: 7,
+    durationMs: 15000,
+    estimatedCostUsd: 0.0156,
+    queuedAt: new Date("2024-04-14T11:00:00Z"),
+    startedAt: new Date("2024-04-14T11:00:03Z"),
+    completedAt: new Date("2024-04-14T11:00:18Z"),
+    steps: [],
+    logs: []
+  }
+];
+
+// src/run/run.handler.ts
+async function mockListRunsHandler(input) {
+  const { agentId, status, limit = 20, offset = 0 } = input;
+  let filtered = [...MOCK_RUNS];
+  if (agentId)
+    filtered = filtered.filter((r) => r.agentId === agentId);
+  if (status)
+    filtered = filtered.filter((r) => r.status === status);
+  const total = filtered.length;
+  const items = filtered.slice(offset, offset + limit).map((r) => {
+    const agent = MOCK_AGENTS.find((a) => a.id === r.agentId);
+    return {
+      id: r.id,
+      agentId: r.agentId,
+      agentName: agent?.name ?? "Unknown",
+      status: r.status,
+      totalTokens: r.totalTokens,
+      durationMs: r.durationMs,
+      estimatedCostUsd: r.estimatedCostUsd,
+      queuedAt: r.queuedAt,
+      completedAt: r.completedAt
+    };
+  });
+  return { items, total, hasMore: offset + limit < total };
+}
+async function mockGetRunHandler(input) {
+  const run = MOCK_RUNS.find((r) => r.id === input.runId);
+  if (!run)
+    throw new Error("RUN_NOT_FOUND");
+  const agent = MOCK_AGENTS.find((a) => a.id === run.agentId);
+  return {
+    ...run,
+    agent: agent ? {
+      id: agent.id,
+      name: agent.name,
+      modelProvider: agent.modelProvider,
+      modelName: agent.modelName
+    } : undefined,
+    steps: input.includeSteps ? run.steps : undefined,
+    logs: input.includeLogs ? run.logs : undefined
+  };
+}
+async function mockExecuteAgentHandler(input) {
+  const agent = MOCK_AGENTS.find((a) => a.id === input.agentId);
+  if (!agent)
+    throw new Error("AGENT_NOT_FOUND");
+  if (agent.status !== "ACTIVE")
+    throw new Error("AGENT_NOT_ACTIVE");
+  return {
+    runId: `run-${Date.now()}`,
+    status: "QUEUED",
+    estimatedWaitMs: 500
+  };
+}
+async function mockCancelRunHandler(input) {
+  const run = MOCK_RUNS.find((r) => r.id === input.runId);
+  if (!run)
+    throw new Error("RUN_NOT_FOUND");
+  if (!["QUEUED", "IN_PROGRESS"].includes(run.status))
+    throw new Error("RUN_NOT_CANCELLABLE");
+  return { success: true, status: "CANCELLED" };
+}
+
+// src/tool/tool.handler.ts
+async function mockListToolsHandler(input) {
+  const {
+    organizationId,
+    category,
+    status,
+    search,
+    limit = 20,
+    offset = 0
+  } = input;
+  let filtered = MOCK_TOOLS.filter((t) => t.organizationId === organizationId);
+  if (category)
+    filtered = filtered.filter((t) => t.category === category);
+  if (status)
+    filtered = filtered.filter((t) => t.status === status);
+  if (search) {
+    const q = search.toLowerCase();
+    filtered = filtered.filter((t) => t.name.toLowerCase().includes(q) || t.description.toLowerCase().includes(q));
+  }
+  const total = filtered.length;
+  const items = filtered.slice(offset, offset + limit).map((t) => ({
+    id: t.id,
+    name: t.name,
+    slug: t.slug,
+    description: t.description,
+    category: t.category,
+    status: t.status,
+    version: t.version,
+    createdAt: t.createdAt
+  }));
+  return { items, total, hasMore: offset + limit < total };
+}
+async function mockGetToolHandler(input) {
+  const tool = MOCK_TOOLS.find((t) => t.id === input.toolId);
+  if (!tool)
+    throw new Error("TOOL_NOT_FOUND");
+  return tool;
+}
+async function mockCreateToolHandler(input) {
+  const exists = MOCK_TOOLS.some((t) => t.organizationId === input.organizationId && t.slug === input.slug);
+  if (exists)
+    throw new Error("SLUG_EXISTS");
+  return {
+    id: `tool-${Date.now()}`,
+    name: input.name,
+    slug: input.slug,
+    status: "DRAFT"
+  };
+}
+async function mockUpdateToolHandler(input) {
+  const tool = MOCK_TOOLS.find((t) => t.id === input.toolId);
+  if (!tool)
+    throw new Error("TOOL_NOT_FOUND");
+  return {
+    id: tool.id,
+    name: input.name ?? tool.name,
+    status: input.status ?? tool.status,
+    updatedAt: new Date
+  };
+}
+async function mockTestToolHandler(input) {
+  const tool = MOCK_TOOLS.find((t) => t.id === input.toolId);
+  if (!tool)
+    throw new Error("TOOL_NOT_FOUND");
+  const startTime = Date.now();
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  return {
+    success: true,
+    output: { result: "Test successful", input: input.testInput },
+    durationMs: Date.now() - startTime
+  };
+}
+export {
+  mockListToolsHandler,
+  mockListRunsHandler,
+  mockListAgentsHandler,
+  mockGetToolHandler,
+  mockGetRunHandler,
+  mockGetAgentHandler,
+  mockExecuteAgentHandler,
+  mockCreateToolHandler,
+  mockCreateAgentHandler,
+  createAgentHandlers
+};