@lssm/example.agent-console 0.0.0-canary-20251215234340 → 0.0.0-canary-20251216024228

package/src/run/run.handler.ts

@@ -0,0 +1,103 @@
+/**
+ * Mock handlers for Run contracts.
+ */
+import { MOCK_RUNS } from '../shared/mock-runs';
+import { MOCK_AGENTS } from '../shared/mock-agents';
+
+export interface ListRunsInput {
+  organizationId?: string;
+  agentId?: string;
+  userId?: string;
+  sessionId?: string;
+  status?: 'QUEUED' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'EXPIRED';
+  startDate?: Date;
+  endDate?: Date;
+  limit?: number;
+  offset?: number;
+}
+
+export interface RunSummary {
+  id: string;
+  agentId: string;
+  agentName: string;
+  status: 'QUEUED' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'EXPIRED';
+  totalTokens: number;
+  durationMs?: number;
+  estimatedCostUsd?: number;
+  queuedAt: Date;
+  completedAt?: Date;
+}
+
+export interface ListRunsOutput {
+  items: RunSummary[];
+  total: number;
+  hasMore: boolean;
+}
+
+/**
+ * Mock handler for ListRunsQuery.
+ */
+export async function mockListRunsHandler(input: ListRunsInput): Promise<ListRunsOutput> {
+  const { agentId, status, limit = 20, offset = 0 } = input;
+
+  let filtered = [...MOCK_RUNS];
+  if (agentId) filtered = filtered.filter((r) => r.agentId === agentId);
+  if (status) filtered = filtered.filter((r) => r.status === status);
+
+  const total = filtered.length;
+  const items = filtered.slice(offset, offset + limit).map((r) => {
+    const agent = MOCK_AGENTS.find((a) => a.id === r.agentId);
+    return {
+      id: r.id,
+      agentId: r.agentId,
+      agentName: agent?.name ?? 'Unknown',
+      status: r.status,
+      totalTokens: r.totalTokens,
+      durationMs: r.durationMs,
+      estimatedCostUsd: r.estimatedCostUsd,
+      queuedAt: r.queuedAt,
+      completedAt: r.completedAt,
+    };
+  });
+
+  return { items, total, hasMore: offset + limit < total };
+}
+
+/**
+ * Mock handler for GetRunQuery.
+ */
+export async function mockGetRunHandler(input: { runId: string; includeSteps?: boolean; includeLogs?: boolean }) {
+  const run = MOCK_RUNS.find((r) => r.id === input.runId);
+  if (!run) throw new Error('RUN_NOT_FOUND');
+
+  const agent = MOCK_AGENTS.find((a) => a.id === run.agentId);
+  return {
+    ...run,
+    agent: agent ? { id: agent.id, name: agent.name, modelProvider: agent.modelProvider, modelName: agent.modelName } : undefined,
+    steps: input.includeSteps ? run.steps : undefined,
+    logs: input.includeLogs ? run.logs : undefined,
+  };
+}
+
+/**
+ * Mock handler for ExecuteAgentCommand.
+ */
+export async function mockExecuteAgentHandler(input: { agentId: string; input: { message: string; context?: Record<string, unknown> } }) {
+  const agent = MOCK_AGENTS.find((a) => a.id === input.agentId);
+  if (!agent) throw new Error('AGENT_NOT_FOUND');
+  if (agent.status !== 'ACTIVE') throw new Error('AGENT_NOT_ACTIVE');
+
+  return { runId: `run-${Date.now()}`, status: 'QUEUED' as const, estimatedWaitMs: 500 };
+}
+
+/**
+ * Mock handler for CancelRunCommand.
+ */
+export async function mockCancelRunHandler(input: { runId: string; reason?: string }) {
+  const run = MOCK_RUNS.find((r) => r.id === input.runId);
+  if (!run) throw new Error('RUN_NOT_FOUND');
+  if (!['QUEUED', 'IN_PROGRESS'].includes(run.status)) throw new Error('RUN_NOT_CANCELLABLE');
+
+  return { success: true, status: 'CANCELLED' as const };
+}
+

package/src/run/run.presentation.ts

