@lssm/example.agent-console 0.0.0-canary-20251225044228 → 0.0.0-canary-20251225070736

package/src/agent/agent.operation.ts

@@ -59,6 +59,42 @@ export const CreateAgentCommand = defineCommand({
     ],
     audit: ['agent-console.agent.created'],
   },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'create-agent-happy-path',
+        given: ['User is authenticated', 'Organization exists'],
+        when: ['User submits valid agent configuration'],
+        then: [
+          'New agent is created with DRAFT status',
+          'AgentCreated event is emitted',
+        ],
+      },
+      {
+        key: 'create-agent-slug-conflict',
+        given: ['User is authenticated', 'Agent with same slug exists'],
+        when: ['User submits agent with duplicate slug'],
+        then: ['SLUG_EXISTS error is returned with 409 status'],
+      },
+    ],
+    examples: [
+      {
+        key: 'basic-create',
+        input: {
+          name: 'Support Assistant',
+          slug: 'support-assistant',
+          modelProvider: 'openai',
+          modelId: 'gpt-4',
+        },
+        output: {
+          id: 'agent-123',
+          name: 'Support Assistant',
+          slug: 'support-assistant',
+          status: 'draft',
+        },
+      },
+    ],
+  },
 });
 
 /**
@@ -110,6 +146,38 @@ export const UpdateAgentCommand = defineCommand({
     ],
     audit: ['agent.updated'],
   },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'update-agent-happy-path',
+        given: ['Agent exists', 'User owns the agent'],
+        when: ['User submits updated configuration'],
+        then: ['Agent is updated', 'AgentUpdated event is emitted'],
+      },
+      {
+        key: 'update-agent-not-found',
+        given: ['Agent does not exist'],
+        when: ['User attempts to update'],
+        then: ['AGENT_NOT_FOUND error is returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'update-name',
+        input: {
+          agentId: 'agent-123',
+          name: 'Updated Assistant',
+          systemPrompt: 'You are a helpful assistant.',
+        },
+        output: {
+          id: 'agent-123',
+          name: 'Updated Assistant',
+          status: 'draft',
+          updatedAt: '2025-01-01T00:00:00Z',
+        },
+      },
+    ],
+  },
 });
 
 /**
@@ -145,6 +213,34 @@ export const GetAgentQuery = defineQuery({
     },
   },
   policy: { auth: 'user' },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'get-agent-happy-path',
+        given: ['Agent exists'],
+        when: ['User requests agent by ID'],
+        then: ['Agent details are returned'],
+      },
+      {
+        key: 'get-agent-with-tools',
+        given: ['Agent exists with assigned tools'],
+        when: ['User requests agent with includeTools=true'],
+        then: ['Agent details with tools list are returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'get-basic',
+        input: { agentId: 'agent-123', includeTools: false },
+        output: {
+          id: 'agent-123',
+          name: 'Support Assistant',
+          status: 'active',
+          tools: [],
+        },
+      },
+    ],
+  },
 });
 
 /**
@@ -194,6 +290,29 @@ export const ListAgentsQuery = defineQuery({
     }),
   },
   policy: { auth: 'user' },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'list-agents-happy-path',
+        given: ['Organization has agents'],
+        when: ['User lists agents'],
+        then: ['Paginated list of agents is returned'],
+      },
+      {
+        key: 'list-agents-filter-by-status',
+        given: ['Organization has agents with mixed statuses'],
+        when: ['User filters by status=active'],
+        then: ['Only active agents are returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'list-basic',
+        input: { organizationId: 'org-123', limit: 10, offset: 0 },
+        output: { items: [], total: 0, hasMore: false },
+      },
+    ],
+  },
 });
 
 /**
@@ -242,6 +361,33 @@ export const AssignToolToAgentCommand = defineCommand({
   },
   policy: { auth: 'user' },
   sideEffects: { audit: ['agent.tool.assigned'] },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'assign-tool-happy-path',
+        given: ['Agent exists', 'Tool exists and is not assigned'],
+        when: ['User assigns tool to agent'],
+        then: ['Tool is assigned', 'Assignment ID is returned'],
+      },
+      {
+        key: 'assign-tool-already-assigned',
+        given: ['Tool is already assigned to agent'],
+        when: ['User attempts to assign again'],
+        then: ['TOOL_ALREADY_ASSIGNED error is returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'assign-basic',
+        input: { agentId: 'agent-123', toolId: 'tool-456' },
+        output: {
+          agentToolId: 'at-789',
+          agentId: 'agent-123',
+          toolId: 'tool-456',
+        },
+      },
+    ],
+  },
 });
 
 /**
@@ -275,4 +421,21 @@ export const RemoveToolFromAgentCommand = defineCommand({
   },
   policy: { auth: 'user' },
   sideEffects: { audit: ['agent.tool.removed'] },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'remove-tool-happy-path',
+        given: ['Agent exists', 'Tool is assigned to agent'],
+        when: ['User removes tool from agent'],
+        then: ['Tool is unassigned', 'Success is returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'remove-basic',
+        input: { agentId: 'agent-123', toolId: 'tool-456' },
+        output: { success: true },
+      },
+    ],
+  },
 });

package/src/run/run.operation.ts

@@ -83,6 +83,29 @@ export const ExecuteAgentCommand = defineCommand({
     ],
     audit: ['run.started'],
   },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'execute-agent-happy-path',
+        given: ['Agent exists', 'Agent is active'],
+        when: ['User submits execution request'],
+        then: ['Run is created', 'RunStarted event is emitted'],
+      },
+      {
+        key: 'execute-agent-not-active',
+        given: ['Agent exists but is not active'],
+        when: ['User attempts to execute'],
+        then: ['AGENT_NOT_ACTIVE error is returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'basic-execute',
+        input: { agentId: 'agent-123', input: { message: 'Hello' } },
+        output: { runId: 'run-456', status: 'pending', estimatedWaitMs: 5000 },
+      },
+    ],
+  },
 });
 
 /**
@@ -144,6 +167,29 @@ export const CancelRunCommand = defineCommand({
     ],
     audit: ['run.cancelled'],
   },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'cancel-run-happy-path',
+        given: ['Run exists', 'Run is in progress'],
+        when: ['User cancels run'],
+        then: ['Run is cancelled', 'RunCancelled event is emitted'],
+      },
+      {
+        key: 'cancel-run-already-completed',
+        given: ['Run exists but is already completed'],
+        when: ['User attempts to cancel'],
+        then: ['RUN_NOT_CANCELLABLE error is returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'cancel-basic',
+        input: { runId: 'run-456', reason: 'User requested' },
+        output: { success: true, status: 'cancelled' },
+      },
+    ],
+  },
 });
 
 /**
@@ -180,6 +226,23 @@ export const GetRunQuery = defineQuery({
     },
   },
   policy: { auth: 'user' },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'get-run-happy-path',
+        given: ['Run exists'],
+        when: ['User requests run by ID'],
+        then: ['Run details are returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'get-with-steps',
+        input: { runId: 'run-456', includeSteps: true, includeLogs: false },
+        output: { id: 'run-456', status: 'completed', steps: [] },
+      },
+    ],
+  },
 });
 
 /**
@@ -232,6 +295,23 @@ export const ListRunsQuery = defineQuery({
     }),
   },
   policy: { auth: 'user' },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'list-runs-happy-path',
+        given: ['Organization has runs'],
+        when: ['User lists runs'],
+        then: ['Paginated list of runs is returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'list-by-agent',
+        input: { agentId: 'agent-123', limit: 20, offset: 0 },
+        output: { items: [], total: 0, hasMore: false },
+      },
+    ],
+  },
 });
 
 /**
@@ -263,6 +343,23 @@ export const GetRunStepsQuery = defineQuery({
     }),
   },
   policy: { auth: 'user' },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'get-run-steps-happy-path',
+        given: ['Run exists with steps'],
+        when: ['User requests steps'],
+        then: ['Steps list is returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'get-steps-basic',
+        input: { runId: 'run-456' },
+        output: { steps: [] },
+      },
+    ],
+  },
 });
 
 /**
@@ -308,6 +405,23 @@ export const GetRunLogsQuery = defineQuery({
     }),
   },
   policy: { auth: 'user' },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'get-run-logs-happy-path',
+        given: ['Run exists with logs'],
+        when: ['User requests logs'],
+        then: ['Paginated logs list is returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'get-logs-filtered',
+        input: { runId: 'run-456', level: 'error', limit: 50 },
+        output: { items: [], total: 0, hasMore: false },
+      },
+    ],
+  },
 });
 
 /**
@@ -373,4 +487,35 @@ export const GetRunMetricsQuery = defineQuery({
     }),
   },
   policy: { auth: 'user' },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'get-run-metrics-happy-path',
+        given: ['Organization has run history'],
+        when: ['User requests metrics for date range'],
+        then: ['Aggregated metrics are returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'get-daily-metrics',
+        input: {
+          organizationId: 'org-123',
+          startDate: '2025-01-01',
+          endDate: '2025-01-31',
+          granularity: 'day',
+        },
+        output: {
+          totalRuns: 100,
+          completedRuns: 90,
+          failedRuns: 10,
+          totalTokens: 50000,
+          totalCostUsd: 5.0,
+          averageDurationMs: 2500,
+          successRate: 0.9,
+          timeline: [],
+        },
+      },
+    ],
+  },
 });

package/src/tool/tool.operation.ts

@@ -59,6 +59,39 @@ export const CreateToolCommand = defineCommand({
     ],
     audit: ['tool.created'],
   },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'create-tool-happy-path',
+        given: ['User is authenticated', 'Organization exists'],
+        when: ['User submits valid tool configuration'],
+        then: ['New tool is created', 'ToolCreated event is emitted'],
+      },
+      {
+        key: 'create-tool-slug-conflict',
+        given: ['Tool with same slug exists'],
+        when: ['User submits tool with duplicate slug'],
+        then: ['SLUG_EXISTS error is returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'create-api-tool',
+        input: {
+          name: 'Weather API',
+          slug: 'weather-api',
+          category: 'api',
+          description: 'Fetches weather data',
+        },
+        output: {
+          id: 'tool-123',
+          name: 'Weather API',
+          slug: 'weather-api',
+          status: 'draft',
+        },
+      },
+    ],
+  },
 });
 
 /**
@@ -110,6 +143,28 @@ export const UpdateToolCommand = defineCommand({
     ],
     audit: ['tool.updated'],
   },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'update-tool-happy-path',
+        given: ['Tool exists', 'User owns the tool'],
+        when: ['User submits updated configuration'],
+        then: ['Tool is updated', 'ToolUpdated event is emitted'],
+      },
+    ],
+    examples: [
+      {
+        key: 'update-description',
+        input: { toolId: 'tool-123', description: 'Updated weather API tool' },
+        output: {
+          id: 'tool-123',
+          name: 'Weather API',
+          status: 'draft',
+          updatedAt: '2025-01-01T00:00:00Z',
+        },
+      },
+    ],
+  },
 });
 
 /**
@@ -144,6 +199,28 @@ export const GetToolQuery = defineQuery({
     },
   },
   policy: { auth: 'user' },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'get-tool-happy-path',
+        given: ['Tool exists'],
+        when: ['User requests tool by ID'],
+        then: ['Tool details are returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'get-basic',
+        input: { toolId: 'tool-123' },
+        output: {
+          id: 'tool-123',
+          name: 'Weather API',
+          status: 'active',
+          category: 'api',
+        },
+      },
+    ],
+  },
 });
 
 /**
@@ -193,6 +270,23 @@ export const ListToolsQuery = defineQuery({
     }),
   },
   policy: { auth: 'user' },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'list-tools-happy-path',
+        given: ['Organization has tools'],
+        when: ['User lists tools'],
+        then: ['Paginated list of tools is returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'list-by-category',
+        input: { organizationId: 'org-123', category: 'api', limit: 10 },
+        output: { items: [], total: 0, hasMore: false },
+      },
+    ],
+  },
 });
 
 /**
@@ -243,4 +337,27 @@ export const TestToolCommand = defineCommand({
   },
   policy: { auth: 'user' },
   sideEffects: { audit: ['tool.tested'] },
+  acceptance: {
+    scenarios: [
+      {
+        key: 'test-tool-success',
+        given: ['Tool exists', 'Tool is configured correctly'],
+        when: ['User runs test with valid input'],
+        then: ['Tool executes successfully', 'Output is returned'],
+      },
+      {
+        key: 'test-tool-failure',
+        given: ['Tool exists', 'Tool has configuration error'],
+        when: ['User runs test'],
+        then: ['TOOL_EXECUTION_ERROR is returned'],
+      },
+    ],
+    examples: [
+      {
+        key: 'test-weather-api',
+        input: { toolId: 'tool-123', testInput: { city: 'Paris' } },
+        output: { success: true, output: { temperature: 22 }, durationMs: 150 },
+      },
+    ],
+  },
 });