@lssm/example.agent-console 0.0.0-canary-20251206160926

package/src/handlers/run.handlers.ts

@@ -0,0 +1,331 @@
+/**
+ * Mock handlers for Run contracts
+ */
+import { MOCK_RUNS, MOCK_RUN_STEPS, MOCK_RUN_LOGS } from './mock-data';
+
+// Types inferred from contract schemas
+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;
+}
+
+export interface GetRunInput {
+  runId: string;
+  includeSteps?: boolean;
+  includeLogs?: boolean;
+}
+
+export interface Run {
+  id: string;
+  organizationId: string;
+  agentId: string;
+  userId?: string;
+  sessionId?: string;
+  input: Record<string, unknown>;
+  output?: Record<string, unknown>;
+  status:
+    | 'QUEUED'
+    | 'IN_PROGRESS'
+    | 'COMPLETED'
+    | 'FAILED'
+    | 'CANCELLED'
+    | 'EXPIRED';
+  errorMessage?: string;
+  errorCode?: string;
+  totalTokens: number;
+  promptTokens: number;
+  completionTokens: number;
+  totalIterations: number;
+  durationMs?: number;
+  estimatedCostUsd?: number;
+  queuedAt: Date;
+  startedAt?: Date;
+  completedAt?: Date;
+  metadata?: Record<string, unknown>;
+  steps?: RunStep[];
+  logs?: RunLog[];
+}
+
+export interface RunStep {
+  id: string;
+  stepNumber: number;
+  type: 'MESSAGE_CREATION' | 'TOOL_CALL' | 'TOOL_RESULT' | 'ERROR';
+  toolId?: string;
+  toolName?: string;
+  input?: Record<string, unknown>;
+  output?: Record<string, unknown>;
+  status:
+    | 'QUEUED'
+    | 'IN_PROGRESS'
+    | 'COMPLETED'
+    | 'FAILED'
+    | 'CANCELLED'
+    | 'EXPIRED';
+  errorMessage?: string;
+  tokensUsed: number;
+  durationMs?: number;
+  startedAt: Date;
+  completedAt?: Date;
+}
+
+export interface RunLog {
+  id: string;
+  stepId?: string;
+  level: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+  message: string;
+  data?: Record<string, unknown>;
+  source?: string;
+  traceId?: string;
+  spanId?: string;
+  timestamp: Date;
+}
+
+export interface GetRunMetricsInput {
+  organizationId: string;
+  agentId?: string;
+  startDate: Date;
+  endDate: Date;
+  granularity?: 'hour' | 'day' | 'week' | 'month';
+}
+
+export interface TimelineDataPoint {
+  period: string;
+  runs: number;
+  tokens: number;
+  costUsd: number;
+  avgDurationMs: number;
+}
+
+export interface RunMetrics {
+  totalRuns: number;
+  completedRuns: number;
+  failedRuns: number;
+  totalTokens: number;
+  totalCostUsd: number;
+  averageDurationMs: number;
+  successRate: number;
+  timeline: TimelineDataPoint[];
+}
+
+/**
+ * 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);
+  }
+
+  // Sort by queuedAt descending
+  filtered.sort((a, b) => b.queuedAt.getTime() - a.queuedAt.getTime());
+
+  const total = filtered.length;
+  const items = filtered.slice(offset, offset + limit).map((r) => ({
+    id: r.id,
+    agentId: r.agentId,
+    agentName: r.agentName,
+    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: GetRunInput): Promise<Run> {
+  const run = MOCK_RUNS.find((r) => r.id === input.runId);
+
+  if (!run) {
+    throw new Error('RUN_NOT_FOUND');
+  }
+
+  const result: Run = {
+    ...run,
+    promptTokens: run.promptTokens ?? 0,
+    completionTokens: run.completionTokens ?? 0,
+    totalIterations: run.totalIterations ?? 0,
+  };
+
+  if (input.includeSteps) {
+    result.steps = MOCK_RUN_STEPS.filter((s) => s.runId === input.runId).map(
+      (s) => ({
+        id: s.id,
+        stepNumber: s.stepNumber,
+        type: s.type,
+        toolId: s.toolId,
+        toolName: s.toolName,
+        input: s.input,
+        output: s.output,
+        status: s.status,
+        errorMessage: undefined,
+        tokensUsed: s.tokensUsed,
+        durationMs: s.durationMs,
+        startedAt: s.startedAt,
+        completedAt: s.completedAt,
+      })
+    );
+  }
+
+  if (input.includeLogs) {
+    result.logs = MOCK_RUN_LOGS.filter((l) => l.runId === input.runId).map(
+      (l) => ({
+        id: l.id,
+        stepId: l.stepId,
+        level: l.level,
+        message: l.message,
+        data: l.data,
+        source: l.source,
+        timestamp: l.timestamp,
+      })
+    );
+  }
+
+  return result;
+}
+
+/**
+ * Mock handler for GetRunMetricsQuery
+ */
+export async function mockGetRunMetricsHandler(
+  input: GetRunMetricsInput
+): Promise<RunMetrics> {
+  const { agentId } = input;
+
+  let runs = [...MOCK_RUNS];
+  if (agentId) {
+    runs = runs.filter((r) => r.agentId === agentId);
+  }
+
+  const completed = runs.filter((r) => r.status === 'COMPLETED');
+  const failed = runs.filter((r) => r.status === 'FAILED');
+
+  const totalTokens = runs.reduce((sum, r) => sum + r.totalTokens, 0);
+  const totalCost = runs.reduce((sum, r) => sum + (r.estimatedCostUsd ?? 0), 0);
+  const avgDuration =
+    completed.length > 0
+      ? completed.reduce((sum, r) => sum + (r.durationMs ?? 0), 0) /
+        completed.length
+      : 0;
+
+  // Generate mock timeline
+  const timeline: TimelineDataPoint[] = [
+    {
+      period: '2024-04-14',
+      runs: 2,
+      tokens: 7200,
+      costUsd: 0.0168,
+      avgDurationMs: 30000,
+    },
+    {
+      period: '2024-04-15',
+      runs: 3,
+      tokens: 5550,
+      costUsd: 0.0137,
+      avgDurationMs: 3600,
+    },
+  ];
+
+  return {
+    totalRuns: runs.length,
+    completedRuns: completed.length,
+    failedRuns: failed.length,
+    totalTokens,
+    totalCostUsd: totalCost,
+    averageDurationMs: avgDuration,
+    successRate: runs.length > 0 ? completed.length / runs.length : 0,
+    timeline,
+  };
+}
+
+/**
+ * Mock handler for ExecuteAgentCommand
+ */
+export async function mockExecuteAgentHandler(input: {
+  agentId: string;
+  input: { message: string; context?: Record<string, unknown> };
+}) {
+  // Simulate queuing a run
+  return {
+    runId: `run-${Date.now()}`,
+    status: 'QUEUED' as const,
+    estimatedWaitMs: 2000,
+  };
+}
+
+/**
+ * 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/handlers/tool.handlers.ts

@@ -0,0 +1,188 @@
+/**
+ * Mock handlers for Tool contracts
+ */
+import { MOCK_TOOLS } from './mock-data';
+
+// Types inferred from contract schemas
+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;
+}
+
+export interface GetToolInput {
+  toolId: string;
+}
+
+export interface Tool {
+  id: string;
+  organizationId: string;
+  name: string;
+  slug: string;
+  description: string;
+  category:
+    | 'RETRIEVAL'
+    | 'COMPUTATION'
+    | 'COMMUNICATION'
+    | 'INTEGRATION'
+    | 'UTILITY'
+    | 'CUSTOM';
+  status: 'DRAFT' | 'ACTIVE' | 'DEPRECATED' | 'DISABLED';
+  parametersSchema: Record<string, unknown>;
+  outputSchema?: Record<string, unknown>;
+  implementationType: 'http' | 'function' | 'workflow';
+  implementationConfig: Record<string, unknown>;
+  maxInvocationsPerMinute?: number;
+  timeoutMs: number;
+  version: string;
+  tags?: string[];
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * 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) ||
+        t.tags?.some((tag) => tag.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: GetToolInput): Promise<Tool> {
+  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;
+  parametersSchema: Record<string, unknown>;
+  implementationType: 'http' | 'function' | 'workflow';
+  implementationConfig: Record<string, unknown>;
+}) {
+  // Simulate slug collision check
+  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 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
+  return {
+    success: true,
+    output: { result: 'Mock tool execution result' },
+    durationMs: Math.floor(Math.random() * 1000) + 100,
+  };
+}