@@ -0,0 +1,47 @@
+import type { PresentationDescriptorV2 } from '@lssm/lib.contracts';
+import { RunSummaryModel } from './run.schema';
+
+/**
+ * Presentation for displaying a list of agent runs.
+ */
+export const RunListPresentation: PresentationDescriptorV2 = {
+  meta: {
+    name: 'agent-console.run.list',
+    version: 1,
+    description: 'List view of agent runs with status, tokens, and duration info',
+    domain: 'agent-console',
+    owners: ['agent-console-team'],
+    tags: ['run', 'list', 'dashboard'],
+  },
+  source: {
+    type: 'component',
+    framework: 'react',
+    componentKey: 'RunListView',
+    props: RunSummaryModel,
+  },
+  targets: ['react', 'markdown', 'application/json'],
+  policy: { flags: ['agent-console.enabled'] },
+};
+
+/**
+ * Presentation for run detail view.
+ */
+export const RunDetailPresentation: PresentationDescriptorV2 = {
+  meta: {
+    name: 'agent-console.run.detail',
+    version: 1,
+    description: 'Detailed view of an agent run with steps, logs, and metrics',
+    domain: 'agent-console',
+    owners: ['agent-console-team'],
+    tags: ['run', 'detail'],
+  },
+  source: {
+    type: 'component',
+    framework: 'react',
+    componentKey: 'RunDetailView',
+  },
+  targets: ['react', 'markdown'],
+  policy: { flags: ['agent-console.enabled'] },
+};
+
+

package/src/run/run.schema.ts

@@ -0,0 +1,139 @@
+import { defineSchemaModel, ScalarTypeEnum } from '@lssm/lib.schema';
+import { RunStatusEnum, RunStepTypeEnum, LogLevelEnum } from './run.enum';
+
+/**
+ * Input data for agent execution.
+ */
+export const RunInputModel = defineSchemaModel({
+  name: 'RunInput',
+  description: 'Input data for agent execution',
+  fields: {
+    message: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    context: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+  },
+});
+
+/**
+ * Individual step within a run.
+ */
+export const RunStepModel = defineSchemaModel({
+  name: 'RunStep',
+  description: 'Individual step within a run',
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    stepNumber: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    type: { type: RunStepTypeEnum, isOptional: false },
+    toolId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    toolName: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    input: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    output: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    status: { type: RunStatusEnum, isOptional: false },
+    errorMessage: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    tokensUsed: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false, defaultValue: 0 },
+    durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    startedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+  },
+});
+
+/**
+ * Execution log entry.
+ */
+export const RunLogModel = defineSchemaModel({
+  name: 'RunLog',
+  description: 'Execution log entry',
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    stepId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    level: { type: LogLevelEnum, isOptional: false },
+    message: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    data: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    source: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    traceId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    spanId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    timestamp: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+  },
+});
+
+/**
+ * Agent reference in a run.
+ */
+export const RunAgentRefModel = defineSchemaModel({
+  name: 'RunAgentRef',
+  description: 'Agent reference in a run',
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    modelProvider: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    modelName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+  },
+});
+
+/**
+ * Agent execution instance.
+ */
+export const RunModel = defineSchemaModel({
+  name: 'Run',
+  description: 'Agent execution instance',
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    organizationId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    sessionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    input: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
+    output: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    status: { type: RunStatusEnum, isOptional: false },
+    errorMessage: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    errorCode: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    totalTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false, defaultValue: 0 },
+    promptTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false, defaultValue: 0 },
+    completionTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false, defaultValue: 0 },
+    totalIterations: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false, defaultValue: 0 },
+    durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    estimatedCostUsd: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
+    queuedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    steps: { type: RunStepModel, isArray: true, isOptional: true },
+    logs: { type: RunLogModel, isArray: true, isOptional: true },
+    agent: { type: RunAgentRefModel, isOptional: true },
+  },
+});
+
+/**
+ * Summary of a run for list views.
+ */
+export const RunSummaryModel = defineSchemaModel({
+  name: 'RunSummary',
+  description: 'Summary of a run for list views',
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    agentName: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    status: { type: RunStatusEnum, isOptional: false },
+    totalTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    estimatedCostUsd: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
+    queuedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+  },
+});
+
+/**
+ * Timeline data point for metrics.
+ */
+export const TimelineDataPointModel = defineSchemaModel({
+  name: 'TimelineDataPoint',
+  description: 'Timeline data point for metrics',
+  fields: {
+    period: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    runs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    tokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    costUsd: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+    avgDurationMs: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+  },
+});
+
+

package/src/shared/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared utilities and mock data.
+ */
+export { MOCK_AGENTS } from './mock-agents';
+export { MOCK_TOOLS } from './mock-tools';
+export { MOCK_RUNS } from './mock-runs';

package/src/shared/mock-agents.ts

