@lssm/example.agent-console 0.0.0-canary-20251216031832 → 0.0.0-canary-20251216033905

package/src/run/run.contracts.ts

@@ -1,7 +1,14 @@
 import { defineCommand, defineQuery } from '@lssm/lib.contracts/spec';
 import { defineSchemaModel, ScalarTypeEnum } from '@lssm/lib.schema';
 import { RunStatusEnum, LogLevelEnum, GranularityEnum } from './run.enum';
-import { RunInputModel, RunModel, RunSummaryModel, RunStepModel, RunLogModel, TimelineDataPointModel } from './run.schema';
+import {
+  RunInputModel,
+  RunModel,
+  RunSummaryModel,
+  RunStepModel,
+  RunLogModel,
+  TimelineDataPointModel,
+} from './run.schema';
 
 const OWNERS = ['agent-console-team'] as const;
 
@@ -28,7 +35,10 @@ export const ExecuteAgentCommand = defineCommand({
         sessionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
         metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
         stream: { type: ScalarTypeEnum.Boolean(), isOptional: true },
-        maxIterations: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+        maxIterations: {
+          type: ScalarTypeEnum.Int_unsecure(),
+          isOptional: true,
+        },
         timeoutMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
       },
     }),
@@ -37,17 +47,37 @@ export const ExecuteAgentCommand = defineCommand({
       fields: {
         runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
         status: { type: RunStatusEnum, isOptional: false },
-        estimatedWaitMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+        estimatedWaitMs: {
+          type: ScalarTypeEnum.Int_unsecure(),
+          isOptional: true,
+        },
       },
     }),
     errors: {
-      AGENT_NOT_FOUND: { description: 'The specified agent does not exist', http: 404, gqlCode: 'AGENT_NOT_FOUND', when: 'Agent ID is invalid' },
-      AGENT_NOT_ACTIVE: { description: 'The specified agent is not active', http: 400, gqlCode: 'AGENT_NOT_ACTIVE', when: 'Agent is in draft/paused/archived state' },
+      AGENT_NOT_FOUND: {
+        description: 'The specified agent does not exist',
+        http: 404,
+        gqlCode: 'AGENT_NOT_FOUND',
+        when: 'Agent ID is invalid',
+      },
+      AGENT_NOT_ACTIVE: {
+        description: 'The specified agent is not active',
+        http: 400,
+        gqlCode: 'AGENT_NOT_ACTIVE',
+        when: 'Agent is in draft/paused/archived state',
+      },
     },
   },
   policy: { auth: 'user' },
   sideEffects: {
-    emits: [{ name: 'run.started', version: 1, when: 'Run is queued', payload: RunSummaryModel }],
+    emits: [
+      {
+        name: 'run.started',
+        version: 1,
+        when: 'Run is queued',
+        payload: RunSummaryModel,
+      },
+    ],
     audit: ['run.started'],
   },
 });
@@ -82,13 +112,30 @@ export const CancelRunCommand = defineCommand({
       },
     }),
     errors: {
-      RUN_NOT_FOUND: { description: 'The specified run does not exist', http: 404, gqlCode: 'RUN_NOT_FOUND', when: 'Run ID is invalid' },
-      RUN_NOT_CANCELLABLE: { description: 'The run cannot be cancelled', http: 400, gqlCode: 'RUN_NOT_CANCELLABLE', when: 'Run is already completed/failed/cancelled' },
+      RUN_NOT_FOUND: {
+        description: 'The specified run does not exist',
+        http: 404,
+        gqlCode: 'RUN_NOT_FOUND',
+        when: 'Run ID is invalid',
+      },
+      RUN_NOT_CANCELLABLE: {
+        description: 'The run cannot be cancelled',
+        http: 400,
+        gqlCode: 'RUN_NOT_CANCELLABLE',
+        when: 'Run is already completed/failed/cancelled',
+      },
     },
   },
   policy: { auth: 'user' },
   sideEffects: {
-    emits: [{ name: 'run.cancelled', version: 1, when: 'Run is cancelled', payload: RunSummaryModel }],
+    emits: [
+      {
+        name: 'run.cancelled',
+        version: 1,
+        when: 'Run is cancelled',
+        payload: RunSummaryModel,
+      },
+    ],
     audit: ['run.cancelled'],
   },
 });
