@contractspec/example.agent-console 3.7.5 → 3.7.7

package/dist/node/run/index.js

@@ -247,6 +247,159 @@ async function mockCancelRunHandler(input) {
   return { success: true, status: "CANCELLED" };
 }
 
+// src/run/run.entity.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var RunStatusEntityEnum = defineEntityEnum({
+  name: "RunStatus",
+  values: [
+    "QUEUED",
+    "IN_PROGRESS",
+    "COMPLETED",
+    "FAILED",
+    "CANCELLED",
+    "EXPIRED"
+  ],
+  description: "Status of an agent run"
+});
+var RunStepTypeEntityEnum = defineEntityEnum({
+  name: "RunStepType",
+  values: ["MESSAGE_CREATION", "TOOL_CALL", "TOOL_RESULT", "ERROR"],
+  description: "Type of run step"
+});
+var LogLevelEntityEnum = defineEntityEnum({
+  name: "LogLevel",
+  values: ["DEBUG", "INFO", "WARN", "ERROR"],
+  description: "Log level"
+});
+var 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]
+});
+var 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]
+});
+var 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]
+});
+
 // src/run/run.enum.ts
 import { defineEnum } from "@contractspec/lib.schema";
 var RunStatusEnum = defineEnum("RunStatus", [
@@ -276,145 +429,354 @@ var GranularityEnum = defineEnum("Granularity", [
   "month"
 ]);
 
-// src/run/run.schema.ts
-import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
-var RunInputModel = defineSchemaModel({
-  name: "RunInput",
-  description: "Input data for agent execution",
-  fields: {
-    message: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    context: { type: ScalarTypeEnum.JSONObject(), isOptional: true }
-  }
-});
-var 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 }
-  }
-});
-var 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 }
-  }
-});
-var RunAgentRefModel = defineSchemaModel({
-  name: "RunAgentRef",
-  description: "Agent reference in a run",
+// src/run/run.event.ts
+import { defineEvent } from "@contractspec/lib.contracts-spec";
+import {
+  defineEnum as defineEnum2,
+  defineSchemaModel,
+  ScalarTypeEnum
+} from "@contractspec/lib.schema";
+var OWNERS = ["@agent-console-team"];
+var RunStartedPayload = defineSchemaModel({
+  name: "RunStartedPayload",
+  description: "Payload for run started event",
   fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    modelProvider: {
+    runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    organizationId: {
       type: ScalarTypeEnum.String_unsecure(),
       isOptional: false
     },
-    modelName: { 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 },
+    sessionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    input: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
   }
 });
-var RunModel = defineSchemaModel({
-  name: "Run",
-  description: "Agent execution instance",
+var RunStartedEvent = defineEvent({
+  meta: {
+    key: "agent.run.started",
+    version: "1.0.0",
+    description: "An agent run was started.",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "started"]
+  },
+  payload: RunStartedPayload
+});
+var RunCompletedPayload = defineSchemaModel({
+  name: "RunCompletedPayload",
+  description: "Payload for run completed event",
   fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    runId: { 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 },
-    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
-    },
+    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,
-      defaultValue: 0
-    },
-    totalIterations: {
-      type: ScalarTypeEnum.Int_unsecure(),
-      isOptional: false,
-      defaultValue: 0
+      isOptional: false
     },
-    durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    totalIterations: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
     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 }
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
   }
 });