@@ -0,0 +1,83 @@
+/**
+ * Mock agent data for testing and demos.
+ */
+export const MOCK_AGENTS = [
+  {
+    id: 'agent-1',
+    organizationId: 'demo-org',
+    name: 'Customer Support Bot',
+    slug: 'customer-support-bot',
+    description: 'Handles tier-1 customer inquiries and routes complex issues.',
+    status: 'ACTIVE' as const,
+    modelProvider: 'OPENAI' as const,
+    modelName: 'gpt-4o-mini',
+    modelConfig: { temperature: 0.7 },
+    systemPrompt: 'You are a helpful customer support assistant.',
+    toolChoice: 'auto' as const,
+    maxIterations: 10,
+    timeoutMs: 120000,
+    version: '1.0.0',
+    tags: ['support', 'tier-1'],
+    createdAt: new Date('2024-01-15T10:00:00Z'),
+    updatedAt: new Date('2024-03-20T14:30:00Z'),
+  },
+  {
+    id: 'agent-2',
+    organizationId: 'demo-org',
+    name: 'Code Review Assistant',
+    slug: 'code-review-assistant',
+    description: 'Reviews pull requests and provides actionable feedback.',
+    status: 'ACTIVE' as const,
+    modelProvider: 'ANTHROPIC' as const,
+    modelName: 'claude-sonnet-4-20250514',
+    modelConfig: { temperature: 0.3 },
+    systemPrompt: 'You are a code review expert.',
+    toolChoice: 'auto' as const,
+    maxIterations: 15,
+    timeoutMs: 180000,
+    version: '2.1.0',
+    tags: ['code', 'review', 'dev'],
+    createdAt: new Date('2024-02-10T09:00:00Z'),
+    updatedAt: new Date('2024-04-05T11:15:00Z'),
+  },
+  {
+    id: 'agent-3',
+    organizationId: 'demo-org',
+    name: 'Data Analyst',
+    slug: 'data-analyst',
+    description: 'Queries databases and generates insights from data.',
+    status: 'PAUSED' as const,
+    modelProvider: 'OPENAI' as const,
+    modelName: 'gpt-4o',
+    modelConfig: { temperature: 0.5 },
+    systemPrompt: 'You are a data analyst expert in SQL and analytics.',
+    toolChoice: 'required' as const,
+    maxIterations: 20,
+    timeoutMs: 300000,
+    version: '1.2.0',
+    tags: ['data', 'analytics', 'sql'],
+    createdAt: new Date('2024-03-01T08:00:00Z'),
+    updatedAt: new Date('2024-04-10T16:45:00Z'),
+  },
+  {
+    id: 'agent-4',
+    organizationId: 'demo-org',
+    name: 'Meeting Scheduler',
+    slug: 'meeting-scheduler',
+    description: 'Schedules meetings and manages calendar conflicts.',
+    status: 'DRAFT' as const,
+    modelProvider: 'GOOGLE' as const,
+    modelName: 'gemini-2.0-flash',
+    modelConfig: { temperature: 0.2 },
+    systemPrompt: 'You help schedule and organize meetings efficiently.',
+    toolChoice: 'auto' as const,
+    maxIterations: 5,
+    timeoutMs: 60000,
+    version: '0.1.0',
+    tags: ['calendar', 'scheduling'],
+    createdAt: new Date('2024-04-01T12:00:00Z'),
+    updatedAt: new Date('2024-04-01T12:00:00Z'),
+  },
+];
+
+

package/src/shared/mock-runs.ts

