@lssm/example.agent-console 0.0.0-canary-20251216031832 → 0.0.0-canary-20251216033905

package/src/shared/mock-tools.ts

@@ -143,4 +143,3 @@ export const MOCK_TOOLS = [
     updatedAt: new Date('2024-01-10T00:00:00Z'),
   },
 ];
-

package/src/tool/index.ts

@@ -3,22 +3,49 @@
  */
 
 // Enums
-export { ToolCategoryEnum, ToolStatusEnum, ImplementationTypeEnum } from './tool.enum';
+export {
+  ToolCategoryEnum,
+  ToolStatusEnum,
+  ImplementationTypeEnum,
+} from './tool.enum';
 
 // Schema models
-export { ToolModel, ToolSummaryModel, CreateToolInputModel, UpdateToolInputModel } from './tool.schema';
+export {
+  ToolModel,
+  ToolSummaryModel,
+  CreateToolInputModel,
+  UpdateToolInputModel,
+} from './tool.schema';
 
 // Contracts
-export { CreateToolCommand, UpdateToolCommand, GetToolQuery, ListToolsQuery, TestToolCommand } from './tool.contracts';
+export {
+  CreateToolCommand,
+  UpdateToolCommand,
+  GetToolQuery,
+  ListToolsQuery,
+  TestToolCommand,
+} from './tool.contracts';
 
 // Events
-export { ToolCreatedEvent, ToolUpdatedEvent, ToolStatusChangedEvent } from './tool.event';
+export {
+  ToolCreatedEvent,
+  ToolUpdatedEvent,
+  ToolStatusChangedEvent,
+} from './tool.event';
 
 // Entities
-export { ToolCategoryEntityEnum, ToolStatusEntityEnum, ImplementationTypeEntityEnum, ToolEntity } from './tool.entity';
+export {
+  ToolCategoryEntityEnum,
+  ToolStatusEntityEnum,
+  ImplementationTypeEntityEnum,
+  ToolEntity,
+} from './tool.entity';
 
 // Presentations
-export { ToolListPresentation, ToolDetailPresentation } from './tool.presentation';
+export {
+  ToolListPresentation,
+  ToolDetailPresentation,
+} from './tool.presentation';
 
 // Handlers
 export {
@@ -31,5 +58,3 @@ export {
   type ToolSummary,
   type ListToolsOutput,
 } from './tool.handler';
-
-

package/src/tool/tool.contracts.ts

@@ -1,7 +1,12 @@
 import { defineCommand, defineQuery } from '@lssm/lib.contracts/spec';
 import { defineSchemaModel, ScalarTypeEnum } from '@lssm/lib.schema';
 import { ToolCategoryEnum, ToolStatusEnum } from './tool.enum';
-import { ToolModel, ToolSummaryModel, CreateToolInputModel, UpdateToolInputModel } from './tool.schema';
+import {
+  ToolModel,
+  ToolSummaryModel,
+  CreateToolInputModel,
+  UpdateToolInputModel,
+} from './tool.schema';
 
 const OWNERS = ['agent-console-team'] as const;
 
@@ -31,12 +36,24 @@ export const CreateToolCommand = defineCommand({
       },
     }),
     errors: {
-      SLUG_EXISTS: { description: 'A tool with this slug already exists in the organization', http: 409, gqlCode: 'SLUG_EXISTS', when: 'Slug is already taken' },
+      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: [{ name: 'tool.created', version: 1, when: 'Tool is successfully created', payload: ToolSummaryModel }],
+    emits: [
+      {
+        name: 'tool.created',
+        version: 1,
+        when: 'Tool is successfully created',
+        payload: ToolSummaryModel,
+      },
+    ],
     audit: ['tool.created'],
   },
 });
@@ -67,12 +84,24 @@ export const UpdateToolCommand = defineCommand({
       },
     }),
     errors: {
-      TOOL_NOT_FOUND: { description: 'The specified tool does not exist', http: 404, gqlCode: 'TOOL_NOT_FOUND', when: 'Tool ID is invalid' },
+      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: [{ name: 'tool.updated', version: 1, when: 'Tool is updated', payload: ToolSummaryModel }],
+    emits: [
+      {
+        name: 'tool.updated',
+        version: 1,
+        when: 'Tool is updated',
+        payload: ToolSummaryModel,
+      },
+    ],
     audit: ['tool.updated'],
   },
 });
