@contractspec/example.agent-console 3.7.6 → 3.7.7

package/src/handlers/index.ts

@@ -4,26 +4,26 @@
 
 // Agent handlers and types
 export {
-  mockCreateAgentHandler,
-  mockGetAgentHandler,
-  mockListAgentsHandler,
-  type AgentSummary,
+	type AgentSummary,
+	mockCreateAgentHandler,
+	mockGetAgentHandler,
+	mockListAgentsHandler,
 } from '../agent/agent.handler';
 
 // Run handlers and types
 export {
-  mockExecuteAgentHandler,
-  mockGetRunHandler,
-  mockListRunsHandler,
-  type RunSummary,
+	mockExecuteAgentHandler,
+	mockGetRunHandler,
+	mockListRunsHandler,
+	type RunSummary,
 } from '../run/run.handler';
 
 // Tool handlers and types
 export {
-  mockCreateToolHandler,
-  mockGetToolHandler,
-  mockListToolsHandler,
-  type ToolSummary,
+	mockCreateToolHandler,
+	mockGetToolHandler,
+	mockListToolsHandler,
+	type ToolSummary,
 } from '../tool/tool.handler';
 
 // Runtime handlers (PGLite)

package/src/index.ts

@@ -17,16 +17,15 @@
 
 // Domain exports
 export * from './agent';
-export * from './run';
-export * from './tool';
-export * from './shared';
-export * from './ui';
-export {
-  createAgentHandlers,
-  type AgentHandlers,
-} from './handlers/agent.handlers';
-
 // Feature spec export
 export * from './agent.feature';
 export { default as example } from './example';
+export {
+	type AgentHandlers,
+	createAgentHandlers,
+} from './handlers/agent.handlers';
+export * from './run';
+export * from './shared';
+export * from './tool';
+export * from './ui';
 import './docs';

package/src/presentations/index.ts

@@ -4,23 +4,21 @@
 
 // Agent presentations
 export {
-  AgentListPresentation,
-  AgentDetailPresentation,
-  AgentConsoleDashboardPresentation,
+	AgentConsoleDashboardPresentation,
+	AgentDetailPresentation,
+	AgentListPresentation,
 } from '../agent/agent.presentation';
-
 // Run presentations
+// Alias: RunMetricsPresentation -> RunDetailPresentation (for backward compatibility)
 export {
-  RunListPresentation,
-  RunDetailPresentation,
+	RunDetailPresentation,
+	RunDetailPresentation as RunMetricsPresentation,
+	RunListPresentation,
 } from '../run/run.presentation';
-// Alias: RunMetricsPresentation -> RunDetailPresentation (for backward compatibility)
-export { RunDetailPresentation as RunMetricsPresentation } from '../run/run.presentation';
-
 // Tool presentations
+// Alias: ToolRegistryPresentation -> ToolListPresentation (for backward compatibility)
 export {
-  ToolListPresentation,
-  ToolDetailPresentation,
+	ToolDetailPresentation,
+	ToolListPresentation,
+	ToolListPresentation as ToolRegistryPresentation,
 } from '../tool/tool.presentation';
-// Alias: ToolRegistryPresentation -> ToolListPresentation (for backward compatibility)
-export { ToolListPresentation as ToolRegistryPresentation } from '../tool/tool.presentation';

package/src/run/index.ts

@@ -2,67 +2,62 @@
  * Run domain - Agent execution and monitoring.
  */
 
+// Entities
+export {
+	LogLevelEntityEnum,
+	RunEntity,
+	RunLogEntity,
+	RunStatusEntityEnum,
+	RunStepEntity,
+	RunStepTypeEntityEnum,
+} from './run.entity';
 // Enums
 export {
-  RunStatusEnum,
-  RunStepTypeEnum,
-  LogLevelEnum,
-  GranularityEnum,
+	GranularityEnum,
+	LogLevelEnum,
+	RunStatusEnum,
+	RunStepTypeEnum,
 } from './run.enum';
-
-// Schema models
-export {
-  RunInputModel,
-  RunStepModel,
-  RunLogModel,
-  RunAgentRefModel,
-  RunModel,
-  RunSummaryModel,
-  TimelineDataPointModel,
-} from './run.schema';
-
-// Contracts
-export {
-  ExecuteAgentCommand,
-  CancelRunCommand,
-  GetRunQuery,
-  ListRunsQuery,
-  GetRunStepsQuery,
-  GetRunLogsQuery,
-  GetRunMetricsQuery,
-} from './run.operation';
-
 // Events
 export {
-  RunStartedEvent,
-  RunCompletedEvent,
-  RunFailedEvent,
-  RunCancelledEvent,
-  ToolInvokedEvent,
-  ToolCompletedEvent,
-  MessageGeneratedEvent,
+	MessageGeneratedEvent,
+	RunCancelledEvent,
+	RunCompletedEvent,
+	RunFailedEvent,
+	RunStartedEvent,
+	ToolCompletedEvent,
+	ToolInvokedEvent,
 } from './run.event';
