@contractspec/example.agent-console 3.7.7 → 3.8.4

package/dist/browser/tool/index.js

@@ -142,164 +142,6 @@ var MOCK_TOOLS = [
   }
 ];
 
-// 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.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.enum.ts
 import { defineEnum } from "@contractspec/lib.schema";
 var ToolCategoryEnum = defineEnum("ToolCategory", [
@@ -322,209 +164,114 @@ var ImplementationTypeEnum = defineEnum("ImplementationType", [
   "workflow"
 ]);
 
-// src/tool/tool.event.ts
-import { defineEvent } from "@contractspec/lib.contracts-spec";
+// src/tool/tool.schema.ts
 import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
-var OWNERS = ["@agent-console-team"];
-var ToolCreatedPayload = defineSchemaModel({
-  name: "ToolCreatedPayload",
-  description: "Payload for tool created event",
+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.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
     slug: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    category: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    implementationType: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false
-    },
-    createdById: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    createdAt: { type: ScalarTypeEnum.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: [...OWNERS],
-    tags: ["tool", "created"]
-  },
-  payload: ToolCreatedPayload
-});
-var ToolUpdatedPayload = defineSchemaModel({
-  name: "ToolUpdatedPayload",
-  description: "Payload for tool updated event",
-  fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false
-    },
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    status: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    updatedFields: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isArray: true,
-      isOptional: false
-    },
-    updatedAt: { type: ScalarTypeEnum.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: [...OWNERS],
-    tags: ["tool", "updated"]
-  },
-  payload: ToolUpdatedPayload
-});
-var ToolStatusChangedPayload = defineSchemaModel({
-  name: "ToolStatusChangedPayload",
-  description: "Payload for tool status changed event",
-  fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false
-    },
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    previousStatus: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false
-    },
-    newStatus: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    changedAt: { type: ScalarTypeEnum.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: [...OWNERS],
-    tags: ["tool", "status"]
-  },
-  payload: ToolStatusChangedPayload
-});
-
-// src/tool/tool.schema.ts
-import { defineSchemaModel as defineSchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
-var ToolModel = defineSchemaModel2({
-  name: "Tool",
-  description: "AI tool definition",
-  fields: {
-    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    organizationId: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: false
-    },
-    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    slug: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
     category: { type: ToolCategoryEnum, isOptional: false },
     status: { type: ToolStatusEnum, isOptional: false },
-    parametersSchema: { type: ScalarTypeEnum2.JSONObject(), isOptional: false },
-    outputSchema: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    parametersSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
+    outputSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
     implementationType: { type: ImplementationTypeEnum, isOptional: false },
     implementationConfig: {
-      type: ScalarTypeEnum2.JSONObject(),
+      type: ScalarTypeEnum.JSONObject(),
       isOptional: false
     },
     maxInvocationsPerMinute: {
-      type: ScalarTypeEnum2.Int_unsecure(),
+      type: ScalarTypeEnum.Int_unsecure(),
       isOptional: true
     },
     timeoutMs: {
-      type: ScalarTypeEnum2.Int_unsecure(),
+      type: ScalarTypeEnum.Int_unsecure(),
       isOptional: false,
       defaultValue: 30000
     },
-    version: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    version: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
     tags: {
-      type: ScalarTypeEnum2.String_unsecure(),
+      type: ScalarTypeEnum.String_unsecure(),
       isArray: true,
       isOptional: true
     },
-    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
   }
 });
