@contractspec/example.agent-console 1.57.0 → 1.58.0

package/dist/run/index.js

@@ -1,9 +1,1351 @@
-import { GranularityEnum, LogLevelEnum, RunStatusEnum, RunStepTypeEnum } from "./run.enum.js";
-import { RunAgentRefModel, RunInputModel, RunLogModel, RunModel, RunStepModel, RunSummaryModel, TimelineDataPointModel } from "./run.schema.js";
-import { CancelRunCommand, ExecuteAgentCommand, GetRunLogsQuery, GetRunMetricsQuery, GetRunQuery, GetRunStepsQuery, ListRunsQuery } from "./run.operation.js";
-import { MessageGeneratedEvent, RunCancelledEvent, RunCompletedEvent, RunFailedEvent, RunStartedEvent, ToolCompletedEvent, ToolInvokedEvent } from "./run.event.js";
-import { LogLevelEntityEnum, RunEntity, RunLogEntity, RunStatusEntityEnum, RunStepEntity, RunStepTypeEntityEnum } from "./run.entity.js";
-import { RunDetailPresentation, RunListPresentation } from "./run.presentation.js";
-import { mockCancelRunHandler, mockExecuteAgentHandler, mockGetRunHandler, mockListRunsHandler } from "./run.handler.js";
-
-export { CancelRunCommand, ExecuteAgentCommand, GetRunLogsQuery, GetRunMetricsQuery, GetRunQuery, GetRunStepsQuery, GranularityEnum, ListRunsQuery, LogLevelEntityEnum, LogLevelEnum, MessageGeneratedEvent, RunAgentRefModel, RunCancelledEvent, RunCompletedEvent, RunDetailPresentation, RunEntity, RunFailedEvent, RunInputModel, RunListPresentation, RunLogEntity, RunLogModel, RunModel, RunStartedEvent, RunStatusEntityEnum, RunStatusEnum, RunStepEntity, RunStepModel, RunStepTypeEntityEnum, RunStepTypeEnum, RunSummaryModel, TimelineDataPointModel, ToolCompletedEvent, ToolInvokedEvent, mockCancelRunHandler, mockExecuteAgentHandler, mockGetRunHandler, mockListRunsHandler };
+// @bun
+// src/shared/mock-agents.ts
+var MOCK_AGENTS = [
+  {
+    id: "agent-1",
+    organizationId: "demo-org",
+    name: "Customer Support Bot",
+    slug: "customer-support-bot",
+    description: "Handles tier-1 customer inquiries and routes complex issues.",
+    status: "ACTIVE",
+    modelProvider: "OPENAI",
+    modelName: "gpt-4o-mini",
+    modelConfig: { temperature: 0.7 },
+    systemPrompt: "You are a helpful customer support assistant.",
+    toolChoice: "auto",
+    maxIterations: 10,
+    timeoutMs: 120000,
+    version: "1.0.0",
+    tags: ["support", "tier-1"],
+    createdAt: new Date("2024-01-15T10:00:00Z"),
+    updatedAt: new Date("2024-03-20T14:30:00Z")
+  },
+  {
+    id: "agent-2",
+    organizationId: "demo-org",
+    name: "Code Review Assistant",
+    slug: "code-review-assistant",
+    description: "Reviews pull requests and provides actionable feedback.",
+    status: "ACTIVE",
+    modelProvider: "ANTHROPIC",
+    modelName: "claude-sonnet-4-20250514",
+    modelConfig: { temperature: 0.3 },
+    systemPrompt: "You are a code review expert.",
+    toolChoice: "auto",
+    maxIterations: 15,
+    timeoutMs: 180000,
+    version: "2.1.0",
+    tags: ["code", "review", "dev"],
+    createdAt: new Date("2024-02-10T09:00:00Z"),
+    updatedAt: new Date("2024-04-05T11:15:00Z")
+  },
+  {
+    id: "agent-3",
+    organizationId: "demo-org",
+    name: "Data Analyst",
+    slug: "data-analyst",
+    description: "Queries databases and generates insights from data.",
+    status: "PAUSED",
+    modelProvider: "OPENAI",
+    modelName: "gpt-4o",
+    modelConfig: { temperature: 0.5 },
+    systemPrompt: "You are a data analyst expert in SQL and analytics.",
+    toolChoice: "required",
+    maxIterations: 20,
+    timeoutMs: 300000,
+    version: "1.2.0",
+    tags: ["data", "analytics", "sql"],
+    createdAt: new Date("2024-03-01T08:00:00Z"),
+    updatedAt: new Date("2024-04-10T16:45:00Z")
+  },
+  {
+    id: "agent-4",
+    organizationId: "demo-org",
+    name: "Meeting Scheduler",
+    slug: "meeting-scheduler",
+    description: "Schedules meetings and manages calendar conflicts.",
+    status: "DRAFT",
+    modelProvider: "GOOGLE",
+    modelName: "gemini-2.0-flash",
+    modelConfig: { temperature: 0.2 },
+    systemPrompt: "You help schedule and organize meetings efficiently.",
+    toolChoice: "auto",
+    maxIterations: 5,
+    timeoutMs: 60000,
+    version: "0.1.0",
+    tags: ["calendar", "scheduling"],
+    createdAt: new Date("2024-04-01T12:00:00Z"),
+    updatedAt: new Date("2024-04-01T12:00:00Z")
+  }
+];
+
+// src/shared/mock-runs.ts
+var MOCK_RUNS = [
+  {
+    id: "run-1",
+    organizationId: "demo-org",
+    agentId: "agent-1",
+    agentName: "Customer Support Bot",
+    userId: "user-1",
+    sessionId: "session-1",
+    input: { message: "How do I reset my password?", context: {} },
+    output: { response: "You can reset your password by clicking..." },
+    status: "COMPLETED",
+    totalTokens: 1250,
+    promptTokens: 800,
+    completionTokens: 450,
+    totalIterations: 3,
+    durationMs: 4500,
+    estimatedCostUsd: 0.0025,
+    queuedAt: new Date("2024-04-15T10:00:00Z"),
+    startedAt: new Date("2024-04-15T10:00:01Z"),
+    completedAt: new Date("2024-04-15T10:00:05Z"),
+    steps: [],
+    logs: []
+  },
+  {
+    id: "run-2",
+    organizationId: "demo-org",
+    agentId: "agent-2",
+    agentName: "Code Review Assistant",
+    userId: "user-2",
+    input: { message: "Review PR #123", context: { prNumber: 123 } },
+    status: "IN_PROGRESS",
+    totalTokens: 3500,
+    promptTokens: 3000,
+    completionTokens: 500,
+    totalIterations: 5,
+    queuedAt: new Date("2024-04-15T10:30:00Z"),
+    startedAt: new Date("2024-04-15T10:30:02Z"),
+    steps: [],
+    logs: []
+  },
+  {
+    id: "run-3",
+    organizationId: "demo-org",
+    agentId: "agent-1",
+    agentName: "Customer Support Bot",
+    userId: "user-1",
+    input: { message: "What are your business hours?" },
+    output: { response: "Our business hours are 9 AM to 5 PM EST..." },
+    status: "COMPLETED",
+    totalTokens: 800,
+    promptTokens: 500,
+    completionTokens: 300,
+    totalIterations: 2,
+    durationMs: 2100,
+    estimatedCostUsd: 0.0012,
+    queuedAt: new Date("2024-04-15T09:00:00Z"),
+    startedAt: new Date("2024-04-15T09:00:01Z"),
+    completedAt: new Date("2024-04-15T09:00:03Z"),
+    steps: [],
+    logs: []
+  },
+  {
+    id: "run-4",
+    organizationId: "demo-org",
+    agentId: "agent-3",
+    agentName: "Data Analyst",
+    userId: "user-3",
+    input: { message: "Generate sales report for Q1" },
+    status: "FAILED",
+    errorMessage: "Database connection timeout",
+    errorCode: "DB_TIMEOUT",
+    totalTokens: 2000,
+    promptTokens: 1500,
+    completionTokens: 500,
+    totalIterations: 8,
+    durationMs: 45000,
+    queuedAt: new Date("2024-04-14T15:00:00Z"),
+    startedAt: new Date("2024-04-14T15:00:05Z"),
+    completedAt: new Date("2024-04-14T15:00:50Z"),
+    steps: [],
+    logs: []
+  },
+  {
+    id: "run-5",
+    organizationId: "demo-org",
+    agentId: "agent-2",
+    agentName: "Code Review Assistant",
+    userId: "user-2",
+    input: { message: "Review PR #120" },
+    output: { response: "Code review complete. 3 suggestions..." },
+    status: "COMPLETED",
+    totalTokens: 5200,
+    promptTokens: 4000,
+    completionTokens: 1200,
+    totalIterations: 7,
+    durationMs: 15000,
+    estimatedCostUsd: 0.0156,
+    queuedAt: new Date("2024-04-14T11:00:00Z"),
+    startedAt: new Date("2024-04-14T11:00:03Z"),
+    completedAt: new Date("2024-04-14T11:00:18Z"),
+    steps: [],
+    logs: []
+  }
+];
+
+// src/run/run.handler.ts
+async function mockListRunsHandler(input) {
+  const { agentId, status, limit = 20, offset = 0 } = input;
+  let filtered = [...MOCK_RUNS];
+  if (agentId)
+    filtered = filtered.filter((r) => r.agentId === agentId);
+  if (status)
+    filtered = filtered.filter((r) => r.status === status);
+  const total = filtered.length;
+  const items = filtered.slice(offset, offset + limit).map((r) => {
+    const agent = MOCK_AGENTS.find((a) => a.id === r.agentId);
+    return {
+      id: r.id,
+      agentId: r.agentId,
+      agentName: agent?.name ?? "Unknown",
+      status: r.status,
+      totalTokens: r.totalTokens,
+      durationMs: r.durationMs,
+      estimatedCostUsd: r.estimatedCostUsd,
+      queuedAt: r.queuedAt,
+      completedAt: r.completedAt
+    };
+  });
+  return { items, total, hasMore: offset + limit < total };
+}
+async function mockGetRunHandler(input) {
+  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,
+    steps: input.includeSteps ? run.steps : undefined,
+    logs: input.includeLogs ? run.logs : undefined
+  };
+}
+async function mockExecuteAgentHandler(input) {
+  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",
+    estimatedWaitMs: 500
+  };
+}
+async function mockCancelRunHandler(input) {
+  const run = MOCK_RUNS.find((r) => r.id === input.runId);
+  if (!run)
+    throw new Error("RUN_NOT_FOUND");
+  if (!["QUEUED", "IN_PROGRESS"].includes(run.status))
+    throw new Error("RUN_NOT_CANCELLABLE");
+  return { success: true, status: "CANCELLED" };
+}
+
+// src/run/run.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var RunStatusEnum = defineEnum("RunStatus", [
+  "QUEUED",
+  "IN_PROGRESS",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED",
+  "EXPIRED"
+]);
+var RunStepTypeEnum = defineEnum("RunStepType", [
+  "MESSAGE_CREATION",
+  "TOOL_CALL",
+  "TOOL_RESULT",
+  "ERROR"
+]);
+var LogLevelEnum = defineEnum("LogLevel", [
+  "DEBUG",
+  "INFO",
+  "WARN",
+  "ERROR"
+]);
+var GranularityEnum = defineEnum("Granularity", [
+  "hour",
+  "day",
+  "week",
+  "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",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    modelProvider: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    modelName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false }
+  }
+});
+var RunModel = defineSchemaModel({
+  name: "Run",
+  description: "Agent execution instance",
+  fields: {
+    id: { 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 },
+    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
+    },
+    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
+    },
+    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 }
+  }
+});
+var RunSummaryModel = defineSchemaModel({
+  name: "RunSummary",
+  description: "Summary of a run for list views",
+  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 },
+    totalTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    estimatedCostUsd: {
+      type: ScalarTypeEnum.Float_unsecure(),
+      isOptional: true
+    },
+    queuedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true }
+  }
+});
+var TimelineDataPointModel = defineSchemaModel({
+  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 }
+  }
+});
+
+// src/run/run.operation.ts
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts/operations";
+import { defineSchemaModel as defineSchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
+var OWNERS = ["@agent-console-team"];
+var ExecuteAgentCommand = defineCommand({
+  meta: {
+    key: "agent.run.execute",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    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({
+      name: "ExecuteAgentInput",
+      fields: {
+        agentId: { type: ScalarTypeEnum2.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 },
+        maxIterations: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true
+        },
+        timeoutMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "ExecuteAgentOutput",
+      fields: {
+        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        status: { type: RunStatusEnum, isOptional: false },
+        estimatedWaitMs: {
+          type: ScalarTypeEnum2.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"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "run.started",
+        version: "1.0.0",
+        stability: "stable",
+        owners: [...OWNERS],
+        tags: ["run", "started"],
+        when: "Run is queued",
+        payload: RunSummaryModel
+      }
+    ],
+    audit: ["run.started"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "execute-agent-happy-path",
+        given: ["Agent exists", "Agent is active"],
+        when: ["User submits execution request"],
+        then: ["Run is created", "RunStarted event is emitted"]
+      },
+      {
+        key: "execute-agent-not-active",
+        given: ["Agent exists but is not active"],
+        when: ["User attempts to execute"],
+        then: ["AGENT_NOT_ACTIVE error is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "basic-execute",
+        input: { agentId: "agent-123", input: { message: "Hello" } },
+        output: { runId: "run-456", status: "pending", estimatedWaitMs: 5000 }
+      }
+    ]
+  }
+});
+var CancelRunCommand = defineCommand({
+  meta: {
+    key: "agent.run.cancel",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    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({
+      name: "CancelRunInput",
+      fields: {
+        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        reason: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "CancelRunOutput",
+      fields: {
+        success: { type: ScalarTypeEnum2.Boolean(), isOptional: false },
+        status: { type: RunStatusEnum, isOptional: false }
+      }
+    }),
+    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"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "run.cancelled",
+        version: "1.0.0",
+        stability: "stable",
+        owners: [...OWNERS],
+        tags: ["run", "cancelled"],
+        when: "Run is cancelled",
+        payload: RunSummaryModel
+      }
+    ],
+    audit: ["run.cancelled"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "cancel-run-happy-path",
+        given: ["Run exists", "Run is in progress"],
+        when: ["User cancels run"],
+        then: ["Run is cancelled", "RunCancelled event is emitted"]
+      },
+      {
+        key: "cancel-run-already-completed",
+        given: ["Run exists but is already completed"],
+        when: ["User attempts to cancel"],
+        then: ["RUN_NOT_CANCELLABLE error is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "cancel-basic",
+        input: { runId: "run-456", reason: "User requested" },
+        output: { success: true, status: "cancelled" }
+      }
+    ]
+  }
+});
+var GetRunQuery = defineQuery({
+  meta: {
+    key: "agent.run.get",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    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({
+      name: "GetRunInput",
+      fields: {
+        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        includeSteps: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+        includeLogs: { type: ScalarTypeEnum2.Boolean(), isOptional: true }
+      }
+    }),
+    output: RunModel,
+    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" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-run-happy-path",
+        given: ["Run exists"],
+        when: ["User requests run by ID"],
+        then: ["Run details are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-with-steps",
+        input: { runId: "run-456", includeSteps: true, includeLogs: false },
+        output: { id: "run-456", status: "completed", steps: [] }
+      }
+    ]
+  }
+});
+var ListRunsQuery = defineQuery({
+  meta: {
+    key: "agent.run.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "list"],
+    description: "Lists runs with optional filtering.",
+    goal: "Browse and search run history.",
+    context: "Run history/dashboard view."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "ListRunsInput",
+      fields: {
+        organizationId: {
+          type: ScalarTypeEnum2.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 },
+        status: { type: RunStatusEnum, isOptional: true },
+        startDate: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+        endDate: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+        limit: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 20
+        },
+        offset: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "ListRunsOutput",
+      fields: {
+        items: { type: RunSummaryModel, isArray: true, isOptional: false },
+        total: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum2.Boolean(), isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "list-runs-happy-path",
+        given: ["Organization has runs"],
+        when: ["User lists runs"],
+        then: ["Paginated list of runs is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "list-by-agent",
+        input: { agentId: "agent-123", limit: 20, offset: 0 },
+        output: { items: [], total: 0, hasMore: false }
+      }
+    ]
+  }
+});
+var GetRunStepsQuery = defineQuery({
+  meta: {
+    key: "agent.run.getSteps",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    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({
+      name: "GetRunStepsInput",
+      fields: {
+        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "GetRunStepsOutput",
+      fields: {
+        steps: { type: RunStepModel, isArray: true, isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-run-steps-happy-path",
+        given: ["Run exists with steps"],
+        when: ["User requests steps"],
+        then: ["Steps list is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-steps-basic",
+        input: { runId: "run-456" },
+        output: { steps: [] }
+      }
+    ]
+  }
+});
+var GetRunLogsQuery = defineQuery({
+  meta: {
+    key: "agent.run.getLogs",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    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({
+      name: "GetRunLogsInput",
+      fields: {
+        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        level: { type: LogLevelEnum, isOptional: true },
+        stepId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+        limit: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 100
+        },
+        offset: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "GetRunLogsOutput",
+      fields: {
+        items: { type: RunLogModel, isArray: true, isOptional: false },
+        total: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum2.Boolean(), isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-run-logs-happy-path",
+        given: ["Run exists with logs"],
+        when: ["User requests logs"],
+        then: ["Paginated logs list is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-logs-filtered",
+        input: { runId: "run-456", level: "error", limit: 50 },
+        output: { items: [], total: 0, hasMore: false }
+      }
+    ]
+  }
+});
+var GetRunMetricsQuery = defineQuery({
+  meta: {
+    key: "agent.run.getMetrics",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    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({
+      name: "GetRunMetricsInput",
+      fields: {
+        organizationId: {
+          type: ScalarTypeEnum2.String_unsecure(),
+          isOptional: false
+        },
+        agentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+        startDate: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+        endDate: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+        granularity: {
+          type: GranularityEnum,
+          isOptional: true,
+          defaultValue: "day"
+        }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "GetRunMetricsOutput",
+      fields: {
+        totalRuns: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        completedRuns: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: false
+        },
+        failedRuns: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        totalTokens: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        totalCostUsd: {
+          type: ScalarTypeEnum2.Float_unsecure(),
+          isOptional: false
+        },
+        averageDurationMs: {
+          type: ScalarTypeEnum2.Float_unsecure(),
+          isOptional: false
+        },
+        successRate: {
+          type: ScalarTypeEnum2.Float_unsecure(),
+          isOptional: false
+        },
+        timeline: {
+          type: TimelineDataPointModel,
+          isArray: true,
+          isOptional: false
+        }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-run-metrics-happy-path",
+        given: ["Organization has run history"],
+        when: ["User requests metrics for date range"],
+        then: ["Aggregated metrics are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-daily-metrics",
+        input: {
+          organizationId: "org-123",
+          startDate: "2025-01-01",
+          endDate: "2025-01-31",
+          granularity: "day"
+        },
+        output: {
+          totalRuns: 100,
+          completedRuns: 90,
+          failedRuns: 10,
+          totalTokens: 50000,
+          totalCostUsd: 5,
+          averageDurationMs: 2500,
+          successRate: 0.9,
+          timeline: []
+        }
+      }
+    ]
+  }
+});
+
+// src/run/run.event.ts
+import { defineEvent, defineSchemaModel as defineSchemaModel3 } from "@contractspec/lib.contracts";
+import { ScalarTypeEnum as ScalarTypeEnum3, defineEnum as defineEnum2 } 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 } from "@contractspec/lib.contracts";
+var RunListPresentation = definePresentation({
+  meta: {
+    key: "agent-console.run.list",
+    version: "1.0.0",
+    title: "Run List",
+    description: "List view of agent runs with status, tokens, and duration info",
+    goal: "Provide an overview of agent execution history and performance.",
+    context: "Run history dashboard.",
+    domain: "agent-console",
+    owners: ["@agent-console-team"],
+    tags: ["run", "list", "dashboard"],
+    stability: StabilityEnum.Experimental
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "RunListView",
+    props: RunSummaryModel
+  },
+  targets: ["react", "markdown", "application/json"],
+  policy: { flags: ["agent-console.enabled"] }
+});
+var RunDetailPresentation = definePresentation({
+  meta: {
+    key: "agent-console.run.detail",
+    version: "1.0.0",
+    title: "Run Details",
+    description: "Detailed view of an agent run with steps, logs, and metrics",
+    goal: "Allow users to inspect and debug a specific agent run.",
+    context: "Detailed view of an agent run.",
+    domain: "agent-console",
+    owners: ["@agent-console-team"],
+    tags: ["run", "detail"],
+    stability: StabilityEnum.Experimental
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "RunDetailView"
+  },
+  targets: ["react", "markdown"],
+  policy: { flags: ["agent-console.enabled"] }
+});
+export {
+  mockListRunsHandler,
+  mockGetRunHandler,
+  mockExecuteAgentHandler,
+  mockCancelRunHandler,
+  ToolInvokedEvent,
+  ToolCompletedEvent,
+  TimelineDataPointModel,
+  RunSummaryModel,
+  RunStepTypeEnum,
+  RunStepTypeEntityEnum,
+  RunStepModel,
+  RunStepEntity,
+  RunStatusEnum,
+  RunStatusEntityEnum,
+  RunStartedEvent,
+  RunModel,
+  RunLogModel,
+  RunLogEntity,
+  RunListPresentation,
+  RunInputModel,
+  RunFailedEvent,
+  RunEntity,
+  RunDetailPresentation,
+  RunCompletedEvent,
+  RunCancelledEvent,
+  RunAgentRefModel,
+  MessageGeneratedEvent,
+  LogLevelEnum,
+  LogLevelEntityEnum,
+  ListRunsQuery,
+  GranularityEnum,
+  GetRunStepsQuery,
+  GetRunQuery,
+  GetRunMetricsQuery,
+  GetRunLogsQuery,
+  ExecuteAgentCommand,
+  CancelRunCommand
+};