@lssm/example.agent-console 0.0.0-canary-20251215234153 → 0.0.0-canary-20251216023757

package/src/tool/tool.contracts.ts

@@ -0,0 +1,180 @@
+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';
+
+const OWNERS = ['agent-console-team'] as const;
+
+/**
+ * CreateToolCommand - Creates a new tool definition.
+ */
+export const CreateToolCommand = defineCommand({
+  meta: {
+    name: 'agent.tool.create',
+    version: 1,
+    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: defineSchemaModel({
+      name: 'CreateToolOutput',
+      fields: {
+        id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+        name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+        slug: { type: ScalarTypeEnum.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: [{ name: 'tool.created', version: 1, when: 'Tool is successfully created', payload: ToolSummaryModel }],
+    audit: ['tool.created'],
+  },
+});
+
+/**
+ * UpdateToolCommand - Updates an existing tool.
+ */
+export const UpdateToolCommand = defineCommand({
+  meta: {
+    name: 'agent.tool.update',
+    version: 1,
+    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: defineSchemaModel({
+      name: 'UpdateToolOutput',
+      fields: {
+        id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+        name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+        status: { type: ToolStatusEnum, isOptional: false },
+        updatedAt: { type: ScalarTypeEnum.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: [{ name: 'tool.updated', version: 1, when: 'Tool is updated', payload: ToolSummaryModel }],
+    audit: ['tool.updated'],
+  },
+});
+
+/**
+ * GetToolQuery - Retrieves a tool by ID.
+ */
+export const GetToolQuery = defineQuery({
+  meta: {
+    name: 'agent.tool.get',
+    version: 1,
+    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: 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' } },
+  },
+  policy: { auth: 'user' },
+});
+
+/**
+ * ListToolsQuery - Lists tools for an organization.
+ */
+export const ListToolsQuery = defineQuery({
+  meta: {
+    name: 'agent.tool.list',
+    version: 1,
+    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: defineSchemaModel({
+      name: 'ListToolsInput',
+      fields: {
+        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 },
+      },
+    }),
+    output: defineSchemaModel({
+      name: 'ListToolsOutput',
+      fields: {
+        items: { type: ToolSummaryModel, isArray: true, isOptional: false },
+        total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+      },
+    }),
+  },
+  policy: { auth: 'user' },
+});
+
+/**
+ * TestToolCommand - Tests a tool with sample input.
+ */
+export const TestToolCommand = defineCommand({
+  meta: {
+    name: 'agent.tool.test',
+    version: 1,
+    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: defineSchemaModel({
+      name: 'TestToolInput',
+      fields: {
+        toolId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+        testInput: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
+      },
+    }),
+    output: defineSchemaModel({
+      name: 'TestToolOutput',
+      fields: {
+        success: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+        output: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+        error: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+        durationMs: { type: ScalarTypeEnum.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'] },
+});
+
+

package/src/tool/tool.entity.ts

@@ -0,0 +1,66 @@
+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'],
+  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,34 @@
+import { defineEnum } from '@lssm/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,84 @@
+import { defineEvent, defineSchemaModel } from '@lssm/lib.contracts';
+import { ScalarTypeEnum } from '@lssm/lib.schema';
+
+/**
+ * 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({
+  name: 'agent.tool.created',
+  version: 1,
+  description: 'A new AI tool was 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({
+  name: 'agent.tool.updated',
+  version: 1,
+  description: 'An AI tool configuration was 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({
+  name: 'agent.tool.statusChanged',
+  version: 1,
+  description: 'An AI tool status was changed (activated, deprecated, disabled).',
+  payload: ToolStatusChangedPayload,
+});
+
+

package/src/tool/tool.handler.ts

@@ -0,0 +1,107 @@
+/**
+ * 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 };
+}
+

package/src/{presentations/tool-registry.ts → tool/tool.presentation.ts}

@@ -1,31 +1,26 @@
-/**
- * Tool Registry Presentation Descriptor
- */
 import type { PresentationDescriptorV2 } from '@lssm/lib.contracts';
-import { ToolSummaryModel } from '../contracts/tool';
+import { ToolSummaryModel } from './tool.schema';
 
 /**
- * Presentation for displaying the tool registry.
+ * Presentation for displaying a list of tools.
  */
-export const ToolRegistryPresentation: PresentationDescriptorV2 = {
+export const ToolListPresentation: PresentationDescriptorV2 = {
   meta: {
-    name: 'agent-console.tool.registry',
+    name: 'agent-console.tool.list',
     version: 1,
-    description: 'Registry of available tools organized by category',
+    description: 'List view of AI tools with category, status, and version info',
     domain: 'agent-console',
     owners: ['agent-console-team'],
-    tags: ['tool', 'registry', 'list'],
+    tags: ['tool', 'list', 'dashboard'],
   },
   source: {
     type: 'component',
     framework: 'react',
-    componentKey: 'ToolRegistryView',
+    componentKey: 'ToolListView',
     props: ToolSummaryModel,
   },
   targets: ['react', 'markdown', 'application/json'],
-  policy: {
-    flags: ['agent-console.enabled'],
-  },
+  policy: { flags: ['agent-console.enabled'] },
 };
 
 /**
@@ -35,7 +30,7 @@ export const ToolDetailPresentation: PresentationDescriptorV2 = {
   meta: {
     name: 'agent-console.tool.detail',
     version: 1,
-    description: 'Detailed view of a tool with schema and configuration',
+    description: 'Detailed view of an AI tool with configuration and test panel',
     domain: 'agent-console',
     owners: ['agent-console-team'],
     tags: ['tool', 'detail'],
@@ -46,7 +41,7 @@ export const ToolDetailPresentation: PresentationDescriptorV2 = {
     componentKey: 'ToolDetailView',
   },
   targets: ['react', 'markdown'],
-  policy: {
-    flags: ['agent-console.enabled'],
-  },
+  policy: { flags: ['agent-console.enabled'] },
 };
+
+

package/src/tool/tool.schema.ts

@@ -0,0 +1,134 @@
+import { defineSchemaModel, ScalarTypeEnum } from '@lssm/lib.schema';
+import {
+  ToolCategoryEnum,
+  ToolStatusEnum,
+  ImplementationTypeEnum,
+} from './tool.enum';
+
+/**
+ * AI tool definition.
+ */
+export const 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 },
+  },
+});
+
+/**
+ * Summary of a tool for list views.
+ */
+export const 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 },
+  },
+});
+
+/**
+ * Input for creating a tool.
+ */
+export const 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,
+    },
+  },
+});
+
+/**
+ * Input for updating a tool.
+ */
+export const 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,
+    },
+  },
+});
+