-var RunSummaryModel = defineSchemaModel({
-  name: "RunSummary",
-  description: "Summary of a run for list views",
+var RunCompletedEvent = defineEvent({
+  meta: {
+    key: "agent.run.completed",
+    version: "1.0.0",
+    description: "An agent run completed successfully.",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "completed"]
+  },
+  payload: RunCompletedPayload
+});
+var RunFailedPayload = defineSchemaModel({
+  name: "RunFailedPayload",
+  description: "Payload for run failed event",
   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 },
+    runId: { 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 },
+    errorMessage: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    errorCode: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
     totalTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    totalIterations: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
     durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    failedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var RunFailedEvent = defineEvent({
+  meta: {
+    key: "agent.run.failed",
+    version: "1.0.0",
+    description: "An agent run encountered an error.",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "failed"]
+  },
+  payload: RunFailedPayload
+});
+var RunCancelledPayload = defineSchemaModel({
+  name: "RunCancelledPayload",
+  description: "Payload for run cancelled event",
+  fields: {
+    runId: { 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 },
+    reason: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    totalTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    totalIterations: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    cancelledAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var RunCancelledEvent = defineEvent({
+  meta: {
+    key: "agent.run.cancelled",
+    version: "1.0.0",
+    description: "An agent run was cancelled by the user.",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "cancelled"]
+  },
+  payload: RunCancelledPayload
+});
+var ToolInvokedPayload = defineSchemaModel({
+  name: "ToolInvokedPayload",
+  description: "Payload for tool invoked event",
+  fields: {
+    runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    stepId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    toolId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    toolName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    input: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
+    invokedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var ToolInvokedEvent = defineEvent({
+  meta: {
+    key: "agent.run.toolInvoked",
+    version: "1.0.0",
+    description: "A tool was invoked during an agent run.",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "tool", "invoked"]
+  },
+  payload: ToolInvokedPayload
+});
+var ToolCompletedPayload = defineSchemaModel({
+  name: "ToolCompletedPayload",
+  description: "Payload for tool completed event",
+  fields: {
+    runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    stepId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    toolId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    toolName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    success: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    output: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    errorMessage: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var ToolCompletedEvent = defineEvent({
+  meta: {
+    key: "agent.run.toolCompleted",
+    version: "1.0.0",
+    description: "A tool invocation completed during an agent run.",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "tool", "completed"]
+  },
+  payload: ToolCompletedPayload
+});
+var MessageTypeEnum = defineEnum2("MessageType", ["assistant", "system"]);
+var MessageGeneratedPayload = defineSchemaModel({
+  name: "MessageGeneratedPayload",
+  description: "Payload for message generated event",
+  fields: {
+    runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    stepId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    messageType: { type: MessageTypeEnum, isOptional: false },
+    content: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    tokensUsed: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    generatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var MessageGeneratedEvent = defineEvent({
+  meta: {
+    key: "agent.run.messageGenerated",
+    version: "1.0.0",
+    description: "An agent generated a message during a run.",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "message", "generated"]
+  },
+  payload: MessageGeneratedPayload
+});
+
+// src/run/run.schema.ts
+import { defineSchemaModel as defineSchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
+var RunInputModel = defineSchemaModel2({
+  name: "RunInput",
+  description: "Input data for agent execution",
+  fields: {
+    message: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    context: { type: ScalarTypeEnum2.JSONObject(), isOptional: true }
+  }
+});
+var RunStepModel = defineSchemaModel2({
+  name: "RunStep",
+  description: "Individual step within a run",
+  fields: {
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    stepNumber: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    type: { type: RunStepTypeEnum, isOptional: false },
+    toolId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    toolName: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    input: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    output: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    status: { type: RunStatusEnum, isOptional: false },
+    errorMessage: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    tokensUsed: {
+      type: ScalarTypeEnum2.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    durationMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    startedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true }
+  }
+});
+var RunLogModel = defineSchemaModel2({
+  name: "RunLog",
+  description: "Execution log entry",
+  fields: {
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    stepId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    level: { type: LogLevelEnum, isOptional: false },
+    message: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    data: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    source: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    traceId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    spanId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    timestamp: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+var RunAgentRefModel = defineSchemaModel2({
+  name: "RunAgentRef",
+  description: "Agent reference in a run",
+  fields: {
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    modelProvider: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: false
+    },
+    modelName: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false }
+  }
+});
+var RunModel = defineSchemaModel2({
+  name: "Run",
+  description: "Agent execution instance",
+  fields: {
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: false
+    },
+    agentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    userId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    sessionId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    input: { type: ScalarTypeEnum2.JSONObject(), isOptional: false },
+    output: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    status: { type: RunStatusEnum, isOptional: false },
+    errorMessage: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    errorCode: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    totalTokens: {
+      type: ScalarTypeEnum2.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    promptTokens: {
+      type: ScalarTypeEnum2.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    completionTokens: {
+      type: ScalarTypeEnum2.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    totalIterations: {
+      type: ScalarTypeEnum2.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    durationMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
     estimatedCostUsd: {
-      type: ScalarTypeEnum.Float_unsecure(),
+      type: ScalarTypeEnum2.Float_unsecure(),
+      isOptional: true
+    },
+    queuedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    completedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    metadata: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    steps: { type: RunStepModel, isArray: true, isOptional: true },
+    logs: { type: RunLogModel, isArray: true, isOptional: true },
+    agent: { type: RunAgentRefModel, isOptional: true }
+  }
+});
+var RunSummaryModel = defineSchemaModel2({
+  name: "RunSummary",
+  description: "Summary of a run for list views",
+  fields: {
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    agentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    agentName: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    status: { type: RunStatusEnum, isOptional: false },
+    totalTokens: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    durationMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    estimatedCostUsd: {
+      type: ScalarTypeEnum2.Float_unsecure(),
       isOptional: true
     },
-    queuedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
-    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true }
+    queuedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true }
   }
 });
-var TimelineDataPointModel = defineSchemaModel({
+var TimelineDataPointModel = defineSchemaModel2({
   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 }
+    period: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    runs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    tokens: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    costUsd: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
+    avgDurationMs: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false }
   }
 });
 
@@ -423,42 +785,42 @@ import {
   defineCommand,
   defineQuery
 } from "@contractspec/lib.contracts-spec/operations";
-import { defineSchemaModel as defineSchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
-var OWNERS = ["@agent-console-team"];
+import { defineSchemaModel as defineSchemaModel3, ScalarTypeEnum as ScalarTypeEnum3 } from "@contractspec/lib.schema";
+var OWNERS2 = ["@agent-console-team"];
 var ExecuteAgentCommand = defineCommand({
   meta: {
     key: "agent.run.execute",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS],
+    owners: [...OWNERS2],
     tags: ["run", "execute"],
     description: "Starts a new agent run with the given input.",
     goal: "Execute an AI agent with user input.",
     context: "Called from chat interface or API."
   },
   io: {
-    input: defineSchemaModel2({
+    input: defineSchemaModel3({
       name: "ExecuteAgentInput",
       fields: {
-        agentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
         input: { type: RunInputModel, isOptional: false },
-        sessionId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-        metadata: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
-        stream: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+        sessionId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+        metadata: { type: ScalarTypeEnum3.JSONObject(), isOptional: true },
+        stream: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
         maxIterations: {
-          type: ScalarTypeEnum2.Int_unsecure(),
+          type: ScalarTypeEnum3.Int_unsecure(),
           isOptional: true
         },
-        timeoutMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true }
+        timeoutMs: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true }
       }
     }),
-    output: defineSchemaModel2({
+    output: defineSchemaModel3({
       name: "ExecuteAgentOutput",
       fields: {
-        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
         status: { type: RunStatusEnum, isOptional: false },
         estimatedWaitMs: {
-          type: ScalarTypeEnum2.Int_unsecure(),
+          type: ScalarTypeEnum3.Int_unsecure(),
           isOptional: true
         }
       }
@@ -485,7 +847,7 @@ var ExecuteAgentCommand = defineCommand({
         key: "run.started",
         version: "1.0.0",
         stability: "stable",
-        owners: [...OWNERS],
+        owners: [...OWNERS2],
         tags: ["run", "started"],
         when: "Run is queued",
         payload: RunSummaryModel
@@ -522,24 +884,24 @@ var CancelRunCommand = defineCommand({
     key: "agent.run.cancel",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS],
+    owners: [...OWNERS2],
     tags: ["run", "cancel"],
     description: "Cancels an in-progress agent run.",
     goal: "Stop a running agent execution.",
     context: "Called when user wants to abort a long-running task."
   },
   io: {
-    input: defineSchemaModel2({
+    input: defineSchemaModel3({
       name: "CancelRunInput",
       fields: {
-        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-        reason: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true }
+        runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        reason: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true }
       }
     }),
-    output: defineSchemaModel2({
+    output: defineSchemaModel3({
       name: "CancelRunOutput",
       fields: {
-        success: { type: ScalarTypeEnum2.Boolean(), isOptional: false },
+        success: { type: ScalarTypeEnum3.Boolean(), isOptional: false },
         status: { type: RunStatusEnum, isOptional: false }
       }
     }),
@@ -565,7 +927,7 @@ var CancelRunCommand = defineCommand({
         key: "run.cancelled",
         version: "1.0.0",
         stability: "stable",
-        owners: [...OWNERS],
+        owners: [...OWNERS2],
         tags: ["run", "cancelled"],
         when: "Run is cancelled",
         payload: RunSummaryModel
@@ -602,19 +964,19 @@ var GetRunQuery = defineQuery({
     key: "agent.run.get",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS],
+    owners: [...OWNERS2],
     tags: ["run", "get"],
     description: "Retrieves a run by its ID with optional details.",
     goal: "View detailed run information.",
     context: "Run details page or monitoring."
   },
   io: {
-    input: defineSchemaModel2({
+    input: defineSchemaModel3({
       name: "GetRunInput",
       fields: {
-        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-        includeSteps: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
-        includeLogs: { type: ScalarTypeEnum2.Boolean(), isOptional: true }
+        runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        includeSteps: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
+        includeLogs: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
       }
     }),
     output: RunModel,
@@ -651,44 +1013,44 @@ var ListRunsQuery = defineQuery({
     key: "agent.run.list",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS],
+    owners: [...OWNERS2],
     tags: ["run", "list"],
     description: "Lists runs with optional filtering.",
     goal: "Browse and search run history.",
     context: "Run history/dashboard view."
   },
   io: {
-    input: defineSchemaModel2({
+    input: defineSchemaModel3({
       name: "ListRunsInput",
       fields: {
         organizationId: {
-          type: ScalarTypeEnum2.String_unsecure(),
+          type: ScalarTypeEnum3.String_unsecure(),
           isOptional: true
         },
-        agentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-        userId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-        sessionId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+        agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+        userId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+        sessionId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
         status: { type: RunStatusEnum, isOptional: true },
-        startDate: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
-        endDate: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+        startDate: { type: ScalarTypeEnum3.DateTime(), isOptional: true },
+        endDate: { type: ScalarTypeEnum3.DateTime(), isOptional: true },
         limit: {
-          type: ScalarTypeEnum2.Int_unsecure(),
+          type: ScalarTypeEnum3.Int_unsecure(),
           isOptional: true,
           defaultValue: 20
         },
         offset: {
-          type: ScalarTypeEnum2.Int_unsecure(),
+          type: ScalarTypeEnum3.Int_unsecure(),
           isOptional: true,
           defaultValue: 0
         }
       }
     }),
-    output: defineSchemaModel2({
+    output: defineSchemaModel3({
       name: "ListRunsOutput",
       fields: {
         items: { type: RunSummaryModel, isArray: true, isOptional: false },
-        total: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
-        hasMore: { type: ScalarTypeEnum2.Boolean(), isOptional: false }
+        total: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum3.Boolean(), isOptional: false }
       }
     })
   },
@@ -716,20 +1078,20 @@ var GetRunStepsQuery = defineQuery({
     key: "agent.run.getSteps",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS],
+    owners: [...OWNERS2],
     tags: ["run", "steps"],
     description: "Retrieves all steps for a specific run.",
     goal: "View step-by-step execution details.",
     context: "Run details page - steps tab."
   },
   io: {
-    input: defineSchemaModel2({
+    input: defineSchemaModel3({
       name: "GetRunStepsInput",
       fields: {
-        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false }
+        runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false }
       }
     }),
-    output: defineSchemaModel2({
+    output: defineSchemaModel3({
       name: "GetRunStepsOutput",
       fields: {
         steps: { type: RunStepModel, isArray: true, isOptional: false }
@@ -760,37 +1122,37 @@ var GetRunLogsQuery = defineQuery({
     key: "agent.run.getLogs",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS],
+    owners: [...OWNERS2],
     tags: ["run", "logs"],
     description: "Retrieves all logs for a specific run.",
     goal: "Debug and audit run execution.",
     context: "Run details page - logs tab."
   },
   io: {
-    input: defineSchemaModel2({
+    input: defineSchemaModel3({
       name: "GetRunLogsInput",
       fields: {
-        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
         level: { type: LogLevelEnum, isOptional: true },
-        stepId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+        stepId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
         limit: {
-          type: ScalarTypeEnum2.Int_unsecure(),
+          type: ScalarTypeEnum3.Int_unsecure(),
           isOptional: true,
           defaultValue: 100
         },
         offset: {
-          type: ScalarTypeEnum2.Int_unsecure(),
+          type: ScalarTypeEnum3.Int_unsecure(),
           isOptional: true,
           defaultValue: 0
         }
       }
     }),
-    output: defineSchemaModel2({
+    output: defineSchemaModel3({
       name: "GetRunLogsOutput",
       fields: {
         items: { type: RunLogModel, isArray: true, isOptional: false },
-        total: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
-        hasMore: { type: ScalarTypeEnum2.Boolean(), isOptional: false }
+        total: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum3.Boolean(), isOptional: false }
       }
     })
   },
@@ -818,23 +1180,23 @@ var GetRunMetricsQuery = defineQuery({
     key: "agent.run.getMetrics",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS],
+    owners: [...OWNERS2],
     tags: ["run", "metrics"],
     description: "Retrieves aggregated metrics for runs within a time period.",
     goal: "Monitor and analyze agent usage.",
     context: "Analytics dashboard."
   },
   io: {
-    input: defineSchemaModel2({
+    input: defineSchemaModel3({
       name: "GetRunMetricsInput",
       fields: {
         organizationId: {
-          type: ScalarTypeEnum2.String_unsecure(),
+          type: ScalarTypeEnum3.String_unsecure(),
           isOptional: false
         },
-        agentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-        startDate: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-        endDate: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+        agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+        startDate: { type: ScalarTypeEnum3.DateTime(), isOptional: false },
+        endDate: { type: ScalarTypeEnum3.DateTime(), isOptional: false },
         granularity: {
           type: GranularityEnum,
           isOptional: true,
@@ -842,26 +1204,26 @@ var GetRunMetricsQuery = defineQuery({
         }
       }
     }),
-    output: defineSchemaModel2({
+    output: defineSchemaModel3({
       name: "GetRunMetricsOutput",
       fields: {
-        totalRuns: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        totalRuns: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
         completedRuns: {
-          type: ScalarTypeEnum2.Int_unsecure(),
+          type: ScalarTypeEnum3.Int_unsecure(),
           isOptional: false
         },
-        failedRuns: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
-        totalTokens: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        failedRuns: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+        totalTokens: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
         totalCostUsd: {
-          type: ScalarTypeEnum2.Float_unsecure(),
+          type: ScalarTypeEnum3.Float_unsecure(),
           isOptional: false
         },
         averageDurationMs: {
-          type: ScalarTypeEnum2.Float_unsecure(),
+          type: ScalarTypeEnum3.Float_unsecure(),
           isOptional: false
         },
         successRate: {
-          type: ScalarTypeEnum2.Float_unsecure(),
+          type: ScalarTypeEnum3.Float_unsecure(),
           isOptional: false
         },
         timeline: {
@@ -906,372 +1268,10 @@ var GetRunMetricsQuery = defineQuery({
   }
 });
 
-// src/run/run.event.ts
-import { defineEvent } from "@contractspec/lib.contracts-spec";
-import {
-  ScalarTypeEnum as ScalarTypeEnum3,
-  defineEnum as defineEnum2,
-  defineSchemaModel as defineSchemaModel3
-} from "@contractspec/lib.schema";
-var OWNERS2 = ["@agent-console-team"];
-var RunStartedPayload = defineSchemaModel3({
-  name: "RunStartedPayload",
-  description: "Payload for run started event",
-  fields: {
-    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    organizationId: {
-      type: ScalarTypeEnum3.String_unsecure(),
-      isOptional: false
-    },
-    agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    agentName: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    userId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    sessionId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    input: { type: ScalarTypeEnum3.JSONObject(), isOptional: false },
-    startedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
-  }
-});
-var RunStartedEvent = defineEvent({
-  meta: {
-    key: "agent.run.started",
-    version: "1.0.0",
-    description: "An agent run was started.",
-    stability: "stable",
-    owners: [...OWNERS2],
-    tags: ["run", "started"]
-  },
-  payload: RunStartedPayload
-});
-var RunCompletedPayload = defineSchemaModel3({
-  name: "RunCompletedPayload",
-  description: "Payload for run completed event",
-  fields: {
-    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    organizationId: {
-      type: ScalarTypeEnum3.String_unsecure(),
-      isOptional: false
-    },
-    agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    agentName: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    userId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    output: { type: ScalarTypeEnum3.JSONObject(), isOptional: false },
-    totalTokens: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    promptTokens: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    completionTokens: {
-      type: ScalarTypeEnum3.Int_unsecure(),
-      isOptional: false
-    },
-    totalIterations: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    durationMs: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    estimatedCostUsd: {
-      type: ScalarTypeEnum3.Float_unsecure(),
-      isOptional: true
-    },
-    completedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
-  }
-});
-var RunCompletedEvent = defineEvent({
-  meta: {
-    key: "agent.run.completed",
-    version: "1.0.0",
-    description: "An agent run completed successfully.",
-    stability: "stable",
-    owners: [...OWNERS2],
-    tags: ["run", "completed"]
-  },
-  payload: RunCompletedPayload
-});
-var RunFailedPayload = defineSchemaModel3({
-  name: "RunFailedPayload",
-  description: "Payload for run failed event",
-  fields: {
-    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    organizationId: {
-      type: ScalarTypeEnum3.String_unsecure(),
-      isOptional: false
-    },
-    agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    agentName: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    userId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    errorMessage: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    errorCode: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    totalTokens: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    totalIterations: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    durationMs: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true },
-    failedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
-  }
-});
-var RunFailedEvent = defineEvent({
-  meta: {
-    key: "agent.run.failed",
-    version: "1.0.0",
-    description: "An agent run encountered an error.",
-    stability: "stable",
-    owners: [...OWNERS2],
-    tags: ["run", "failed"]
-  },
-  payload: RunFailedPayload
-});
-var RunCancelledPayload = defineSchemaModel3({
-  name: "RunCancelledPayload",
-  description: "Payload for run cancelled event",
-  fields: {
-    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    organizationId: {
-      type: ScalarTypeEnum3.String_unsecure(),
-      isOptional: false
-    },
-    agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    userId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    cancelledBy: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    reason: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    totalTokens: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    totalIterations: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    cancelledAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
-  }
-});
-var RunCancelledEvent = defineEvent({
-  meta: {
-    key: "agent.run.cancelled",
-    version: "1.0.0",
-    description: "An agent run was cancelled by the user.",
-    stability: "stable",
-    owners: [...OWNERS2],
-    tags: ["run", "cancelled"]
-  },
-  payload: RunCancelledPayload
-});
-var ToolInvokedPayload = defineSchemaModel3({
-  name: "ToolInvokedPayload",
-  description: "Payload for tool invoked event",
-  fields: {
-    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    stepId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    toolId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    toolName: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    input: { type: ScalarTypeEnum3.JSONObject(), isOptional: false },
-    invokedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
-  }
-});
-var ToolInvokedEvent = defineEvent({
-  meta: {
-    key: "agent.run.toolInvoked",
-    version: "1.0.0",
-    description: "A tool was invoked during an agent run.",
-    stability: "stable",
-    owners: [...OWNERS2],
-    tags: ["run", "tool", "invoked"]
-  },
-  payload: ToolInvokedPayload
-});
-var ToolCompletedPayload = defineSchemaModel3({
-  name: "ToolCompletedPayload",
-  description: "Payload for tool completed event",
-  fields: {
-    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    stepId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    toolId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    toolName: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    success: { type: ScalarTypeEnum3.Boolean(), isOptional: false },
-    output: { type: ScalarTypeEnum3.JSONObject(), isOptional: true },
-    errorMessage: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    durationMs: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    completedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
-  }
-});
-var ToolCompletedEvent = defineEvent({
-  meta: {
-    key: "agent.run.toolCompleted",
-    version: "1.0.0",
-    description: "A tool invocation completed during an agent run.",
-    stability: "stable",
-    owners: [...OWNERS2],
-    tags: ["run", "tool", "completed"]
-  },
-  payload: ToolCompletedPayload
-});
-var MessageTypeEnum = defineEnum2("MessageType", ["assistant", "system"]);
-var MessageGeneratedPayload = defineSchemaModel3({
-  name: "MessageGeneratedPayload",
-  description: "Payload for message generated event",
-  fields: {
-    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    stepId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    messageType: { type: MessageTypeEnum, isOptional: false },
-    content: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    tokensUsed: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    generatedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
-  }
-});
-var MessageGeneratedEvent = defineEvent({
-  meta: {
-    key: "agent.run.messageGenerated",
-    version: "1.0.0",
-    description: "An agent generated a message during a run.",
-    stability: "stable",
-    owners: [...OWNERS2],
-    tags: ["run", "message", "generated"]
-  },
-  payload: MessageGeneratedPayload
-});
-
-// src/run/run.entity.ts
-import {
-  defineEntity,
-  defineEntityEnum,
-  field,
-  index
-} from "@contractspec/lib.schema";
-var RunStatusEntityEnum = defineEntityEnum({
-  name: "RunStatus",
-  values: [
-    "QUEUED",
-    "IN_PROGRESS",
-    "COMPLETED",
-    "FAILED",
-    "CANCELLED",
-    "EXPIRED"
-  ],
-  description: "Status of an agent run"
-});
-var RunStepTypeEntityEnum = defineEntityEnum({
-  name: "RunStepType",
-  values: ["MESSAGE_CREATION", "TOOL_CALL", "TOOL_RESULT", "ERROR"],
-  description: "Type of run step"
-});
-var LogLevelEntityEnum = defineEntityEnum({
-  name: "LogLevel",
-  values: ["DEBUG", "INFO", "WARN", "ERROR"],
-  description: "Log level"
-});
-var 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]
-});
-var 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]
-});
-var 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]
-});
-
 // src/run/run.presentation.ts
 import {
-  StabilityEnum,
-  definePresentation
+  definePresentation,
+  StabilityEnum
 } from "@contractspec/lib.contracts-spec";
 var RunListPresentation = definePresentation({
   meta: {