package/src/index.ts

@@ -0,0 +1,34 @@
+/**
+ * Agent Console Example
+ *
+ * A ContractSpec example demonstrating AI agent orchestration with tools, runs, and logs.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   ToolEntity,
+ *   AgentEntity,
+ *   RunEntity,
+ *   CreateToolCommand,
+ *   ExecuteAgentCommand
+ * } from '@lssm/example.agent-console';
+ * ```
+ */
+
+// Entity exports
+export * from './entities';
+
+// Contract exports
+export * from './contracts';
+
+// Event exports
+export * from './events';
+
+// Handler exports (for sandbox/demo use)
+export * from './handlers';
+
+// Presentation exports
+export * from './presentations';
+
+// Feature spec export
+export * from './feature';

package/src/presentations/agent-list.ts

@@ -0,0 +1,55 @@
+/**
+ * Agent List Presentation Descriptor
+ */
+import type { PresentationDescriptorV2 } from '@lssm/lib.contracts';
+import { AgentSummaryModel } from '../contracts/agent';
+
+/**
+ * Presentation for displaying a list of AI agents.
+ * Supports both React (DataTable) and Markdown (list) rendering.
+ */
+export const AgentListPresentation: PresentationDescriptorV2 = {
+  meta: {
+    name: 'agent-console.agent.list',
+    version: 1,
+    description:
+      'List view of AI agents with status, model provider, and version info',
+    domain: 'agent-console',
+    owners: ['agent-console-team'],
+    tags: ['agent', 'list', 'dashboard'],
+  },
+  source: {
+    type: 'component',
+    framework: 'react',
+    componentKey: 'AgentListView',
+    props: AgentSummaryModel,
+  },
+  targets: ['react', 'markdown', 'application/json'],
+  policy: {
+    flags: ['agent-console.enabled'],
+  },
+};
+
+/**
+ * Presentation for agent detail view.
+ */
+export const AgentDetailPresentation: PresentationDescriptorV2 = {
+  meta: {
+    name: 'agent-console.agent.detail',
+    version: 1,
+    description:
+      'Detailed view of an AI agent with configuration, tools, and recent runs',
+    domain: 'agent-console',
+    owners: ['agent-console-team'],
+    tags: ['agent', 'detail'],
+  },
+  source: {
+    type: 'component',
+    framework: 'react',
+    componentKey: 'AgentDetailView',
+  },
+  targets: ['react', 'markdown'],
+  policy: {
+    flags: ['agent-console.enabled'],
+  },
+};

