@contractspec/example.agent-console 1.56.1 → 1.58.0

package/dist/browser/tool/index.js

@@ -0,0 +1,946 @@
+// 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/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
+  };
+}
+
+// src/tool/tool.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var ToolCategoryEnum = defineEnum("ToolCategory", [
+  "RETRIEVAL",
+  "COMPUTATION",
+  "COMMUNICATION",
+  "INTEGRATION",
+  "UTILITY",
+  "CUSTOM"
+]);
+var ToolStatusEnum = defineEnum("ToolStatus", [
+  "DRAFT",
+  "ACTIVE",
+  "DEPRECATED",
+  "DISABLED"
+]);
+var ImplementationTypeEnum = defineEnum("ImplementationType", [
+  "http",
+  "function",
+  "workflow"
+]);
+
+// src/tool/tool.schema.ts
+import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
+var ToolModel = defineSchemaModel({
+  name: "Tool",
+  description: "AI tool definition",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    category: { type: ToolCategoryEnum, isOptional: false },
+    status: { type: ToolStatusEnum, isOptional: false },
+    parametersSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
+    outputSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    implementationType: { type: ImplementationTypeEnum, isOptional: false },
+    implementationConfig: {
+      type: ScalarTypeEnum.JSONObject(),
+      isOptional: false
+    },
+    maxInvocationsPerMinute: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: true
+    },
+    timeoutMs: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 30000
+    },
+    version: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    tags: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var ToolSummaryModel = defineSchemaModel({
+  name: "ToolSummary",
+  description: "Summary of a tool for list views",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    category: { type: ToolCategoryEnum, isOptional: false },
+    status: { type: ToolStatusEnum, isOptional: false },
+    version: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var CreateToolInputModel = defineSchemaModel({
+  name: "CreateToolInput",
+  description: "Input for creating a tool",
+  fields: {
+    organizationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    category: { type: ToolCategoryEnum, isOptional: true },
+    parametersSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
+    outputSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    implementationType: { type: ImplementationTypeEnum, isOptional: false },
+    implementationConfig: {
+      type: ScalarTypeEnum.JSONObject(),
+      isOptional: false
+    },
+    maxInvocationsPerMinute: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: true
+    },
+    timeoutMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    tags: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+var UpdateToolInputModel = defineSchemaModel({
+  name: "UpdateToolInput",
+  description: "Input for updating a tool",
+  fields: {
+    toolId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: true },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    status: { type: ToolStatusEnum, isOptional: true },
+    parametersSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    outputSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    implementationConfig: {
+      type: ScalarTypeEnum.JSONObject(),
+      isOptional: true
+    },
+    maxInvocationsPerMinute: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: true
+    },
+    timeoutMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    tags: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+
+// src/tool/tool.operation.ts
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts/operations";
+import { defineSchemaModel as defineSchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
+var OWNERS = ["@agent-console-team"];
+var CreateToolCommand = defineCommand({
+  meta: {
+    key: "agent.tool.create",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["tool", "create"],
+    description: "Creates a new AI tool definition.",
+    goal: "Allow users to define new tools that agents can use.",
+    context: "Called from the tool builder UI when creating a new tool."
+  },
+  io: {
+    input: CreateToolInputModel,
+    output: defineSchemaModel2({
+      name: "CreateToolOutput",
+      fields: {
+        id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+        slug: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        status: { type: ToolStatusEnum, isOptional: false }
+      }
+    }),
+    errors: {
+      SLUG_EXISTS: {
+        description: "A tool with this slug already exists in the organization",
+        http: 409,
+        gqlCode: "SLUG_EXISTS",
+        when: "Slug is already taken"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "tool.created",
+        version: "1.0.0",
+        stability: "stable",
+        owners: [...OWNERS],
+        tags: ["tool", "created"],
+        when: "Tool is successfully created",
+        payload: ToolSummaryModel
+      }
+    ],
+    audit: ["tool.created"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "create-tool-happy-path",
+        given: ["User is authenticated", "Organization exists"],
+        when: ["User submits valid tool configuration"],
+        then: ["New tool is created", "ToolCreated event is emitted"]
+      },
+      {
+        key: "create-tool-slug-conflict",
+        given: ["Tool with same slug exists"],
+        when: ["User submits tool with duplicate slug"],
+        then: ["SLUG_EXISTS error is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "create-api-tool",
+        input: {
+          name: "Weather API",
+          slug: "weather-api",
+          category: "api",
+          description: "Fetches weather data"
+        },
+        output: {
+          id: "tool-123",
+          name: "Weather API",
+          slug: "weather-api",
+          status: "draft"
+        }
+      }
+    ]
+  }
+});
+var UpdateToolCommand = defineCommand({
+  meta: {
+    key: "agent.tool.update",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["tool", "update"],
+    description: "Updates an existing AI tool definition.",
+    goal: "Allow users to modify tool settings and configuration.",
+    context: "Called from the tool settings UI."
+  },
+  io: {
+    input: UpdateToolInputModel,
+    output: defineSchemaModel2({
+      name: "UpdateToolOutput",
+      fields: {
+        id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+        status: { type: ToolStatusEnum, isOptional: false },
+        updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+      }
+    }),
+    errors: {
+      TOOL_NOT_FOUND: {
+        description: "The specified tool does not exist",
+        http: 404,
+        gqlCode: "TOOL_NOT_FOUND",
+        when: "Tool ID is invalid"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "tool.updated",
+        version: "1.0.0",
+        stability: "stable",
+        owners: [...OWNERS],
+        tags: ["tool", "updated"],
+        when: "Tool is updated",
+        payload: ToolSummaryModel
+      }
+    ],
+    audit: ["tool.updated"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "update-tool-happy-path",
+        given: ["Tool exists", "User owns the tool"],
+        when: ["User submits updated configuration"],
+        then: ["Tool is updated", "ToolUpdated event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "update-description",
+        input: { toolId: "tool-123", description: "Updated weather API tool" },
+        output: {
+          id: "tool-123",
+          name: "Weather API",
+          status: "draft",
+          updatedAt: "2025-01-01T00:00:00Z"
+        }
+      }
+    ]
+  }
+});
+var GetToolQuery = defineQuery({
+  meta: {
+    key: "agent.tool.get",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["tool", "get"],
+    description: "Retrieves a tool by its ID.",
+    goal: "View detailed tool configuration.",
+    context: "Called when viewing tool details or editing."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "GetToolInput",
+      fields: {
+        toolId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false }
+      }
+    }),
+    output: ToolModel,
+    errors: {
+      TOOL_NOT_FOUND: {
+        description: "The specified tool does not exist",
+        http: 404,
+        gqlCode: "TOOL_NOT_FOUND",
+        when: "Tool ID is invalid"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-tool-happy-path",
+        given: ["Tool exists"],
+        when: ["User requests tool by ID"],
+        then: ["Tool details are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-basic",
+        input: { toolId: "tool-123" },
+        output: {
+          id: "tool-123",
+          name: "Weather API",
+          status: "active",
+          category: "api"
+        }
+      }
+    ]
+  }
+});
+var ListToolsQuery = defineQuery({
+  meta: {
+    key: "agent.tool.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["tool", "list"],
+    description: "Lists tools for an organization with optional filtering.",
+    goal: "Browse and search available tools.",
+    context: "Tool list/dashboard view."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "ListToolsInput",
+      fields: {
+        organizationId: {
+          type: ScalarTypeEnum2.String_unsecure(),
+          isOptional: false
+        },
+        category: { type: ToolCategoryEnum, isOptional: true },
+        status: { type: ToolStatusEnum, isOptional: true },
+        search: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+        limit: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 20
+        },
+        offset: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "ListToolsOutput",
+      fields: {
+        items: { type: ToolSummaryModel, isArray: true, isOptional: false },
+        total: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum2.Boolean(), isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "list-tools-happy-path",
+        given: ["Organization has tools"],
+        when: ["User lists tools"],
+        then: ["Paginated list of tools is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "list-by-category",
+        input: { organizationId: "org-123", category: "api", limit: 10 },
+        output: { items: [], total: 0, hasMore: false }
+      }
+    ]
+  }
+});
+var TestToolCommand = defineCommand({
+  meta: {
+    key: "agent.tool.test",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["tool", "test"],
+    description: "Tests a tool with sample input to verify it works correctly.",
+    goal: "Validate tool configuration before deployment.",
+    context: "Tool builder UI - test panel."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "TestToolInput",
+      fields: {
+        toolId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        testInput: { type: ScalarTypeEnum2.JSONObject(), isOptional: false }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "TestToolOutput",
+      fields: {
+        success: { type: ScalarTypeEnum2.Boolean(), isOptional: false },
+        output: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+        error: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+        durationMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false }
+      }
+    }),
+    errors: {
+      TOOL_NOT_FOUND: {
+        description: "The specified tool does not exist",
+        http: 404,
+        gqlCode: "TOOL_NOT_FOUND",
+        when: "Tool ID is invalid"
+      },
+      TOOL_EXECUTION_ERROR: {
+        description: "Tool execution failed",
+        http: 500,
+        gqlCode: "TOOL_EXECUTION_ERROR",
+        when: "Tool returns an error"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  sideEffects: { audit: ["tool.tested"] },
+  acceptance: {
+    scenarios: [
+      {
+        key: "test-tool-success",
+        given: ["Tool exists", "Tool is configured correctly"],
+        when: ["User runs test with valid input"],
+        then: ["Tool executes successfully", "Output is returned"]
+      },
+      {
+        key: "test-tool-failure",
+        given: ["Tool exists", "Tool has configuration error"],
+        when: ["User runs test"],
+        then: ["TOOL_EXECUTION_ERROR is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "test-weather-api",
+        input: { toolId: "tool-123", testInput: { city: "Paris" } },
+        output: { success: true, output: { temperature: 22 }, durationMs: 150 }
+      }
+    ]
+  }
+});
+
+// src/tool/tool.event.ts
+import { defineEvent, defineSchemaModel as defineSchemaModel3 } from "@contractspec/lib.contracts";
+import { ScalarTypeEnum as ScalarTypeEnum3 } from "@contractspec/lib.schema";
+var OWNERS2 = ["@agent-console-team"];
+var ToolCreatedPayload = defineSchemaModel3({
+  name: "ToolCreatedPayload",
+  description: "Payload for tool created event",
+  fields: {
+    id: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    slug: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    category: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    implementationType: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: false
+    },
+    createdById: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var ToolCreatedEvent = defineEvent({
+  meta: {
+    key: "agent.tool.created",
+    version: "1.0.0",
+    description: "A new AI tool was created.",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["tool", "created"]
+  },
+  payload: ToolCreatedPayload
+});
+var ToolUpdatedPayload = defineSchemaModel3({
+  name: "ToolUpdatedPayload",
+  description: "Payload for tool updated event",
+  fields: {
+    id: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    status: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    updatedFields: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isArray: true,
+      isOptional: false
+    },
+    updatedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var ToolUpdatedEvent = defineEvent({
+  meta: {
+    key: "agent.tool.updated",
+    version: "1.0.0",
+    description: "An AI tool configuration was updated.",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["tool", "updated"]
+  },
+  payload: ToolUpdatedPayload
+});
+var ToolStatusChangedPayload = defineSchemaModel3({
+  name: "ToolStatusChangedPayload",
+  description: "Payload for tool status changed event",
+  fields: {
+    id: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    previousStatus: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: false
+    },
+    newStatus: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    changedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var ToolStatusChangedEvent = defineEvent({
+  meta: {
+    key: "agent.tool.statusChanged",
+    version: "1.0.0",
+    description: "An AI tool status was changed (activated, deprecated, disabled).",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["tool", "status"]
+  },
+  payload: ToolStatusChangedPayload
+});
+
+// src/tool/tool.entity.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var ToolCategoryEntityEnum = defineEntityEnum({
+  name: "ToolCategory",
+  values: [
+    "RETRIEVAL",
+    "COMPUTATION",
+    "COMMUNICATION",
+    "INTEGRATION",
+    "UTILITY",
+    "CUSTOM"
+  ],
+  description: "Category of tool"
+});
+var ToolStatusEntityEnum = defineEntityEnum({
+  name: "ToolStatus",
+  values: ["DRAFT", "ACTIVE", "DEPRECATED", "DISABLED"],
+  description: "Status of tool"
+});
+var ImplementationTypeEntityEnum = defineEntityEnum({
+  name: "ImplementationType",
+  values: ["http", "function", "workflow"],
+  description: "How the tool is implemented"
+});
+var ToolEntity = defineEntity({
+  name: "Tool",
+  schema: "agent_console",
+  description: "An AI tool that can be used by agents.",
+  fields: {
+    id: field.id(),
+    organizationId: field.string({
+      description: "Organization that owns this tool"
+    }),
+    name: field.string({ description: "Tool name" }),
+    slug: field.string({ description: "URL-safe identifier" }),
+    description: field.string({ description: "Tool description" }),
+    category: field.enum("ToolCategory", { default: "CUSTOM" }),
+    status: field.enum("ToolStatus", { default: "DRAFT" }),
+    parametersSchema: field.json({
+      description: "JSON Schema for tool parameters"
+    }),
+    outputSchema: field.json({
+      isOptional: true,
+      description: "JSON Schema for tool output"
+    }),
+    implementationType: field.enum("ImplementationType"),
+    implementationConfig: field.json({
+      description: "Implementation configuration"
+    }),
+    maxInvocationsPerMinute: field.int({
+      isOptional: true,
+      description: "Rate limit"
+    }),
+    timeoutMs: field.int({ default: 30000, description: "Execution timeout" }),
+    version: field.string({ default: "1.0.0", description: "Tool version" }),
+    tags: field.string({
+      isArray: true,
+      isOptional: true,
+      description: "Tags for categorization"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    createdById: field.string({
+      isOptional: true,
+      description: "User who created this tool"
+    }),
+    agents: field.hasMany("Agent", { description: "Agents using this tool" })
+  },
+  indexes: [
+    index.unique(["organizationId", "slug"]),
+    index.on(["organizationId", "category"]),
+    index.on(["organizationId", "status"])
+  ],
+  enums: [
+    ToolCategoryEntityEnum,
+    ToolStatusEntityEnum,
+    ImplementationTypeEntityEnum
+  ]
+});
+
+// src/tool/tool.presentation.ts
+import { StabilityEnum, definePresentation } from "@contractspec/lib.contracts";
+var ToolListPresentation = definePresentation({
+  meta: {
+    key: "agent-console.tool.list",
+    version: "1.0.0",
+    title: "Tool List",
+    description: "List view of AI tools with category, status, and version info",
+    goal: "Provide an overview of all available tools for agents.",
+    context: "Tool management dashboard.",
+    domain: "agent-console",
+    owners: ["@agent-console-team"],
+    tags: ["tool", "list", "dashboard"],
+    stability: StabilityEnum.Experimental
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "ToolListView",
+    props: ToolSummaryModel
+  },
+  targets: ["react", "markdown", "application/json"],
+  policy: { flags: ["agent-console.enabled"] }
+});
+var ToolDetailPresentation = definePresentation({
+  meta: {
+    key: "agent-console.tool.detail",
+    version: "1.0.0",
+    title: "Tool Details",
+    description: "Detailed view of an AI tool with configuration and test panel",
+    goal: "Allow users to inspect and test a specific tool.",
+    context: "Detailed view of a tool.",
+    domain: "agent-console",
+    owners: ["@agent-console-team"],
+    tags: ["tool", "detail"],
+    stability: StabilityEnum.Experimental
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "ToolDetailView"
+  },
+  targets: ["react", "markdown"],
+  policy: { flags: ["agent-console.enabled"] }
+});
+export {
+  mockUpdateToolHandler,
+  mockTestToolHandler,
+  mockListToolsHandler,
+  mockGetToolHandler,
+  mockCreateToolHandler,
+  UpdateToolInputModel,
+  UpdateToolCommand,
+  ToolUpdatedEvent,
+  ToolSummaryModel,
+  ToolStatusEnum,
+  ToolStatusEntityEnum,
+  ToolStatusChangedEvent,
+  ToolModel,
+  ToolListPresentation,
+  ToolEntity,
+  ToolDetailPresentation,
+  ToolCreatedEvent,
+  ToolCategoryEnum,
+  ToolCategoryEntityEnum,
+  TestToolCommand,
+  ListToolsQuery,
+  ImplementationTypeEnum,
+  ImplementationTypeEntityEnum,
+  GetToolQuery,
+  CreateToolInputModel,
+  CreateToolCommand
+};