-var ToolSummaryModel = defineSchemaModel2({
+var ToolSummaryModel = defineSchemaModel({
   name: "ToolSummary",
   description: "Summary of a tool for list views",
   fields: {
-    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    slug: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    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: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+    version: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
   }
 });
-var CreateToolInputModel = defineSchemaModel2({
+var CreateToolInputModel = defineSchemaModel({
   name: "CreateToolInput",
   description: "Input for creating a tool",
   fields: {
     organizationId: {
-      type: ScalarTypeEnum2.String_unsecure(),
+      type: ScalarTypeEnum.String_unsecure(),
       isOptional: false
     },
-    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    slug: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    description: { type: ScalarTypeEnum2.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: ScalarTypeEnum2.JSONObject(), isOptional: false },
-    outputSchema: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    parametersSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
+    outputSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
     implementationType: { type: ImplementationTypeEnum, isOptional: false },
     implementationConfig: {
-      type: ScalarTypeEnum2.JSONObject(),
+      type: ScalarTypeEnum.JSONObject(),
       isOptional: false
     },
     maxInvocationsPerMinute: {
-      type: ScalarTypeEnum2.Int_unsecure(),
+      type: ScalarTypeEnum.Int_unsecure(),
       isOptional: true
     },
-    timeoutMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    timeoutMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
     tags: {
-      type: ScalarTypeEnum2.String_unsecure(),
+      type: ScalarTypeEnum.String_unsecure(),
       isArray: true,
       isOptional: true
     }
   }
 });
-var UpdateToolInputModel = defineSchemaModel2({
+var UpdateToolInputModel = defineSchemaModel({
   name: "UpdateToolInput",
   description: "Input for updating a tool",
   fields: {
-    toolId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: true },
-    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    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: ScalarTypeEnum2.JSONObject(), isOptional: true },
-    outputSchema: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    parametersSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    outputSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
     implementationConfig: {
-      type: ScalarTypeEnum2.JSONObject(),
+      type: ScalarTypeEnum.JSONObject(),
       isOptional: true
     },
     maxInvocationsPerMinute: {
-      type: ScalarTypeEnum2.Int_unsecure(),
+      type: ScalarTypeEnum.Int_unsecure(),
       isOptional: true
     },
-    timeoutMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    timeoutMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
     tags: {
-      type: ScalarTypeEnum2.String_unsecure(),
+      type: ScalarTypeEnum.String_unsecure(),
       isArray: true,
       isOptional: true
     }
@@ -536,14 +283,14 @@ import {
   defineCommand,
   defineQuery
 } from "@contractspec/lib.contracts-spec/operations";
-import { defineSchemaModel as defineSchemaModel3, ScalarTypeEnum as ScalarTypeEnum3 } from "@contractspec/lib.schema";
-var OWNERS2 = ["@agent-console-team"];
+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: [...OWNERS2],
+    owners: [...OWNERS],
     tags: ["tool", "create"],
     description: "Creates a new AI tool definition.",
     goal: "Allow users to define new tools that agents can use.",
@@ -551,12 +298,12 @@ var CreateToolCommand = defineCommand({
   },
   io: {
     input: CreateToolInputModel,
-    output: defineSchemaModel3({
+    output: defineSchemaModel2({
       name: "CreateToolOutput",
       fields: {
-        id: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-        name: { type: ScalarTypeEnum3.NonEmptyString(), isOptional: false },
-        slug: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        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 }
       }
     }),
@@ -576,7 +323,7 @@ var CreateToolCommand = defineCommand({
         key: "tool.created",
         version: "1.0.0",
         stability: "stable",
-        owners: [...OWNERS2],
+        owners: [...OWNERS],
         tags: ["tool", "created"],
         when: "Tool is successfully created",
         payload: ToolSummaryModel
@@ -623,7 +370,7 @@ var UpdateToolCommand = defineCommand({
     key: "agent.tool.update",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS2],
+    owners: [...OWNERS],
     tags: ["tool", "update"],
     description: "Updates an existing AI tool definition.",
     goal: "Allow users to modify tool settings and configuration.",
@@ -631,13 +378,13 @@ var UpdateToolCommand = defineCommand({
   },
   io: {
     input: UpdateToolInputModel,
-    output: defineSchemaModel3({
+    output: defineSchemaModel2({
       name: "UpdateToolOutput",
       fields: {
-        id: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-        name: { type: ScalarTypeEnum3.NonEmptyString(), isOptional: false },
+        id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
         status: { type: ToolStatusEnum, isOptional: false },
-        updatedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+        updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
       }
     }),
     errors: {
@@ -656,7 +403,7 @@ var UpdateToolCommand = defineCommand({
         key: "tool.updated",
         version: "1.0.0",
         stability: "stable",
-        owners: [...OWNERS2],
+        owners: [...OWNERS],
         tags: ["tool", "updated"],
         when: "Tool is updated",
         payload: ToolSummaryModel
@@ -692,17 +439,17 @@ var GetToolQuery = defineQuery({
     key: "agent.tool.get",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS2],
+    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: defineSchemaModel3({
+    input: defineSchemaModel2({
       name: "GetToolInput",
       fields: {
-        toolId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false }
+        toolId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false }
       }
     }),
     output: ToolModel,
@@ -744,41 +491,41 @@ var ListToolsQuery = defineQuery({
     key: "agent.tool.list",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS2],
+    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: defineSchemaModel3({
+    input: defineSchemaModel2({
       name: "ListToolsInput",
       fields: {
         organizationId: {
-          type: ScalarTypeEnum3.String_unsecure(),
+          type: ScalarTypeEnum2.String_unsecure(),
           isOptional: false
         },
         category: { type: ToolCategoryEnum, isOptional: true },
         status: { type: ToolStatusEnum, isOptional: true },
-        search: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+        search: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
         limit: {
-          type: ScalarTypeEnum3.Int_unsecure(),
+          type: ScalarTypeEnum2.Int_unsecure(),
           isOptional: true,
           defaultValue: 20
         },
         offset: {
-          type: ScalarTypeEnum3.Int_unsecure(),
+          type: ScalarTypeEnum2.Int_unsecure(),
           isOptional: true,
           defaultValue: 0
         }
       }
     }),
-    output: defineSchemaModel3({
+    output: defineSchemaModel2({
       name: "ListToolsOutput",
       fields: {
         items: { type: ToolSummaryModel, isArray: true, isOptional: false },
-        total: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-        hasMore: { type: ScalarTypeEnum3.Boolean(), isOptional: false }
+        total: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum2.Boolean(), isOptional: false }
       }
     })
   },
@@ -806,27 +553,27 @@ var TestToolCommand = defineCommand({
     key: "agent.tool.test",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS2],
+    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: defineSchemaModel3({
+    input: defineSchemaModel2({
       name: "TestToolInput",
       fields: {
-        toolId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-        testInput: { type: ScalarTypeEnum3.JSONObject(), isOptional: false }
+        toolId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        testInput: { type: ScalarTypeEnum2.JSONObject(), isOptional: false }
       }
     }),
-    output: defineSchemaModel3({
+    output: defineSchemaModel2({
       name: "TestToolOutput",
       fields: {
-        success: { type: ScalarTypeEnum3.Boolean(), isOptional: false },
-        output: { type: ScalarTypeEnum3.JSONObject(), isOptional: true },
-        error: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-        durationMs: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false }
+        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: {
@@ -871,6 +618,259 @@ var TestToolCommand = defineCommand({
   }
 });
 
+// src/tool/tool.handler.ts
+var nextMockToolId = MOCK_TOOLS.length + 1;
+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-${nextMockToolId++}`,
+    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");
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  return {
+    success: true,
+    output: { result: "Test successful", input: input.testInput },
+    durationMs: 100
+  };
+}
+
+// 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.event.ts
+import { defineEvent } from "@contractspec/lib.contracts-spec";
+import { defineSchemaModel as defineSchemaModel3, 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.presentation.ts
 import {
   definePresentation,