package/src/presentations/dashboard.ts

@@ -0,0 +1,29 @@
+/**
+ * Agent Console Dashboard Presentation Descriptor
+ */
+import type { PresentationDescriptorV2 } from '@lssm/lib.contracts';
+
+/**
+ * Main dashboard presentation for the agent console.
+ * Combines agent stats, recent runs, and tool overview.
+ */
+export const AgentConsoleDashboardPresentation: PresentationDescriptorV2 = {
+  meta: {
+    name: 'agent-console.dashboard',
+    version: 1,
+    description:
+      'Main dashboard for AI agent operations with stats, recent activity, and quick actions',
+    domain: 'agent-console',
+    owners: ['agent-console-team'],
+    tags: ['dashboard', 'overview'],
+  },
+  source: {
+    type: 'component',
+    framework: 'react',
+    componentKey: 'AgentConsoleDashboard',
+  },
+  targets: ['react', 'markdown'],
+  policy: {
+    flags: ['agent-console.enabled'],
+  },
+};

package/src/presentations/index.ts

@@ -0,0 +1,48 @@
+/**
+ * Presentation descriptors for agent-console
+ *
+ * These define how data can be rendered across different targets (React, Markdown, JSON).
+ */
+
+// Agent presentations
+export { AgentListPresentation, AgentDetailPresentation } from './agent-list';
+
+// Run presentations
+export {
+  RunListPresentation,
+  RunDetailPresentation,
+  RunMetricsPresentation,
+} from './run-list';
+
+// Tool presentations
+export {
+  ToolRegistryPresentation,
+  ToolDetailPresentation,
+} from './tool-registry';
+
+// Dashboard
+export { AgentConsoleDashboardPresentation } from './dashboard';
+
+// Re-export all presentations as an array for easy registration
+import { AgentListPresentation, AgentDetailPresentation } from './agent-list';
+import {
+  RunListPresentation,
+  RunDetailPresentation,
+  RunMetricsPresentation,
+} from './run-list';
+import {
+  ToolRegistryPresentation,
+  ToolDetailPresentation,
+} from './tool-registry';
+import { AgentConsoleDashboardPresentation } from './dashboard';
+
+export const AgentConsolePresentations = [
+  AgentConsoleDashboardPresentation,
+  AgentListPresentation,
+  AgentDetailPresentation,
+  RunListPresentation,
+  RunDetailPresentation,
+  RunMetricsPresentation,
+  ToolRegistryPresentation,
+  ToolDetailPresentation,
+];