-
-// Entities
+// Handlers
 export {
-  RunStatusEntityEnum,
-  RunStepTypeEntityEnum,
-  LogLevelEntityEnum,
-  RunEntity,
-  RunStepEntity,
-  RunLogEntity,
-} from './run.entity';
+	type ListRunsInput,
+	type ListRunsOutput,
+	mockCancelRunHandler,
+	mockExecuteAgentHandler,
+	mockGetRunHandler,
+	mockListRunsHandler,
+	type RunSummary,
+} from './run.handler';
+// Contracts
+export {
+	CancelRunCommand,
+	ExecuteAgentCommand,
+	GetRunLogsQuery,
+	GetRunMetricsQuery,
+	GetRunQuery,
+	GetRunStepsQuery,
+	ListRunsQuery,
+} from './run.operation';
 
 // Presentations
-export { RunListPresentation, RunDetailPresentation } from './run.presentation';
-
-// Handlers
+export { RunDetailPresentation, RunListPresentation } from './run.presentation';
+// Schema models
 export {
-  mockListRunsHandler,
-  mockGetRunHandler,
-  mockExecuteAgentHandler,
-  mockCancelRunHandler,
-  type ListRunsInput,
-  type RunSummary,
-  type ListRunsOutput,
-} from './run.handler';
+	RunAgentRefModel,
+	RunInputModel,
+	RunLogModel,
+	RunModel,
+	RunStepModel,
+	RunSummaryModel,
+	TimelineDataPointModel,
+} from './run.schema';

package/src/run/run.entity.ts