@@ -0,0 +1,108 @@
+/**
+ * Mock run data for testing and demos.
+ */
+export const MOCK_RUNS = [
+  {
+    id: 'run-1',
+    organizationId: 'demo-org',
+    agentId: 'agent-1',
+    agentName: 'Customer Support Bot',
+    userId: 'user-1',
+    sessionId: 'session-1',
+    input: { message: 'How do I reset my password?', context: {} },
+    output: { response: 'You can reset your password by clicking...' },
+    status: 'COMPLETED' as const,
+    totalTokens: 1250,
+    promptTokens: 800,
+    completionTokens: 450,
+    totalIterations: 3,
+    durationMs: 4500,
+    estimatedCostUsd: 0.0025,
+    queuedAt: new Date('2024-04-15T10:00:00Z'),
+    startedAt: new Date('2024-04-15T10:00:01Z'),
+    completedAt: new Date('2024-04-15T10:00:05Z'),
+    steps: [],
+    logs: [],
+  },
+  {
+    id: 'run-2',
+    organizationId: 'demo-org',
+    agentId: 'agent-2',
+    agentName: 'Code Review Assistant',
+    userId: 'user-2',
+    input: { message: 'Review PR #123', context: { prNumber: 123 } },
+    status: 'IN_PROGRESS' as const,
+    totalTokens: 3500,
+    promptTokens: 3000,
+    completionTokens: 500,
+    totalIterations: 5,
+    queuedAt: new Date('2024-04-15T10:30:00Z'),
+    startedAt: new Date('2024-04-15T10:30:02Z'),
+    steps: [],
+    logs: [],
+  },
+  {
+    id: 'run-3',
+    organizationId: 'demo-org',
+    agentId: 'agent-1',
+    agentName: 'Customer Support Bot',
+    userId: 'user-1',
+    input: { message: 'What are your business hours?' },
+    output: { response: 'Our business hours are 9 AM to 5 PM EST...' },
+    status: 'COMPLETED' as const,
+    totalTokens: 800,
+    promptTokens: 500,
+    completionTokens: 300,
+    totalIterations: 2,
+    durationMs: 2100,
+    estimatedCostUsd: 0.0012,
+    queuedAt: new Date('2024-04-15T09:00:00Z'),
+    startedAt: new Date('2024-04-15T09:00:01Z'),
+    completedAt: new Date('2024-04-15T09:00:03Z'),
+    steps: [],
+    logs: [],
+  },
+  {
+    id: 'run-4',
+    organizationId: 'demo-org',
+    agentId: 'agent-3',
+    agentName: 'Data Analyst',
+    userId: 'user-3',
+    input: { message: 'Generate sales report for Q1' },
+    status: 'FAILED' as const,
+    errorMessage: 'Database connection timeout',
+    errorCode: 'DB_TIMEOUT',
+    totalTokens: 2000,
+    promptTokens: 1500,
+    completionTokens: 500,
+    totalIterations: 8,
+    durationMs: 45000,
+    queuedAt: new Date('2024-04-14T15:00:00Z'),
+    startedAt: new Date('2024-04-14T15:00:05Z'),
+    completedAt: new Date('2024-04-14T15:00:50Z'),
+    steps: [],
+    logs: [],
+  },
+  {
+    id: 'run-5',
+    organizationId: 'demo-org',
+    agentId: 'agent-2',
+    agentName: 'Code Review Assistant',
+    userId: 'user-2',
+    input: { message: 'Review PR #120' },
+    output: { response: 'Code review complete. 3 suggestions...' },
+    status: 'COMPLETED' as const,
+    totalTokens: 5200,
+    promptTokens: 4000,
+    completionTokens: 1200,
+    totalIterations: 7,
+    durationMs: 15000,
+    estimatedCostUsd: 0.0156,
+    queuedAt: new Date('2024-04-14T11:00:00Z'),
+    startedAt: new Date('2024-04-14T11:00:03Z'),
+    completedAt: new Date('2024-04-14T11:00:18Z'),
+    steps: [],
+    logs: [],
+  },
+];
+

package/src/shared/mock-tools.ts

