@contractspec/example.agent-console 0.0.0-canary-20260113170453

package/src/tool/tool.entity.ts

@@ -0,0 +1,99 @@
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index,
+} from '@contractspec/lib.schema';
+
+/**
+ * Tool category enum for entities.
+ */
+export const ToolCategoryEntityEnum = defineEntityEnum({
+  name: 'ToolCategory',
+  values: [
+    'RETRIEVAL',
+    'COMPUTATION',
+    'COMMUNICATION',
+    'INTEGRATION',
+    'UTILITY',
+    'CUSTOM',
+  ],
+  description: 'Category of tool',
+});
+
+/**
+ * Tool status enum for entities.
+ */
+export const ToolStatusEntityEnum = defineEntityEnum({
+  name: 'ToolStatus',
+  values: ['DRAFT', 'ACTIVE', 'DEPRECATED', 'DISABLED'],
+  description: 'Status of tool',
+});
+
+/**
+ * Implementation type enum for entities.
+ */
+export const ImplementationTypeEntityEnum = defineEntityEnum({
+  name: 'ImplementationType',
+  values: ['http', 'function', 'workflow'],
+  description: 'How the tool is implemented',
+});
+
+/**
+ * Tool entity - Represents an AI tool definition.
+ */
+export const 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,
+  ],
+});

package/src/tool/tool.enum.ts

@@ -0,0 +1,32 @@
+import { defineEnum } from '@contractspec/lib.schema';
+
+/**
+ * Tool category enum.
+ */
+export const ToolCategoryEnum = defineEnum('ToolCategory', [
+  'RETRIEVAL',
+  'COMPUTATION',
+  'COMMUNICATION',
+  'INTEGRATION',
+  'UTILITY',
+  'CUSTOM',
+]);
+
+/**
+ * Tool status enum.
+ */
+export const ToolStatusEnum = defineEnum('ToolStatus', [
+  'DRAFT',
+  'ACTIVE',
+  'DEPRECATED',
+  'DISABLED',
+]);
+
+/**
+ * Implementation type enum.
+ */
+export const ImplementationTypeEnum = defineEnum('ImplementationType', [
+  'http',
+  'function',
+  'workflow',
+]);

package/src/tool/tool.event.ts

@@ -0,0 +1,119 @@
+import { defineEvent, defineSchemaModel } from '@contractspec/lib.contracts';
+import { ScalarTypeEnum } from '@contractspec/lib.schema';
+
+const OWNERS = ['@agent-console-team'] as const;
+
+/**
+ * Payload for tool created event.
+ */
+const 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.String_unsecure(), 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 },
+  },
+});
+
+/**
+ * ToolCreatedEvent - A new tool was created.
+ */
+export const 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,
+});
+
+/**
+ * Payload for tool updated event.
+ */
+const 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 },
+  },
+});
+
+/**
+ * ToolUpdatedEvent - A tool was updated.
+ */
+export const 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,
+});
+
+/**
+ * Payload for tool status changed event.
+ */
+const 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 },
+  },
+});
+
+/**
+ * ToolStatusChangedEvent - A tool's status was changed.
+ */
+export const 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,
+});

package/src/tool/tool.handler.ts

@@ -0,0 +1,154 @@
+/**
+ * Mock handlers for Tool contracts.
+ */
+import { MOCK_TOOLS } from '../shared/mock-tools';
+
+export interface ListToolsInput {
+  organizationId: string;
+  category?:
+    | 'RETRIEVAL'
+    | 'COMPUTATION'
+    | 'COMMUNICATION'
+    | 'INTEGRATION'
+    | 'UTILITY'
+    | 'CUSTOM';
+  status?: 'DRAFT' | 'ACTIVE' | 'DEPRECATED' | 'DISABLED';
+  search?: string;
+  limit?: number;
+  offset?: number;
+}
+
+export interface ToolSummary {
+  id: string;
+  name: string;
+  slug: string;
+  description: string;
+  category:
+    | 'RETRIEVAL'
+    | 'COMPUTATION'
+    | 'COMMUNICATION'
+    | 'INTEGRATION'
+    | 'UTILITY'
+    | 'CUSTOM';
+  status: 'DRAFT' | 'ACTIVE' | 'DEPRECATED' | 'DISABLED';
+  version: string;
+  createdAt: Date;
+}
+
+export interface ListToolsOutput {
+  items: ToolSummary[];
+  total: number;
+  hasMore: boolean;
+}
+
+/**
+ * Mock handler for ListToolsQuery.
+ */
+export async function mockListToolsHandler(
+  input: ListToolsInput
+): Promise<ListToolsOutput> {
+  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 };
+}
+
+/**
+ * Mock handler for GetToolQuery.
+ */
+export async function mockGetToolHandler(input: { toolId: string }) {
+  const tool = MOCK_TOOLS.find((t) => t.id === input.toolId);
+  if (!tool) throw new Error('TOOL_NOT_FOUND');
+  return tool;
+}
+
+/**
+ * Mock handler for CreateToolCommand.
+ */
+export async function mockCreateToolHandler(input: {
+  organizationId: string;
+  name: string;
+  slug: string;
+  description: string;
+  implementationType: 'http' | 'function' | 'workflow';
+}) {
+  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' as const,
+  };
+}
+
+/**
+ * Mock handler for UpdateToolCommand.
+ */
+export async function mockUpdateToolHandler(input: {
+  toolId: string;
+  name?: string;
+  status?: 'DRAFT' | 'ACTIVE' | 'DEPRECATED' | 'DISABLED';
+}) {
+  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(),
+  };
+}
+
+/**
+ * Mock handler for TestToolCommand.
+ */
+export async function mockTestToolHandler(input: {
+  toolId: string;
+  testInput: Record<string, unknown>;
+}) {
+  const tool = MOCK_TOOLS.find((t) => t.id === input.toolId);
+  if (!tool) throw new Error('TOOL_NOT_FOUND');
+
+  // Simulate tool execution
+  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,
+  };
+}