@@ -92,9 +121,21 @@ export const GetToolQuery = defineQuery({
     context: 'Called when viewing tool details or editing.',
   },
   io: {
-    input: defineSchemaModel({ name: 'GetToolInput', fields: { toolId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false } } }),
+    input: defineSchemaModel({
+      name: 'GetToolInput',
+      fields: {
+        toolId: { type: ScalarTypeEnum.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' } },
+    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' },
 });
@@ -117,12 +158,23 @@ export const ListToolsQuery = defineQuery({
     input: defineSchemaModel({
       name: 'ListToolsInput',
       fields: {
-        organizationId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+        organizationId: {
+          type: ScalarTypeEnum.String_unsecure(),
+          isOptional: false,
+        },
         category: { type: ToolCategoryEnum, isOptional: true },
         status: { type: ToolStatusEnum, isOptional: true },
         search: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-        limit: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true, defaultValue: 20 },
-        offset: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true, defaultValue: 0 },
+        limit: {
+          type: ScalarTypeEnum.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 20,
+        },
+        offset: {
+          type: ScalarTypeEnum.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0,
+        },
       },
     }),
     output: defineSchemaModel({
@@ -169,12 +221,20 @@ export const TestToolCommand = defineCommand({
       },
     }),
     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' },
+      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'] },
 });
-
-

package/src/tool/tool.entity.ts

@@ -1,11 +1,23 @@
-import { defineEntity, defineEntityEnum, field, index } from '@lssm/lib.schema/entity';
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index,
+} from '@lssm/lib.schema/entity';
 
 /**
  * Tool category enum for entities.
  */
 export const ToolCategoryEntityEnum = defineEntityEnum({
   name: 'ToolCategory',
-  values: ['RETRIEVAL', 'COMPUTATION', 'COMMUNICATION', 'INTEGRATION', 'UTILITY', 'CUSTOM'],
+  values: [
+    'RETRIEVAL',
+    'COMPUTATION',
+    'COMMUNICATION',
+    'INTEGRATION',
+    'UTILITY',
+    'CUSTOM',
+  ],
   description: 'Category of tool',
 });
 
@@ -36,23 +48,42 @@ export const ToolEntity = defineEntity({
   description: 'An AI tool that can be used by agents.',
   fields: {
     id: field.id(),
-    organizationId: field.string({ description: 'Organization that owns this tool' }),
+    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' }),
+    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' }),
+    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' }),
+    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' }),
+    createdById: field.string({
+      isOptional: true,
+      description: 'User who created this tool',
+    }),
     agents: field.hasMany('Agent', { description: 'Agents using this tool' }),
   },
   indexes: [
@@ -60,7 +91,9 @@ export const ToolEntity = defineEntity({
     index.on(['organizationId', 'category']),
     index.on(['organizationId', 'status']),
   ],
-  enums: [ToolCategoryEntityEnum, ToolStatusEntityEnum, ImplementationTypeEntityEnum],
+  enums: [
+    ToolCategoryEntityEnum,
+    ToolStatusEntityEnum,
+    ImplementationTypeEntityEnum,
+  ],
 });
-
-

package/src/tool/tool.enum.ts

@@ -30,5 +30,3 @@ export const ImplementationTypeEnum = defineEnum('ImplementationType', [
   'function',
   'workflow',
 ]);
-
-

package/src/tool/tool.event.ts

@@ -9,11 +9,17 @@ const ToolCreatedPayload = defineSchemaModel({
   description: 'Payload for tool created event',
   fields: {
     id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: { 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 },
+    implementationType: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false,
+    },
     createdById: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
     createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
   },
@@ -37,10 +43,17 @@ const ToolUpdatedPayload = defineSchemaModel({
   description: 'Payload for tool updated event',
   fields: {
     id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: { 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 },
+    updatedFields: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isArray: true,
+      isOptional: false,
+    },
     updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
   },
 });
@@ -63,9 +76,15 @@ const ToolStatusChangedPayload = defineSchemaModel({
   description: 'Payload for tool status changed event',
   fields: {
     id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: { 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 },
+    previousStatus: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false,
+    },
     newStatus: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
     changedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
   },
@@ -77,8 +96,7 @@ const ToolStatusChangedPayload = defineSchemaModel({
 export const ToolStatusChangedEvent = defineEvent({
   name: 'agent.tool.statusChanged',
   version: 1,
-  description: 'An AI tool status was changed (activated, deprecated, disabled).',
+  description:
+    'An AI tool status was changed (activated, deprecated, disabled).',
   payload: ToolStatusChangedPayload,
 });
-
-

package/src/tool/tool.handler.ts

@@ -5,7 +5,13 @@ import { MOCK_TOOLS } from '../shared/mock-tools';
 
 export interface ListToolsInput {
   organizationId: string;
-  category?: 'RETRIEVAL' | 'COMPUTATION' | 'COMMUNICATION' | 'INTEGRATION' | 'UTILITY' | 'CUSTOM';
+  category?:
+    | 'RETRIEVAL'
+    | 'COMPUTATION'
+    | 'COMMUNICATION'
+    | 'INTEGRATION'
+    | 'UTILITY'
+    | 'CUSTOM';
   status?: 'DRAFT' | 'ACTIVE' | 'DEPRECATED' | 'DISABLED';
   search?: string;
   limit?: number;
@@ -17,7 +23,13 @@ export interface ToolSummary {
   name: string;
   slug: string;
   description: string;
-  category: 'RETRIEVAL' | 'COMPUTATION' | 'COMMUNICATION' | 'INTEGRATION' | 'UTILITY' | 'CUSTOM';
+  category:
+    | 'RETRIEVAL'
+    | 'COMPUTATION'
+    | 'COMMUNICATION'
+    | 'INTEGRATION'
+    | 'UTILITY'
+    | 'CUSTOM';
   status: 'DRAFT' | 'ACTIVE' | 'DEPRECATED' | 'DISABLED';
   version: string;
   createdAt: Date;
@@ -32,15 +44,28 @@ export interface ListToolsOutput {
 /**
  * Mock handler for ListToolsQuery.
  */
-export async function mockListToolsHandler(input: ListToolsInput): Promise<ListToolsOutput> {
-  const { organizationId, category, status, search, limit = 20, offset = 0 } = input;
+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));
+    filtered = filtered.filter(
+      (t) =>
+        t.name.toLowerCase().includes(q) ||
+        t.description.toLowerCase().includes(q)
+    );
   }
 
   const total = filtered.length;
@@ -77,24 +102,43 @@ export async function mockCreateToolHandler(input: {
   description: string;
   implementationType: 'http' | 'function' | 'workflow';
 }) {
-  const exists = MOCK_TOOLS.some((t) => t.organizationId === input.organizationId && t.slug === input.slug);
+  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 };
+  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' }) {
+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() };
+  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> }) {
+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');
 
@@ -102,6 +146,9 @@ export async function mockTestToolHandler(input: { toolId: string; testInput: Re
   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 };
+  return {
+    success: true,
+    output: { result: 'Test successful', input: input.testInput },
+    durationMs: Date.now() - startTime,
+  };
 }
-

package/src/tool/tool.presentation.ts

@@ -8,7 +8,8 @@ export const ToolListPresentation: PresentationDescriptorV2 = {
   meta: {
     name: 'agent-console.tool.list',
     version: 1,
-    description: 'List view of AI tools with category, status, and version info',
+    description:
+      'List view of AI tools with category, status, and version info',
     domain: 'agent-console',
     owners: ['agent-console-team'],
     tags: ['tool', 'list', 'dashboard'],
@@ -30,7 +31,8 @@ export const ToolDetailPresentation: PresentationDescriptorV2 = {
   meta: {
     name: 'agent-console.tool.detail',
     version: 1,
-    description: 'Detailed view of an AI tool with configuration and test panel',
+    description:
+      'Detailed view of an AI tool with configuration and test panel',
     domain: 'agent-console',
     owners: ['agent-console-team'],
     tags: ['tool', 'detail'],
@@ -43,5 +45,3 @@ export const ToolDetailPresentation: PresentationDescriptorV2 = {
   targets: ['react', 'markdown'],
   policy: { flags: ['agent-console.enabled'] },
 };
-
-

package/src/tool/tool.schema.ts

@@ -131,4 +131,3 @@ export const UpdateToolInputModel = defineSchemaModel({
     },
   },
 });
-