@@ -1,175 +1,175 @@
 import {
-  defineEntity,
-  defineEntityEnum,
-  field,
-  index,
+	defineEntity,
+	defineEntityEnum,
+	field,
+	index,
 } from '@contractspec/lib.schema';
 
 /**
  * Run status enum for entities.
  */
 export const RunStatusEntityEnum = defineEntityEnum({
-  name: 'RunStatus',
-  values: [
-    'QUEUED',
-    'IN_PROGRESS',
-    'COMPLETED',
-    'FAILED',
-    'CANCELLED',
-    'EXPIRED',
-  ],
-  description: 'Status of an agent run',
+	name: 'RunStatus',
+	values: [
+		'QUEUED',
+		'IN_PROGRESS',
+		'COMPLETED',
+		'FAILED',
+		'CANCELLED',
+		'EXPIRED',
+	],
+	description: 'Status of an agent run',
 });
 
 /**
  * Run step type enum for entities.
  */
 export const RunStepTypeEntityEnum = defineEntityEnum({
-  name: 'RunStepType',
-  values: ['MESSAGE_CREATION', 'TOOL_CALL', 'TOOL_RESULT', 'ERROR'],
-  description: 'Type of run step',
+	name: 'RunStepType',
+	values: ['MESSAGE_CREATION', 'TOOL_CALL', 'TOOL_RESULT', 'ERROR'],
+	description: 'Type of run step',
 });
 
 /**
  * Log level enum for entities.
  */
 export const LogLevelEntityEnum = defineEntityEnum({
-  name: 'LogLevel',
-  values: ['DEBUG', 'INFO', 'WARN', 'ERROR'],
-  description: 'Log level',
+	name: 'LogLevel',
+	values: ['DEBUG', 'INFO', 'WARN', 'ERROR'],
+	description: 'Log level',
 });
 
 /**
  * Run entity - Represents an agent execution.
  */
 export const RunEntity = defineEntity({
-  name: 'Run',
-  schema: 'agent_console',
-  description: 'An execution of an agent with input/output and metrics.',
-  fields: {
-    id: field.id(),
-    organizationId: field.string({ description: 'Organization ID' }),
-    agentId: field.foreignKey({ description: 'Agent being executed' }),
-    userId: field.string({
-      isOptional: true,
-      description: 'User who initiated the run',
-    }),
-    sessionId: field.string({
-      isOptional: true,
-      description: 'Conversation session ID',
-    }),
-    input: field.json({ description: 'Input data for the run' }),
-    output: field.json({
-      isOptional: true,
-      description: 'Output result from the run',
-    }),
-    status: field.enum('RunStatus', { default: 'QUEUED' }),
-    errorMessage: field.string({
-      isOptional: true,
-      description: 'Error message if failed',
-    }),
-    errorCode: field.string({
-      isOptional: true,
-      description: 'Error code if failed',
-    }),
-    totalTokens: field.int({ default: 0, description: 'Total tokens used' }),
-    promptTokens: field.int({ default: 0, description: 'Prompt tokens used' }),
-    completionTokens: field.int({
-      default: 0,
-      description: 'Completion tokens used',
-    }),
-    totalIterations: field.int({
-      default: 0,
-      description: 'Number of iterations',
-    }),
-    durationMs: field.int({
-      isOptional: true,
-      description: 'Execution duration in ms',
-    }),
-    estimatedCostUsd: field.float({
-      isOptional: true,
-      description: 'Estimated cost in USD',
-    }),
-    queuedAt: field.dateTime({ description: 'When run was queued' }),
-    startedAt: field.dateTime({
-      isOptional: true,
-      description: 'When run started executing',
-    }),
-    completedAt: field.dateTime({
-      isOptional: true,
-      description: 'When run completed',
-    }),
-    metadata: field.json({
-      isOptional: true,
-      description: 'Additional metadata',
-    }),
-    agent: field.belongsTo('Agent', ['agentId'], ['id']),
-    steps: field.hasMany('RunStep', { description: 'Execution steps' }),
-    logs: field.hasMany('RunLog', { description: 'Execution logs' }),
-  },
-  indexes: [
-    index.on(['organizationId', 'agentId', 'queuedAt']),
-    index.on(['organizationId', 'status']),
-    index.on(['agentId', 'status']),
-    index.on(['sessionId']),
-  ],
-  enums: [RunStatusEntityEnum],
+	name: 'Run',
+	schema: 'agent_console',
+	description: 'An execution of an agent with input/output and metrics.',
+	fields: {
+		id: field.id(),
+		organizationId: field.string({ description: 'Organization ID' }),
+		agentId: field.foreignKey({ description: 'Agent being executed' }),
+		userId: field.string({
+			isOptional: true,
+			description: 'User who initiated the run',
+		}),
+		sessionId: field.string({
+			isOptional: true,
+			description: 'Conversation session ID',
+		}),
+		input: field.json({ description: 'Input data for the run' }),
+		output: field.json({
+			isOptional: true,
+			description: 'Output result from the run',
+		}),
+		status: field.enum('RunStatus', { default: 'QUEUED' }),
+		errorMessage: field.string({
+			isOptional: true,
+			description: 'Error message if failed',
+		}),
+		errorCode: field.string({
+			isOptional: true,
+			description: 'Error code if failed',
+		}),
+		totalTokens: field.int({ default: 0, description: 'Total tokens used' }),
+		promptTokens: field.int({ default: 0, description: 'Prompt tokens used' }),
+		completionTokens: field.int({
+			default: 0,
+			description: 'Completion tokens used',
+		}),
+		totalIterations: field.int({
+			default: 0,
+			description: 'Number of iterations',
+		}),
+		durationMs: field.int({
+			isOptional: true,
+			description: 'Execution duration in ms',
+		}),
+		estimatedCostUsd: field.float({
+			isOptional: true,
+			description: 'Estimated cost in USD',
+		}),
+		queuedAt: field.dateTime({ description: 'When run was queued' }),
+		startedAt: field.dateTime({
+			isOptional: true,
+			description: 'When run started executing',
+		}),
+		completedAt: field.dateTime({
+			isOptional: true,
+			description: 'When run completed',
+		}),
+		metadata: field.json({
+			isOptional: true,
+			description: 'Additional metadata',
+		}),
+		agent: field.belongsTo('Agent', ['agentId'], ['id']),
+		steps: field.hasMany('RunStep', { description: 'Execution steps' }),
+		logs: field.hasMany('RunLog', { description: 'Execution logs' }),
+	},
+	indexes: [
+		index.on(['organizationId', 'agentId', 'queuedAt']),
+		index.on(['organizationId', 'status']),
+		index.on(['agentId', 'status']),
+		index.on(['sessionId']),
+	],
+	enums: [RunStatusEntityEnum],
 });
 
 /**
  * RunStep entity - Individual step in a run.
  */
 export const RunStepEntity = defineEntity({
-  name: 'RunStep',
-  schema: 'agent_console',
-  description: 'An individual step in an agent run.',
-  fields: {
-    id: field.id(),
-    runId: field.foreignKey({ description: 'Parent run' }),
-    stepNumber: field.int({ description: 'Step sequence number' }),
-    type: field.enum('RunStepType'),
-    toolId: field.string({
-      isOptional: true,
-      description: 'Tool used in this step',
-    }),
-    toolName: field.string({ isOptional: true, description: 'Tool name' }),
-    input: field.json({ isOptional: true, description: 'Step input' }),
-    output: field.json({ isOptional: true, description: 'Step output' }),
-    status: field.enum('RunStatus'),
-    errorMessage: field.string({ isOptional: true }),
-    tokensUsed: field.int({ default: 0 }),
-    durationMs: field.int({ isOptional: true }),
-    startedAt: field.dateTime(),
-    completedAt: field.dateTime({ isOptional: true }),
-    run: field.belongsTo('Run', ['runId'], ['id']),
-  },
-  indexes: [index.on(['runId', 'stepNumber'])],
-  enums: [RunStepTypeEntityEnum],
+	name: 'RunStep',
+	schema: 'agent_console',
+	description: 'An individual step in an agent run.',
+	fields: {
+		id: field.id(),
+		runId: field.foreignKey({ description: 'Parent run' }),
+		stepNumber: field.int({ description: 'Step sequence number' }),
+		type: field.enum('RunStepType'),
+		toolId: field.string({
+			isOptional: true,
+			description: 'Tool used in this step',
+		}),
+		toolName: field.string({ isOptional: true, description: 'Tool name' }),
+		input: field.json({ isOptional: true, description: 'Step input' }),
+		output: field.json({ isOptional: true, description: 'Step output' }),
+		status: field.enum('RunStatus'),
+		errorMessage: field.string({ isOptional: true }),
+		tokensUsed: field.int({ default: 0 }),
+		durationMs: field.int({ isOptional: true }),
+		startedAt: field.dateTime(),
+		completedAt: field.dateTime({ isOptional: true }),
+		run: field.belongsTo('Run', ['runId'], ['id']),
+	},
+	indexes: [index.on(['runId', 'stepNumber'])],
+	enums: [RunStepTypeEntityEnum],
 });
 
 /**
  * RunLog entity - Log entry for a run.
  */
 export const RunLogEntity = defineEntity({
-  name: 'RunLog',
-  schema: 'agent_console',
-  description: 'A log entry for an agent run.',
-  fields: {
-    id: field.id(),
-    runId: field.foreignKey({ description: 'Parent run' }),
-    stepId: field.string({ isOptional: true, description: 'Related step' }),
-    level: field.enum('LogLevel'),
-    message: field.string({ description: 'Log message' }),
-    data: field.json({ isOptional: true, description: 'Additional log data' }),
-    source: field.string({
-      isOptional: true,
-      description: 'Log source component',
-    }),
-    traceId: field.string({ isOptional: true }),
-    spanId: field.string({ isOptional: true }),
-    timestamp: field.dateTime(),
-    run: field.belongsTo('Run', ['runId'], ['id']),
-  },
-  indexes: [index.on(['runId', 'timestamp']), index.on(['runId', 'level'])],
-  enums: [LogLevelEntityEnum],
+	name: 'RunLog',
+	schema: 'agent_console',
+	description: 'A log entry for an agent run.',
+	fields: {
+		id: field.id(),
+		runId: field.foreignKey({ description: 'Parent run' }),
+		stepId: field.string({ isOptional: true, description: 'Related step' }),
+		level: field.enum('LogLevel'),
+		message: field.string({ description: 'Log message' }),
+		data: field.json({ isOptional: true, description: 'Additional log data' }),
+		source: field.string({
+			isOptional: true,
+			description: 'Log source component',
+		}),
+		traceId: field.string({ isOptional: true }),
+		spanId: field.string({ isOptional: true }),
+		timestamp: field.dateTime(),
+		run: field.belongsTo('Run', ['runId'], ['id']),
+	},
+	indexes: [index.on(['runId', 'timestamp']), index.on(['runId', 'level'])],
+	enums: [LogLevelEntityEnum],
 });