@@ -117,7 +164,14 @@ export const GetRunQuery = defineQuery({
       },
     }),
     output: RunModel,
-    errors: { RUN_NOT_FOUND: { description: 'The specified run does not exist', http: 404, gqlCode: 'RUN_NOT_FOUND', when: 'Run ID is invalid' } },
+    errors: {
+      RUN_NOT_FOUND: {
+        description: 'The specified run does not exist',
+        http: 404,
+        gqlCode: 'RUN_NOT_FOUND',
+        when: 'Run ID is invalid',
+      },
+    },
   },
   policy: { auth: 'user' },
 });
@@ -140,15 +194,26 @@ export const ListRunsQuery = defineQuery({
     input: defineSchemaModel({
       name: 'ListRunsInput',
       fields: {
-        organizationId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+        organizationId: {
+          type: ScalarTypeEnum.String_unsecure(),
+          isOptional: true,
+        },
         agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
         userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
         sessionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
         status: { type: RunStatusEnum, isOptional: true },
         startDate: { type: ScalarTypeEnum.DateTime(), isOptional: true },
         endDate: { type: ScalarTypeEnum.DateTime(), isOptional: true },
-        limit: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true, defaultValue: 20 },
-        offset: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true, defaultValue: 0 },
+        limit: {
+          type: ScalarTypeEnum.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 20,
+        },
+        offset: {
+          type: ScalarTypeEnum.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0,
+        },
       },
     }),
     output: defineSchemaModel({
@@ -178,8 +243,18 @@ export const GetRunStepsQuery = defineQuery({
     context: 'Run details page - steps tab.',
   },
   io: {
-    input: defineSchemaModel({ name: 'GetRunStepsInput', fields: { runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false } } }),
-    output: defineSchemaModel({ name: 'GetRunStepsOutput', fields: { steps: { type: RunStepModel, isArray: true, isOptional: false } } }),
+    input: defineSchemaModel({
+      name: 'GetRunStepsInput',
+      fields: {
+        runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+      },
+    }),
+    output: defineSchemaModel({
+      name: 'GetRunStepsOutput',
+      fields: {
+        steps: { type: RunStepModel, isArray: true, isOptional: false },
+      },
+    }),
   },
   policy: { auth: 'user' },
 });
@@ -205,8 +280,16 @@ export const GetRunLogsQuery = defineQuery({
         runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
         level: { type: LogLevelEnum, isOptional: true },
         stepId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-        limit: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true, defaultValue: 100 },
-        offset: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true, defaultValue: 0 },
+        limit: {
+          type: ScalarTypeEnum.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 100,
+        },
+        offset: {
+          type: ScalarTypeEnum.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0,
+        },
       },
     }),
     output: defineSchemaModel({
@@ -239,28 +322,49 @@ export const GetRunMetricsQuery = defineQuery({
     input: defineSchemaModel({
       name: 'GetRunMetricsInput',
       fields: {
-        organizationId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+        organizationId: {
+          type: ScalarTypeEnum.String_unsecure(),
+          isOptional: false,
+        },
         agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
         startDate: { type: ScalarTypeEnum.DateTime(), isOptional: false },
         endDate: { type: ScalarTypeEnum.DateTime(), isOptional: false },
-        granularity: { type: GranularityEnum, isOptional: true, defaultValue: 'day' },
+        granularity: {
+          type: GranularityEnum,
+          isOptional: true,
+          defaultValue: 'day',
+        },
       },
     }),
     output: defineSchemaModel({
       name: 'GetRunMetricsOutput',
       fields: {
         totalRuns: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-        completedRuns: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+        completedRuns: {
+          type: ScalarTypeEnum.Int_unsecure(),
+          isOptional: false,
+        },
         failedRuns: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
         totalTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-        totalCostUsd: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
-        averageDurationMs: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
-        successRate: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
-        timeline: { type: TimelineDataPointModel, isArray: true, isOptional: false },
+        totalCostUsd: {
+          type: ScalarTypeEnum.Float_unsecure(),
+          isOptional: false,
+        },
+        averageDurationMs: {
+          type: ScalarTypeEnum.Float_unsecure(),
+          isOptional: false,
+        },
+        successRate: {
+          type: ScalarTypeEnum.Float_unsecure(),
+          isOptional: false,
+        },
+        timeline: {
+          type: TimelineDataPointModel,
+          isArray: true,
+          isOptional: false,
+        },
       },
     }),
   },
   policy: { auth: 'user' },
 });
-
-

package/src/run/run.entity.ts

@@ -1,11 +1,23 @@
-import { defineEntity, defineEntityEnum, field, index } from '@lssm/lib.schema/entity';
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index,
+} from '@lssm/lib.schema/entity';
 
 /**
  * Run status enum for entities.
  */
 export const RunStatusEntityEnum = defineEntityEnum({
   name: 'RunStatus',
-  values: ['QUEUED', 'IN_PROGRESS', 'COMPLETED', 'FAILED', 'CANCELLED', 'EXPIRED'],
+  values: [
+    'QUEUED',
+    'IN_PROGRESS',
+    'COMPLETED',
+    'FAILED',
+    'CANCELLED',
+    'EXPIRED',
+  ],
   description: 'Status of an agent run',
 });
 