@@ -0,0 +1,146 @@
+/**
+ * Mock tool data for testing and demos.
+ */
+export const MOCK_TOOLS = [
+  {
+    id: 'tool-1',
+    organizationId: 'demo-org',
+    name: 'Web Search',
+    slug: 'web-search',
+    description: 'Search the web for real-time information using Brave API.',
+    category: 'RETRIEVAL' as const,
+    status: 'ACTIVE' as const,
+    parametersSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        numResults: { type: 'number', default: 10 },
+      },
+      required: ['query'],
+    },
+    outputSchema: { type: 'array', items: { type: 'object' } },
+    implementationType: 'http' as const,
+    implementationConfig: {
+      url: 'https://api.brave.com/search',
+      method: 'GET',
+    },
+    maxInvocationsPerMinute: 60,
+    timeoutMs: 30000,
+    version: '1.0.0',
+    tags: ['search', 'web'],
+    createdAt: new Date('2024-01-01T00:00:00Z'),
+    updatedAt: new Date('2024-02-15T10:00:00Z'),
+  },
+  {
+    id: 'tool-2',
+    organizationId: 'demo-org',
+    name: 'SQL Query',
+    slug: 'sql-query',
+    description: 'Execute read-only SQL queries against the data warehouse.',
+    category: 'RETRIEVAL' as const,
+    status: 'ACTIVE' as const,
+    parametersSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'SQL query' },
+        maxRows: { type: 'number', default: 100 },
+      },
+      required: ['query'],
+    },
+    outputSchema: { type: 'object' },
+    implementationType: 'function' as const,
+    implementationConfig: { handler: 'executeSqlQuery' },
+    maxInvocationsPerMinute: 30,
+    timeoutMs: 60000,
+    version: '1.1.0',
+    tags: ['sql', 'database'],
+    createdAt: new Date('2024-01-05T00:00:00Z'),
+    updatedAt: new Date('2024-03-10T14:00:00Z'),
+  },
+  {
+    id: 'tool-3',
+    organizationId: 'demo-org',
+    name: 'Email Sender',
+    slug: 'email-sender',
+    description: 'Send emails via SMTP or API.',
+    category: 'COMMUNICATION' as const,
+    status: 'ACTIVE' as const,
+    parametersSchema: {
+      type: 'object',
+      properties: {
+        to: { type: 'string' },
+        subject: { type: 'string' },
+        body: { type: 'string' },
+      },
+      required: ['to', 'subject', 'body'],
+    },
+    implementationType: 'http' as const,
+    implementationConfig: { url: '/api/send-email', method: 'POST' },
+    maxInvocationsPerMinute: 10,
+    timeoutMs: 30000,
+    version: '1.0.0',
+    tags: ['email', 'communication'],
+    createdAt: new Date('2024-02-01T00:00:00Z'),
+    updatedAt: new Date('2024-02-01T00:00:00Z'),
+  },
+  {
+    id: 'tool-4',
+    organizationId: 'demo-org',
+    name: 'GitHub Integration',
+    slug: 'github-integration',
+    description: 'Interact with GitHub repositories, PRs, and issues.',
+    category: 'INTEGRATION' as const,
+    status: 'ACTIVE' as const,
+    parametersSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['list_prs', 'get_pr', 'create_comment'],
+        },
+        repo: { type: 'string' },
+        params: { type: 'object' },
+      },
+      required: ['action', 'repo'],
+    },
+    implementationType: 'http' as const,
+    implementationConfig: { url: 'https://api.github.com', auth: 'token' },
+    maxInvocationsPerMinute: 100,
+    timeoutMs: 15000,
+    version: '2.0.0',
+    tags: ['github', 'integration', 'code'],
+    createdAt: new Date('2024-02-20T00:00:00Z'),
+    updatedAt: new Date('2024-04-01T09:00:00Z'),
+  },
+  {
+    id: 'tool-5',
+    organizationId: 'demo-org',
+    name: 'Calculator',
+    slug: 'calculator',
+    description: 'Perform mathematical calculations.',
+    category: 'COMPUTATION' as const,
+    status: 'ACTIVE' as const,
+    parametersSchema: {
+      type: 'object',
+      properties: {
+        expression: {
+          type: 'string',
+          description: 'Math expression to evaluate',
+        },
+      },
+      required: ['expression'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: { result: { type: 'number' } },
+    },
+    implementationType: 'function' as const,
+    implementationConfig: { handler: 'evaluateMath' },
+    timeoutMs: 5000,
+    version: '1.0.0',
+    tags: ['math', 'utility'],
+    createdAt: new Date('2024-01-10T00:00:00Z'),
+    updatedAt: new Date('2024-01-10T00:00:00Z'),
+  },
+];
+

package/src/tool/index.ts

@@ -0,0 +1,35 @@
+/**
+ * Tool domain - AI tool definitions and management.
+ */
+
+// Enums
+export { ToolCategoryEnum, ToolStatusEnum, ImplementationTypeEnum } from './tool.enum';
+
+// Schema models
+export { ToolModel, ToolSummaryModel, CreateToolInputModel, UpdateToolInputModel } from './tool.schema';
+
+// Contracts
+export { CreateToolCommand, UpdateToolCommand, GetToolQuery, ListToolsQuery, TestToolCommand } from './tool.contracts';
+
+// Events
+export { ToolCreatedEvent, ToolUpdatedEvent, ToolStatusChangedEvent } from './tool.event';
+
+// Entities
+export { ToolCategoryEntityEnum, ToolStatusEntityEnum, ImplementationTypeEntityEnum, ToolEntity } from './tool.entity';
+
+// Presentations
+export { ToolListPresentation, ToolDetailPresentation } from './tool.presentation';
+
+// Handlers
+export {
+  mockListToolsHandler,
+  mockGetToolHandler,
+  mockCreateToolHandler,
+  mockUpdateToolHandler,
+  mockTestToolHandler,
+  type ListToolsInput,
+  type ToolSummary,
+  type ListToolsOutput,
+} from './tool.handler';
+
+