package/src/run/run.enum.ts

@@ -4,40 +4,40 @@ import { defineEnum } from '@contractspec/lib.schema';
  * Run status enum.
  */
 export const RunStatusEnum = defineEnum('RunStatus', [
-  'QUEUED',
-  'IN_PROGRESS',
-  'COMPLETED',
-  'FAILED',
-  'CANCELLED',
-  'EXPIRED',
+	'QUEUED',
+	'IN_PROGRESS',
+	'COMPLETED',
+	'FAILED',
+	'CANCELLED',
+	'EXPIRED',
 ]);
 
 /**
  * Run step type enum.
  */
 export const RunStepTypeEnum = defineEnum('RunStepType', [
-  'MESSAGE_CREATION',
-  'TOOL_CALL',
-  'TOOL_RESULT',
-  'ERROR',
+	'MESSAGE_CREATION',
+	'TOOL_CALL',
+	'TOOL_RESULT',
+	'ERROR',
 ]);
 
 /**
  * Log level enum.
  */
 export const LogLevelEnum = defineEnum('LogLevel', [
-  'DEBUG',
-  'INFO',
-  'WARN',
-  'ERROR',
+	'DEBUG',
+	'INFO',
+	'WARN',
+	'ERROR',
 ]);
 
 /**
  * Granularity enum for metrics.
  */
 export const GranularityEnum = defineEnum('Granularity', [
-  'hour',
-  'day',
-  'week',
-  'month',
+	'hour',
+	'day',
+	'week',
+	'month',
 ]);