@@ -38,23 +50,59 @@ export const RunEntity = defineEntity({
     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' }),
+    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' }),
+    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' }),
+    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' }),
+    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' }),
+    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' }),
@@ -80,7 +128,10 @@ export const RunStepEntity = defineEntity({
     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' }),
+    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' }),
@@ -110,17 +161,15 @@ export const RunLogEntity = defineEntity({
     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' }),
+    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']),
-  ],
+  indexes: [index.on(['runId', 'timestamp']), index.on(['runId', 'level'])],
   enums: [LogLevelEntityEnum],
 });
-
-

package/src/run/run.enum.ts

@@ -41,5 +41,3 @@ export const GranularityEnum = defineEnum('Granularity', [
   'week',
   'month',
 ]);
-
-

package/src/run/run.event.ts

@@ -9,7 +9,10 @@ const RunStartedPayload = defineSchemaModel({
   description: 'Payload for run started event',
   fields: {
     runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false,
+    },
     agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
     agentName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
     userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
@@ -37,17 +40,26 @@ const RunCompletedPayload = defineSchemaModel({
   description: 'Payload for run completed event',
   fields: {
     runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false,
+    },
     agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
     agentName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
     userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
     output: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
     totalTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
     promptTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    completionTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    completionTokens: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: false,
+    },
     totalIterations: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
     durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    estimatedCostUsd: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
+    estimatedCostUsd: {
+      type: ScalarTypeEnum.Float_unsecure(),
+      isOptional: true,
+    },
     completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
   },
 });
@@ -70,7 +82,10 @@ const RunFailedPayload = defineSchemaModel({
   description: 'Payload for run failed event',
   fields: {
     runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false,
+    },
     agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
     agentName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
     userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
@@ -101,7 +116,10 @@ const RunCancelledPayload = defineSchemaModel({
   description: 'Payload for run cancelled event',
   fields: {
     runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: { 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 },
     cancelledBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
@@ -207,5 +225,3 @@ export const MessageGeneratedEvent = defineEvent({
   description: 'An agent generated a message during a run.',
   payload: MessageGeneratedPayload,
 });
-
-

package/src/run/run.handler.ts

@@ -9,7 +9,13 @@ export interface ListRunsInput {
   agentId?: string;
   userId?: string;
   sessionId?: string;
-  status?: 'QUEUED' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'EXPIRED';
+  status?:
+    | 'QUEUED'
+    | 'IN_PROGRESS'
+    | 'COMPLETED'
+    | 'FAILED'
+    | 'CANCELLED'
+    | 'EXPIRED';
   startDate?: Date;
   endDate?: Date;
   limit?: number;
@@ -20,7 +26,13 @@ export interface RunSummary {
   id: string;
   agentId: string;
   agentName: string;
-  status: 'QUEUED' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'EXPIRED';
+  status:
+    | 'QUEUED'
+    | 'IN_PROGRESS'
+    | 'COMPLETED'
+    | 'FAILED'
+    | 'CANCELLED'
+    | 'EXPIRED';
   totalTokens: number;
   durationMs?: number;
   estimatedCostUsd?: number;
@@ -37,7 +49,9 @@ export interface ListRunsOutput {
 /**
  * Mock handler for ListRunsQuery.
  */
-export async function mockListRunsHandler(input: ListRunsInput): Promise<ListRunsOutput> {
+export async function mockListRunsHandler(
+  input: ListRunsInput
+): Promise<ListRunsOutput> {
   const { agentId, status, limit = 20, offset = 0 } = input;
 
   let filtered = [...MOCK_RUNS];
@@ -66,14 +80,25 @@ export async function mockListRunsHandler(input: ListRunsInput): Promise<ListRun
 /**
  * Mock handler for GetRunQuery.
  */
-export async function mockGetRunHandler(input: { runId: string; includeSteps?: boolean; includeLogs?: boolean }) {
+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,
+    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,
   };
@@ -82,22 +107,32 @@ export async function mockGetRunHandler(input: { runId: string; includeSteps?: b
 /**
  * Mock handler for ExecuteAgentCommand.
  */
-export async function mockExecuteAgentHandler(input: { agentId: string; input: { message: string; context?: Record<string, unknown> } }) {
+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 };
+  return {
+    runId: `run-${Date.now()}`,
+    status: 'QUEUED' as const,
+    estimatedWaitMs: 500,
+  };
 }
 
 /**
  * Mock handler for CancelRunCommand.
  */
-export async function mockCancelRunHandler(input: { runId: string; reason?: string }) {
+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');
+  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

@@ -8,7 +8,8 @@ export const RunListPresentation: PresentationDescriptorV2 = {
   meta: {
     name: 'agent-console.run.list',
     version: 1,
-    description: 'List view of agent runs with status, tokens, and duration info',
+    description:
+      'List view of agent runs with status, tokens, and duration info',
     domain: 'agent-console',
     owners: ['agent-console-team'],
     tags: ['run', 'list', 'dashboard'],
@@ -43,5 +44,3 @@ export const RunDetailPresentation: PresentationDescriptorV2 = {
   targets: ['react', 'markdown'],
   policy: { flags: ['agent-console.enabled'] },
 };
-
-

package/src/run/run.schema.ts

@@ -29,7 +29,11 @@ export const RunStepModel = defineSchemaModel({
     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 },
+    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 },
@@ -64,7 +68,10 @@ export const RunAgentRefModel = defineSchemaModel({
   fields: {
     id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
     name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    modelProvider: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    modelProvider: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false,
+    },
     modelName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
   },
 });
@@ -77,7 +84,10 @@ export const RunModel = defineSchemaModel({
   description: 'Agent execution instance',
   fields: {
     id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: { 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 },
@@ -86,12 +96,31 @@ export const RunModel = defineSchemaModel({
     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 },
+    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 },
+    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 },
@@ -115,7 +144,10 @@ export const RunSummaryModel = defineSchemaModel({
     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 },
+    estimatedCostUsd: {
+      type: ScalarTypeEnum.Float_unsecure(),
+      isOptional: true,
+    },
     queuedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
     completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
   },
@@ -135,5 +167,3 @@ export const TimelineDataPointModel = defineSchemaModel({
     avgDurationMs: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
   },
 });
-
-

package/src/shared/mock-agents.ts

@@ -79,5 +79,3 @@ export const MOCK_AGENTS = [
     updatedAt: new Date('2024-04-01T12:00:00Z'),
   },
 ];
-
-

package/src/shared/mock-runs.ts

@@ -105,4 +105,3 @@ export const MOCK_RUNS = [
     logs: [],
   },
 ];
-