@contractspec/example.agent-console 3.7.6 → 3.7.7

package/dist/tool/index.js

@@ -216,6 +216,91 @@ async function mockTestToolHandler(input) {
   };
 }
 
+// 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", [
@@ -238,114 +323,209 @@ var ImplementationTypeEnum = defineEnum("ImplementationType", [
   "workflow"
 ]);
 
-// src/tool/tool.schema.ts
+// src/tool/tool.event.ts
+import { defineEvent } from "@contractspec/lib.contracts-spec";
 import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
-var ToolModel = defineSchemaModel({
-  name: "Tool",
-  description: "AI tool definition",
+var OWNERS = ["@agent-console-team"];
+var ToolCreatedPayload = defineSchemaModel({
+  name: "ToolCreatedPayload",
+  description: "Payload for tool created event",
   fields: {
     id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
     organizationId: {
       type: ScalarTypeEnum.String_unsecure(),
       isOptional: false
     },
-    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
     slug: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    description: { 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 },
     category: { type: ToolCategoryEnum, isOptional: false },
     status: { type: ToolStatusEnum, isOptional: false },
-    parametersSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
-    outputSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    parametersSchema: { type: ScalarTypeEnum2.JSONObject(), isOptional: false },
+    outputSchema: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
     implementationType: { type: ImplementationTypeEnum, isOptional: false },
     implementationConfig: {
-      type: ScalarTypeEnum.JSONObject(),
+      type: ScalarTypeEnum2.JSONObject(),
       isOptional: false
     },
     maxInvocationsPerMinute: {
-      type: ScalarTypeEnum.Int_unsecure(),
+      type: ScalarTypeEnum2.Int_unsecure(),
       isOptional: true
     },
     timeoutMs: {
-      type: ScalarTypeEnum.Int_unsecure(),
+      type: ScalarTypeEnum2.Int_unsecure(),
       isOptional: false,
       defaultValue: 30000
     },
-    version: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    version: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
     tags: {
-      type: ScalarTypeEnum.String_unsecure(),
+      type: ScalarTypeEnum2.String_unsecure(),
       isArray: true,
       isOptional: true
     },
-    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
-    updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
   }
 });
-var ToolSummaryModel = defineSchemaModel({
+var ToolSummaryModel = defineSchemaModel2({
   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 },
+    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 },
     category: { type: ToolCategoryEnum, isOptional: false },
     status: { type: ToolStatusEnum, isOptional: false },
-    version: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+    version: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
   }
 });
-var CreateToolInputModel = defineSchemaModel({
+var CreateToolInputModel = defineSchemaModel2({
   name: "CreateToolInput",
   description: "Input for creating a tool",
   fields: {
     organizationId: {
-      type: ScalarTypeEnum.String_unsecure(),
+      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 },
+    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
     category: { type: ToolCategoryEnum, isOptional: true },
-    parametersSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
-    outputSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    parametersSchema: { type: ScalarTypeEnum2.JSONObject(), isOptional: false },
+    outputSchema: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
     implementationType: { type: ImplementationTypeEnum, isOptional: false },
     implementationConfig: {
-      type: ScalarTypeEnum.JSONObject(),
+      type: ScalarTypeEnum2.JSONObject(),
       isOptional: false
     },
     maxInvocationsPerMinute: {
-      type: ScalarTypeEnum.Int_unsecure(),
+      type: ScalarTypeEnum2.Int_unsecure(),
       isOptional: true
     },
-    timeoutMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    timeoutMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
     tags: {
-      type: ScalarTypeEnum.String_unsecure(),
+      type: ScalarTypeEnum2.String_unsecure(),
       isArray: true,
       isOptional: true
     }
   }
 });
-var UpdateToolInputModel = defineSchemaModel({
+var UpdateToolInputModel = defineSchemaModel2({
   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 },
+    toolId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: true },
+    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
     status: { type: ToolStatusEnum, isOptional: true },
-    parametersSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
-    outputSchema: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    parametersSchema: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    outputSchema: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
     implementationConfig: {
-      type: ScalarTypeEnum.JSONObject(),
+      type: ScalarTypeEnum2.JSONObject(),
       isOptional: true
     },
     maxInvocationsPerMinute: {
-      type: ScalarTypeEnum.Int_unsecure(),
+      type: ScalarTypeEnum2.Int_unsecure(),
       isOptional: true
     },
-    timeoutMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    timeoutMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
     tags: {
-      type: ScalarTypeEnum.String_unsecure(),
+      type: ScalarTypeEnum2.String_unsecure(),
       isArray: true,
       isOptional: true
     }
@@ -357,14 +537,14 @@ import {
   defineCommand,
   defineQuery
 } from "@contractspec/lib.contracts-spec/operations";
-import { defineSchemaModel as defineSchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
-var OWNERS = ["@agent-console-team"];
+import { defineSchemaModel as defineSchemaModel3, ScalarTypeEnum as ScalarTypeEnum3 } from "@contractspec/lib.schema";
+var OWNERS2 = ["@agent-console-team"];
 var CreateToolCommand = defineCommand({
   meta: {
     key: "agent.tool.create",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS],
+    owners: [...OWNERS2],
     tags: ["tool", "create"],
     description: "Creates a new AI tool definition.",
     goal: "Allow users to define new tools that agents can use.",
@@ -372,12 +552,12 @@ var CreateToolCommand = defineCommand({
   },
   io: {
     input: CreateToolInputModel,
-    output: defineSchemaModel2({
+    output: defineSchemaModel3({
       name: "CreateToolOutput",
       fields: {
-        id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-        name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-        slug: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        id: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        name: { type: ScalarTypeEnum3.NonEmptyString(), isOptional: false },
+        slug: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
         status: { type: ToolStatusEnum, isOptional: false }
       }
     }),
@@ -397,7 +577,7 @@ var CreateToolCommand = defineCommand({
         key: "tool.created",
         version: "1.0.0",
         stability: "stable",
-        owners: [...OWNERS],
+        owners: [...OWNERS2],
         tags: ["tool", "created"],
         when: "Tool is successfully created",
         payload: ToolSummaryModel
@@ -444,7 +624,7 @@ var UpdateToolCommand = defineCommand({
     key: "agent.tool.update",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS],
+    owners: [...OWNERS2],
     tags: ["tool", "update"],
     description: "Updates an existing AI tool definition.",
     goal: "Allow users to modify tool settings and configuration.",
@@ -452,13 +632,13 @@ var UpdateToolCommand = defineCommand({
   },
   io: {
     input: UpdateToolInputModel,
-    output: defineSchemaModel2({
+    output: defineSchemaModel3({
       name: "UpdateToolOutput",
       fields: {
-        id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-        name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+        id: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        name: { type: ScalarTypeEnum3.NonEmptyString(), isOptional: false },
         status: { type: ToolStatusEnum, isOptional: false },
-        updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+        updatedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
       }
     }),
     errors: {
@@ -477,7 +657,7 @@ var UpdateToolCommand = defineCommand({
         key: "tool.updated",
         version: "1.0.0",
         stability: "stable",
-        owners: [...OWNERS],
+        owners: [...OWNERS2],
         tags: ["tool", "updated"],
         when: "Tool is updated",
         payload: ToolSummaryModel
@@ -513,17 +693,17 @@ var GetToolQuery = defineQuery({
     key: "agent.tool.get",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS],
+    owners: [...OWNERS2],
     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({
+    input: defineSchemaModel3({
       name: "GetToolInput",
       fields: {
-        toolId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false }
+        toolId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false }
       }
     }),
     output: ToolModel,
@@ -565,41 +745,41 @@ var ListToolsQuery = defineQuery({
     key: "agent.tool.list",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS],
+    owners: [...OWNERS2],
     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({
+    input: defineSchemaModel3({
       name: "ListToolsInput",
       fields: {
         organizationId: {
-          type: ScalarTypeEnum2.String_unsecure(),
+          type: ScalarTypeEnum3.String_unsecure(),
           isOptional: false
         },
         category: { type: ToolCategoryEnum, isOptional: true },
         status: { type: ToolStatusEnum, isOptional: true },
-        search: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+        search: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
         limit: {
-          type: ScalarTypeEnum2.Int_unsecure(),
+          type: ScalarTypeEnum3.Int_unsecure(),
           isOptional: true,
           defaultValue: 20
         },
         offset: {
-          type: ScalarTypeEnum2.Int_unsecure(),
+          type: ScalarTypeEnum3.Int_unsecure(),
           isOptional: true,
           defaultValue: 0
         }
       }
     }),
-    output: defineSchemaModel2({
+    output: defineSchemaModel3({
       name: "ListToolsOutput",
       fields: {
         items: { type: ToolSummaryModel, isArray: true, isOptional: false },
-        total: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
-        hasMore: { type: ScalarTypeEnum2.Boolean(), isOptional: false }
+        total: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum3.Boolean(), isOptional: false }
       }
     })
   },
@@ -627,27 +807,27 @@ var TestToolCommand = defineCommand({
     key: "agent.tool.test",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS],
+    owners: [...OWNERS2],
     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({
+    input: defineSchemaModel3({
       name: "TestToolInput",
       fields: {
-        toolId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-        testInput: { type: ScalarTypeEnum2.JSONObject(), isOptional: false }
+        toolId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        testInput: { type: ScalarTypeEnum3.JSONObject(), isOptional: false }
       }
     }),
-    output: defineSchemaModel2({
+    output: defineSchemaModel3({
       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 }
+        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 }
       }
     }),
     errors: {
@@ -692,190 +872,10 @@ var TestToolCommand = defineCommand({
   }
 });
 
-// src/tool/tool.event.ts
-import { defineEvent } from "@contractspec/lib.contracts-spec";
-import { ScalarTypeEnum as ScalarTypeEnum3, defineSchemaModel as defineSchemaModel3 } 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
+  definePresentation,
+  StabilityEnum
 } from "@contractspec/lib.contracts-spec";
 var ToolListPresentation = definePresentation({
   meta: {