@contractspec/example.agent-console 3.7.7 → 3.8.2

package/dist/node/handlers/index.js

@@ -1,3 +1,135 @@
+// src/agent/agent.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var AgentStatusEnum = defineEnum("AgentStatus", [
+  "DRAFT",
+  "ACTIVE",
+  "PAUSED",
+  "ARCHIVED"
+]);
+var ModelProviderEnum = defineEnum("ModelProvider", [
+  "OPENAI",
+  "ANTHROPIC",
+  "GOOGLE",
+  "MISTRAL",
+  "CUSTOM"
+]);
+var ToolChoiceEnum = defineEnum("ToolChoice", [
+  "auto",
+  "required",
+  "none"
+]);
+
+// src/agent/agent.event.ts
+import { defineEvent } from "@contractspec/lib.contracts-spec";
+import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
+var OWNERS = ["@agent-console-team"];
+var AgentCreatedPayload = defineSchemaModel({
+  name: "AgentCreatedPayload",
+  description: "Payload for agent created event",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    slug: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    modelProvider: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    modelName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    toolCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    createdById: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var AgentCreatedEvent = defineEvent({
+  meta: {
+    key: "agent-console.agent.created",
+    version: "1.0.0",
+    description: "A new AI agent was configured.",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["agent", "created"]
+  },
+  payload: AgentCreatedPayload
+});
+var AgentUpdatedPayload = defineSchemaModel({
+  name: "AgentUpdatedPayload",
+  description: "Payload for agent updated event",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    status: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    updatedFields: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isArray: true,
+      isOptional: false
+    },
+    updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var AgentUpdatedEvent = defineEvent({
+  meta: {
+    key: "agent-console.agent.updated",
+    version: "1.0.0",
+    description: "An AI agent configuration was updated.",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["agent", "updated"]
+  },
+  payload: AgentUpdatedPayload
+});
+var AgentToolAssignedPayload = defineSchemaModel({
+  name: "AgentToolAssignedPayload",
+  description: "Payload for agent tool assigned event",
+  fields: {
+    agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    toolId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    agentName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    toolName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    assignedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var AgentToolAssignedEvent = defineEvent({
+  meta: {
+    key: "agent-console.agent.toolAssigned",
+    version: "1.0.0",
+    description: "A tool was assigned to an agent.",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["agent", "tool", "assigned"]
+  },
+  payload: AgentToolAssignedPayload
+});
+var AgentToolRemovedPayload = defineSchemaModel({
+  name: "AgentToolRemovedPayload",
+  description: "Payload for agent tool removed event",
+  fields: {
+    agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    toolId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    agentName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    toolName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    removedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var AgentToolRemovedEvent = defineEvent({
+  meta: {
+    key: "agent-console.agent.toolRemoved",
+    version: "1.0.0",
+    description: "A tool was removed from an agent.",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["agent", "tool", "removed"]
+  },
+  payload: AgentToolRemovedPayload
+});
+
 // src/shared/mock-agents.ts
 var MOCK_AGENTS = [
   {
@@ -222,7 +354,604 @@ var MOCK_TOOLS = [
   }
 ];
 
+// src/agent/agent.schema.ts
+import { defineSchemaModel as defineSchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
+var AgentModel = defineSchemaModel2({
+  name: "Agent",
+  description: "AI agent configuration",
+  fields: {
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    status: { type: AgentStatusEnum, isOptional: false },
+    modelProvider: { type: ModelProviderEnum, isOptional: false },
+    modelName: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    modelConfig: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    systemPrompt: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    userPromptTemplate: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    toolIds: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    toolChoice: {
+      type: ToolChoiceEnum,
+      isOptional: false,
+      defaultValue: "auto"
+    },
+    maxIterations: {
+      type: ScalarTypeEnum2.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 10
+    },
+    maxTokensPerRun: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    timeoutMs: {
+      type: ScalarTypeEnum2.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 120000
+    },
+    version: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    tags: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+var AgentSummaryModel = defineSchemaModel2({
+  name: "AgentSummary",
+  description: "Summary of an agent for list views",
+  fields: {
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    status: { type: AgentStatusEnum, isOptional: false },
+    modelProvider: { type: ModelProviderEnum, isOptional: false },
+    modelName: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    version: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+var AgentToolRefModel = defineSchemaModel2({
+  name: "AgentToolRef",
+  description: "Tool reference in agent context",
+  fields: {
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    category: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false }
+  }
+});
+var AgentWithToolsModel = defineSchemaModel2({
+  name: "AgentWithTools",
+  description: "Agent with associated tools",
+  fields: {
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    status: { type: AgentStatusEnum, isOptional: false },
+    modelProvider: { type: ModelProviderEnum, isOptional: false },
+    modelName: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    modelConfig: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    systemPrompt: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    userPromptTemplate: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    toolIds: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    toolChoice: { type: ToolChoiceEnum, isOptional: false },
+    maxIterations: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    maxTokensPerRun: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    timeoutMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    version: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    tags: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    tools: { type: AgentToolRefModel, isArray: true, isOptional: true }
+  }
+});
+var CreateAgentInputModel = defineSchemaModel2({
+  name: "CreateAgentInput",
+  description: "Input for creating an agent",
+  fields: {
+    organizationId: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    modelProvider: { type: ModelProviderEnum, isOptional: false },
+    modelName: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    modelConfig: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    systemPrompt: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    userPromptTemplate: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    toolIds: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    toolChoice: { type: ToolChoiceEnum, isOptional: true },
+    maxIterations: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    maxTokensPerRun: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    timeoutMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    tags: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+var UpdateAgentInputModel = defineSchemaModel2({
+  name: "UpdateAgentInput",
+  description: "Input for updating an agent",
+  fields: {
+    agentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: true },
+    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    status: { type: AgentStatusEnum, isOptional: true },
+    modelConfig: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    systemPrompt: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    userPromptTemplate: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    toolIds: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    toolChoice: { type: ToolChoiceEnum, isOptional: true },
+    maxIterations: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    maxTokensPerRun: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    timeoutMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    tags: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+
+// src/agent/agent.operation.ts
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts-spec/operations";
+import { defineSchemaModel as defineSchemaModel3, ScalarTypeEnum as ScalarTypeEnum3 } from "@contractspec/lib.schema";
+var OWNERS2 = ["@agent-console-team"];
+var CreateAgentCommand = defineCommand({
+  meta: {
+    key: "agent-console.agent.create",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["agent", "create"],
+    description: "Creates a new AI agent configuration.",
+    goal: "Allow users to define new AI agents with specific models and tools.",
+    context: "Called from the agent builder UI when creating a new agent."
+  },
+  io: {
+    input: CreateAgentInputModel,
+    output: defineSchemaModel3({
+      name: "CreateAgentOutput",
+      fields: {
+        id: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        name: { type: ScalarTypeEnum3.NonEmptyString(), isOptional: false },
+        slug: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        status: { type: AgentStatusEnum, isOptional: false }
+      }
+    }),
+    errors: {
+      SLUG_EXISTS: {
+        description: "An agent with this slug already exists in the organization",
+        http: 409,
+        gqlCode: "SLUG_EXISTS",
+        when: "Slug is already taken"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        ref: AgentCreatedEvent.meta,
+        when: "Agent is successfully created"
+      }
+    ],
+    audit: ["agent-console.agent.created"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "create-agent-happy-path",
+        given: ["User is authenticated", "Organization exists"],
+        when: ["User submits valid agent configuration"],
+        then: [
+          "New agent is created with DRAFT status",
+          "AgentCreated event is emitted"
+        ]
+      },
+      {
+        key: "create-agent-slug-conflict",
+        given: ["User is authenticated", "Agent with same slug exists"],
+        when: ["User submits agent with duplicate slug"],
+        then: ["SLUG_EXISTS error is returned with 409 status"]
+      }
+    ],
+    examples: [
+      {
+        key: "basic-create",
+        input: {
+          name: "Support Assistant",
+          slug: "support-assistant",
+          modelProvider: "openai",
+          modelId: "gpt-4"
+        },
+        output: {
+          id: "agent-123",
+          name: "Support Assistant",
+          slug: "support-assistant",
+          status: "draft"
+        }
+      }
+    ]
+  }
+});
+var UpdateAgentCommand = defineCommand({
+  meta: {
+    key: "agent-console.agent.update",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["agent", "update"],
+    description: "Updates an existing AI agent configuration.",
+    goal: "Allow users to modify agent settings and configuration.",
+    context: "Called from the agent settings UI."
+  },
+  io: {
+    input: UpdateAgentInputModel,
+    output: defineSchemaModel3({
+      name: "UpdateAgentOutput",
+      fields: {
+        id: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        name: { type: ScalarTypeEnum3.NonEmptyString(), isOptional: false },
+        status: { type: AgentStatusEnum, isOptional: false },
+        updatedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+      }
+    }),
+    errors: {
+      AGENT_NOT_FOUND: {
+        description: "The specified agent does not exist",
+        http: 404,
+        gqlCode: "AGENT_NOT_FOUND",
+        when: "Agent ID is invalid"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "agent.updated",
+        version: "1.0.0",
+        stability: "stable",
+        owners: [...OWNERS2],
+        tags: ["agent", "updated"],
+        when: "Agent is updated",
+        payload: AgentSummaryModel
+      }
+    ],
+    audit: ["agent.updated"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "update-agent-happy-path",
+        given: ["Agent exists", "User owns the agent"],
+        when: ["User submits updated configuration"],
+        then: ["Agent is updated", "AgentUpdated event is emitted"]
+      },
+      {
+        key: "update-agent-not-found",
+        given: ["Agent does not exist"],
+        when: ["User attempts to update"],
+        then: ["AGENT_NOT_FOUND error is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "update-name",
+        input: {
+          agentId: "agent-123",
+          name: "Updated Assistant",
+          systemPrompt: "You are a helpful assistant."
+        },
+        output: {
+          id: "agent-123",
+          name: "Updated Assistant",
+          status: "draft",
+          updatedAt: "2025-01-01T00:00:00Z"
+        }
+      }
+    ]
+  }
+});
+var GetAgentQuery = defineQuery({
+  meta: {
+    key: "agent-console.agent.get",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["agent", "get"],
+    description: "Retrieves an agent by its ID.",
+    goal: "View detailed agent configuration.",
+    context: "Called when viewing agent details or editing."
+  },
+  io: {
+    input: defineSchemaModel3({
+      name: "GetAgentInput",
+      fields: {
+        agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        includeTools: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
+      }
+    }),
+    output: AgentWithToolsModel,
+    errors: {
+      AGENT_NOT_FOUND: {
+        description: "The specified agent does not exist",
+        http: 404,
+        gqlCode: "AGENT_NOT_FOUND",
+        when: "Agent ID is invalid"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-agent-happy-path",
+        given: ["Agent exists"],
+        when: ["User requests agent by ID"],
+        then: ["Agent details are returned"]
+      },
+      {
+        key: "get-agent-with-tools",
+        given: ["Agent exists with assigned tools"],
+        when: ["User requests agent with includeTools=true"],
+        then: ["Agent details with tools list are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-basic",
+        input: { agentId: "agent-123", includeTools: false },
+        output: {
+          id: "agent-123",
+          name: "Support Assistant",
+          status: "active",
+          tools: []
+        }
+      }
+    ]
+  }
+});
+var ListAgentsQuery = defineQuery({
+  meta: {
+    key: "agent-console.agent.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["agent", "list"],
+    description: "Lists agents for an organization with optional filtering.",
+    goal: "Browse and search available agents.",
+    context: "Agent list/dashboard view."
+  },
+  io: {
+    input: defineSchemaModel3({
+      name: "ListAgentsInput",
+      fields: {
+        organizationId: {
+          type: ScalarTypeEnum3.String_unsecure(),
+          isOptional: false
+        },
+        status: { type: AgentStatusEnum, isOptional: true },
+        modelProvider: { type: ModelProviderEnum, isOptional: true },
+        search: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+        limit: {
+          type: ScalarTypeEnum3.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 20
+        },
+        offset: {
+          type: ScalarTypeEnum3.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel3({
+      name: "ListAgentsOutput",
+      fields: {
+        items: { type: AgentSummaryModel, isArray: true, isOptional: false },
+        total: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum3.Boolean(), isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "list-agents-happy-path",
+        given: ["Organization has agents"],
+        when: ["User lists agents"],
+        then: ["Paginated list of agents is returned"]
+      },
+      {
+        key: "list-agents-filter-by-status",
+        given: ["Organization has agents with mixed statuses"],
+        when: ["User filters by status=active"],
+        then: ["Only active agents are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "list-basic",
+        input: { organizationId: "org-123", limit: 10, offset: 0 },
+        output: { items: [], total: 0, hasMore: false }
+      }
+    ]
+  }
+});
+var AssignToolToAgentCommand = defineCommand({
+  meta: {
+    key: "agent-console.agent.assignTool",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["agent", "tool", "assign"],
+    description: "Assigns a tool to an agent with optional configuration.",
+    goal: "Enable agents to use specific tools.",
+    context: "Agent configuration UI - tool selection."
+  },
+  io: {
+    input: defineSchemaModel3({
+      name: "AssignToolToAgentInput",
+      fields: {
+        agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        toolId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        config: { type: ScalarTypeEnum3.JSONObject(), isOptional: true },
+        order: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true }
+      }
+    }),
+    output: defineSchemaModel3({
+      name: "AssignToolToAgentOutput",
+      fields: {
+        agentToolId: {
+          type: ScalarTypeEnum3.String_unsecure(),
+          isOptional: false
+        },
+        agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        toolId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false }
+      }
+    }),
+    errors: {
+      TOOL_ALREADY_ASSIGNED: {
+        description: "This tool is already assigned to the agent",
+        http: 409,
+        gqlCode: "TOOL_ALREADY_ASSIGNED",
+        when: "Tool assignment already exists"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  sideEffects: { audit: ["agent.tool.assigned"] },
+  acceptance: {
+    scenarios: [
+      {
+        key: "assign-tool-happy-path",
+        given: ["Agent exists", "Tool exists and is not assigned"],
+        when: ["User assigns tool to agent"],
+        then: ["Tool is assigned", "Assignment ID is returned"]
+      },
+      {
+        key: "assign-tool-already-assigned",
+        given: ["Tool is already assigned to agent"],
+        when: ["User attempts to assign again"],
+        then: ["TOOL_ALREADY_ASSIGNED error is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "assign-basic",
+        input: { agentId: "agent-123", toolId: "tool-456" },
+        output: {
+          agentToolId: "at-789",
+          agentId: "agent-123",
+          toolId: "tool-456"
+        }
+      }
+    ]
+  }
+});
+var RemoveToolFromAgentCommand = defineCommand({
+  meta: {
+    key: "agent-console.agent.removeTool",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["agent", "tool", "remove"],
+    description: "Removes a tool assignment from an agent.",
+    goal: "Disable specific tools for an agent.",
+    context: "Agent configuration UI - tool management."
+  },
+  io: {
+    input: defineSchemaModel3({
+      name: "RemoveToolFromAgentInput",
+      fields: {
+        agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+        toolId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false }
+      }
+    }),
+    output: defineSchemaModel3({
+      name: "RemoveToolFromAgentOutput",
+      fields: {
+        success: { type: ScalarTypeEnum3.Boolean(), isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  sideEffects: { audit: ["agent.tool.removed"] },
+  acceptance: {
+    scenarios: [
+      {
+        key: "remove-tool-happy-path",
+        given: ["Agent exists", "Tool is assigned to agent"],
+        when: ["User removes tool from agent"],
+        then: ["Tool is unassigned", "Success is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "remove-basic",
+        input: { agentId: "agent-123", toolId: "tool-456" },
+        output: { success: true }
+      }
+    ]
+  }
+});
+
 // src/agent/agent.handler.ts
+var nextMockAgentId = MOCK_AGENTS.length + 1;
 async function mockListAgentsHandler(input) {
   const {
     organizationId,
@@ -276,7 +1005,7 @@ async function mockCreateAgentHandler(input) {
   if (exists)
     throw new Error("SLUG_EXISTS");
   return {
-    id: `agent-${Date.now()}`,
+    id: `agent-${nextMockAgentId++}`,
     name: input.name,
     slug: input.slug,
     status: "DRAFT"
@@ -294,9 +1023,1152 @@ async function mockUpdateAgentHandler(input) {
   };
 }
 
+// src/run/run.enum.ts
+import { defineEnum as defineEnum2 } from "@contractspec/lib.schema";
+var RunStatusEnum = defineEnum2("RunStatus", [
+  "QUEUED",
+  "IN_PROGRESS",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED",
+  "EXPIRED"
+]);
+var RunStepTypeEnum = defineEnum2("RunStepType", [
+  "MESSAGE_CREATION",
+  "TOOL_CALL",
+  "TOOL_RESULT",
+  "ERROR"
+]);
+var LogLevelEnum = defineEnum2("LogLevel", [
+  "DEBUG",
+  "INFO",
+  "WARN",
+  "ERROR"
+]);
+var GranularityEnum = defineEnum2("Granularity", [
+  "hour",
+  "day",
+  "week",
+  "month"
+]);
+
+// src/run/run.schema.ts
+import { defineSchemaModel as defineSchemaModel4, ScalarTypeEnum as ScalarTypeEnum4 } from "@contractspec/lib.schema";
+var RunInputModel = defineSchemaModel4({
+  name: "RunInput",
+  description: "Input data for agent execution",
+  fields: {
+    message: { type: ScalarTypeEnum4.NonEmptyString(), isOptional: false },
+    context: { type: ScalarTypeEnum4.JSONObject(), isOptional: true }
+  }
+});
+var RunStepModel = defineSchemaModel4({
+  name: "RunStep",
+  description: "Individual step within a run",
+  fields: {
+    id: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    stepNumber: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: false },
+    type: { type: RunStepTypeEnum, isOptional: false },
+    toolId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    toolName: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    input: { type: ScalarTypeEnum4.JSONObject(), isOptional: true },
+    output: { type: ScalarTypeEnum4.JSONObject(), isOptional: true },
+    status: { type: RunStatusEnum, isOptional: false },
+    errorMessage: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    tokensUsed: {
+      type: ScalarTypeEnum4.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    durationMs: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: true },
+    startedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: true }
+  }
+});
+var RunLogModel = defineSchemaModel4({
+  name: "RunLog",
+  description: "Execution log entry",
+  fields: {
+    id: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    stepId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    level: { type: LogLevelEnum, isOptional: false },
+    message: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    data: { type: ScalarTypeEnum4.JSONObject(), isOptional: true },
+    source: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    traceId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    spanId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    timestamp: { type: ScalarTypeEnum4.DateTime(), isOptional: false }
+  }
+});
+var RunAgentRefModel = defineSchemaModel4({
+  name: "RunAgentRef",
+  description: "Agent reference in a run",
+  fields: {
+    id: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum4.NonEmptyString(), isOptional: false },
+    modelProvider: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isOptional: false
+    },
+    modelName: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false }
+  }
+});
+var RunModel = defineSchemaModel4({
+  name: "Run",
+  description: "Agent execution instance",
+  fields: {
+    id: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isOptional: false
+    },
+    agentId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    userId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    sessionId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    input: { type: ScalarTypeEnum4.JSONObject(), isOptional: false },
+    output: { type: ScalarTypeEnum4.JSONObject(), isOptional: true },
+    status: { type: RunStatusEnum, isOptional: false },
+    errorMessage: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    errorCode: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    totalTokens: {
+      type: ScalarTypeEnum4.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    promptTokens: {
+      type: ScalarTypeEnum4.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    completionTokens: {
+      type: ScalarTypeEnum4.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    totalIterations: {
+      type: ScalarTypeEnum4.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    durationMs: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: true },
+    estimatedCostUsd: {
+      type: ScalarTypeEnum4.Float_unsecure(),
+      isOptional: true
+    },
+    queuedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: true },
+    completedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: true },
+    metadata: { type: ScalarTypeEnum4.JSONObject(), isOptional: true },
+    steps: { type: RunStepModel, isArray: true, isOptional: true },
+    logs: { type: RunLogModel, isArray: true, isOptional: true },
+    agent: { type: RunAgentRefModel, isOptional: true }
+  }
+});
+var RunSummaryModel = defineSchemaModel4({
+  name: "RunSummary",
+  description: "Summary of a run for list views",
+  fields: {
+    id: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    agentId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    agentName: { type: ScalarTypeEnum4.NonEmptyString(), isOptional: false },
+    status: { type: RunStatusEnum, isOptional: false },
+    totalTokens: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: false },
+    durationMs: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: true },
+    estimatedCostUsd: {
+      type: ScalarTypeEnum4.Float_unsecure(),
+      isOptional: true
+    },
+    queuedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: true }
+  }
+});
+var TimelineDataPointModel = defineSchemaModel4({
+  name: "TimelineDataPoint",
+  description: "Timeline data point for metrics",
+  fields: {
+    period: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    runs: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: false },
+    tokens: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: false },
+    costUsd: { type: ScalarTypeEnum4.Float_unsecure(), isOptional: false },
+    avgDurationMs: { type: ScalarTypeEnum4.Float_unsecure(), isOptional: false }
+  }
+});
+
+// src/run/run.operation.ts
+import {
+  defineCommand as defineCommand2,
+  defineQuery as defineQuery2
+} from "@contractspec/lib.contracts-spec/operations";
+import { defineSchemaModel as defineSchemaModel5, ScalarTypeEnum as ScalarTypeEnum5 } from "@contractspec/lib.schema";
+var OWNERS3 = ["@agent-console-team"];
+var ExecuteAgentCommand = defineCommand2({
+  meta: {
+    key: "agent.run.execute",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    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: defineSchemaModel5({
+      name: "ExecuteAgentInput",
+      fields: {
+        agentId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+        input: { type: RunInputModel, isOptional: false },
+        sessionId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
+        metadata: { type: ScalarTypeEnum5.JSONObject(), isOptional: true },
+        stream: { type: ScalarTypeEnum5.Boolean(), isOptional: true },
+        maxIterations: {
+          type: ScalarTypeEnum5.Int_unsecure(),
+          isOptional: true
+        },
+        timeoutMs: { type: ScalarTypeEnum5.Int_unsecure(), isOptional: true }
+      }
+    }),
+    output: defineSchemaModel5({
+      name: "ExecuteAgentOutput",
+      fields: {
+        runId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+        status: { type: RunStatusEnum, isOptional: false },
+        estimatedWaitMs: {
+          type: ScalarTypeEnum5.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: [...OWNERS3],
+        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 = defineCommand2({
+  meta: {
+    key: "agent.run.cancel",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    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: defineSchemaModel5({
+      name: "CancelRunInput",
+      fields: {
+        runId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+        reason: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true }
+      }
+    }),
+    output: defineSchemaModel5({
+      name: "CancelRunOutput",
+      fields: {
+        success: { type: ScalarTypeEnum5.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: [...OWNERS3],
+        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 = defineQuery2({
+  meta: {
+    key: "agent.run.get",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    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: defineSchemaModel5({
+      name: "GetRunInput",
+      fields: {
+        runId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+        includeSteps: { type: ScalarTypeEnum5.Boolean(), isOptional: true },
+        includeLogs: { type: ScalarTypeEnum5.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 = defineQuery2({
+  meta: {
+    key: "agent.run.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["run", "list"],
+    description: "Lists runs with optional filtering.",
+    goal: "Browse and search run history.",
+    context: "Run history/dashboard view."
+  },
+  io: {
+    input: defineSchemaModel5({
+      name: "ListRunsInput",
+      fields: {
+        organizationId: {
+          type: ScalarTypeEnum5.String_unsecure(),
+          isOptional: true
+        },
+        agentId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
+        userId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
+        sessionId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
+        status: { type: RunStatusEnum, isOptional: true },
+        startDate: { type: ScalarTypeEnum5.DateTime(), isOptional: true },
+        endDate: { type: ScalarTypeEnum5.DateTime(), isOptional: true },
+        limit: {
+          type: ScalarTypeEnum5.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 20
+        },
+        offset: {
+          type: ScalarTypeEnum5.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel5({
+      name: "ListRunsOutput",
+      fields: {
+        items: { type: RunSummaryModel, isArray: true, isOptional: false },
+        total: { type: ScalarTypeEnum5.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum5.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 = defineQuery2({
+  meta: {
+    key: "agent.run.getSteps",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    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: defineSchemaModel5({
+      name: "GetRunStepsInput",
+      fields: {
+        runId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false }
+      }
+    }),
+    output: defineSchemaModel5({
+      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 = defineQuery2({
+  meta: {
+    key: "agent.run.getLogs",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    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: defineSchemaModel5({
+      name: "GetRunLogsInput",
+      fields: {
+        runId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+        level: { type: LogLevelEnum, isOptional: true },
+        stepId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
+        limit: {
+          type: ScalarTypeEnum5.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 100
+        },
+        offset: {
+          type: ScalarTypeEnum5.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel5({
+      name: "GetRunLogsOutput",
+      fields: {
+        items: { type: RunLogModel, isArray: true, isOptional: false },
+        total: { type: ScalarTypeEnum5.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum5.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 = defineQuery2({
+  meta: {
+    key: "agent.run.getMetrics",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS3],
+    tags: ["run", "metrics"],
+    description: "Retrieves aggregated metrics for runs within a time period.",
+    goal: "Monitor and analyze agent usage.",
+    context: "Analytics dashboard."
+  },
+  io: {
+    input: defineSchemaModel5({
+      name: "GetRunMetricsInput",
+      fields: {
+        organizationId: {
+          type: ScalarTypeEnum5.String_unsecure(),
+          isOptional: false
+        },
+        agentId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
+        startDate: { type: ScalarTypeEnum5.DateTime(), isOptional: false },
+        endDate: { type: ScalarTypeEnum5.DateTime(), isOptional: false },
+        granularity: {
+          type: GranularityEnum,
+          isOptional: true,
+          defaultValue: "day"
+        }
+      }
+    }),
+    output: defineSchemaModel5({
+      name: "GetRunMetricsOutput",
+      fields: {
+        totalRuns: { type: ScalarTypeEnum5.Int_unsecure(), isOptional: false },
+        completedRuns: {
+          type: ScalarTypeEnum5.Int_unsecure(),
+          isOptional: false
+        },
+        failedRuns: { type: ScalarTypeEnum5.Int_unsecure(), isOptional: false },
+        totalTokens: { type: ScalarTypeEnum5.Int_unsecure(), isOptional: false },
+        totalCostUsd: {
+          type: ScalarTypeEnum5.Float_unsecure(),
+          isOptional: false
+        },
+        averageDurationMs: {
+          type: ScalarTypeEnum5.Float_unsecure(),
+          isOptional: false
+        },
+        successRate: {
+          type: ScalarTypeEnum5.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/tool/tool.enum.ts
+import { defineEnum as defineEnum3 } from "@contractspec/lib.schema";
+var ToolCategoryEnum = defineEnum3("ToolCategory", [
+  "RETRIEVAL",
+  "COMPUTATION",
+  "COMMUNICATION",
+  "INTEGRATION",
+  "UTILITY",
+  "CUSTOM"
+]);
+var ToolStatusEnum = defineEnum3("ToolStatus", [
+  "DRAFT",
+  "ACTIVE",
+  "DEPRECATED",
+  "DISABLED"
+]);
+var ImplementationTypeEnum = defineEnum3("ImplementationType", [
+  "http",
+  "function",
+  "workflow"
+]);
+
+// src/tool/tool.schema.ts
+import { defineSchemaModel as defineSchemaModel6, ScalarTypeEnum as ScalarTypeEnum6 } from "@contractspec/lib.schema";
+var ToolModel = defineSchemaModel6({
+  name: "Tool",
+  description: "AI tool definition",
+  fields: {
+    id: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum6.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum6.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    category: { type: ToolCategoryEnum, isOptional: false },
+    status: { type: ToolStatusEnum, isOptional: false },
+    parametersSchema: { type: ScalarTypeEnum6.JSONObject(), isOptional: false },
+    outputSchema: { type: ScalarTypeEnum6.JSONObject(), isOptional: true },
+    implementationType: { type: ImplementationTypeEnum, isOptional: false },
+    implementationConfig: {
+      type: ScalarTypeEnum6.JSONObject(),
+      isOptional: false
+    },
+    maxInvocationsPerMinute: {
+      type: ScalarTypeEnum6.Int_unsecure(),
+      isOptional: true
+    },
+    timeoutMs: {
+      type: ScalarTypeEnum6.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 30000
+    },
+    version: { type: ScalarTypeEnum6.NonEmptyString(), isOptional: false },
+    tags: {
+      type: ScalarTypeEnum6.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    createdAt: { type: ScalarTypeEnum6.DateTime(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum6.DateTime(), isOptional: false }
+  }
+});
+var ToolSummaryModel = defineSchemaModel6({
+  name: "ToolSummary",
+  description: "Summary of a tool for list views",
+  fields: {
+    id: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum6.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    category: { type: ToolCategoryEnum, isOptional: false },
+    status: { type: ToolStatusEnum, isOptional: false },
+    version: { type: ScalarTypeEnum6.NonEmptyString(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum6.DateTime(), isOptional: false }
+  }
+});
+var CreateToolInputModel = defineSchemaModel6({
+  name: "CreateToolInput",
+  description: "Input for creating a tool",
+  fields: {
+    organizationId: {
+      type: ScalarTypeEnum6.String_unsecure(),
+      isOptional: false
+    },
+    name: { type: ScalarTypeEnum6.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    category: { type: ToolCategoryEnum, isOptional: true },
+    parametersSchema: { type: ScalarTypeEnum6.JSONObject(), isOptional: false },
+    outputSchema: { type: ScalarTypeEnum6.JSONObject(), isOptional: true },
+    implementationType: { type: ImplementationTypeEnum, isOptional: false },
+    implementationConfig: {
+      type: ScalarTypeEnum6.JSONObject(),
+      isOptional: false
+    },
+    maxInvocationsPerMinute: {
+      type: ScalarTypeEnum6.Int_unsecure(),
+      isOptional: true
+    },
+    timeoutMs: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: true },
+    tags: {
+      type: ScalarTypeEnum6.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+var UpdateToolInputModel = defineSchemaModel6({
+  name: "UpdateToolInput",
+  description: "Input for updating a tool",
+  fields: {
+    toolId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum6.NonEmptyString(), isOptional: true },
+    description: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
+    status: { type: ToolStatusEnum, isOptional: true },
+    parametersSchema: { type: ScalarTypeEnum6.JSONObject(), isOptional: true },
+    outputSchema: { type: ScalarTypeEnum6.JSONObject(), isOptional: true },
+    implementationConfig: {
+      type: ScalarTypeEnum6.JSONObject(),
+      isOptional: true
+    },
+    maxInvocationsPerMinute: {
+      type: ScalarTypeEnum6.Int_unsecure(),
+      isOptional: true
+    },
+    timeoutMs: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: true },
+    tags: {
+      type: ScalarTypeEnum6.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+
+// src/tool/tool.operation.ts
+import {
+  defineCommand as defineCommand3,
+  defineQuery as defineQuery3
+} from "@contractspec/lib.contracts-spec/operations";
+import { defineSchemaModel as defineSchemaModel7, ScalarTypeEnum as ScalarTypeEnum7 } from "@contractspec/lib.schema";
+var OWNERS4 = ["@agent-console-team"];
+var CreateToolCommand = defineCommand3({
+  meta: {
+    key: "agent.tool.create",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS4],
+    tags: ["tool", "create"],
+    description: "Creates a new AI tool definition.",
+    goal: "Allow users to define new tools that agents can use.",
+    context: "Called from the tool builder UI when creating a new tool."
+  },
+  io: {
+    input: CreateToolInputModel,
+    output: defineSchemaModel7({
+      name: "CreateToolOutput",
+      fields: {
+        id: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+        name: { type: ScalarTypeEnum7.NonEmptyString(), isOptional: false },
+        slug: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+        status: { type: ToolStatusEnum, isOptional: false }
+      }
+    }),
+    errors: {
+      SLUG_EXISTS: {
+        description: "A tool with this slug already exists in the organization",
+        http: 409,
+        gqlCode: "SLUG_EXISTS",
+        when: "Slug is already taken"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "tool.created",
+        version: "1.0.0",
+        stability: "stable",
+        owners: [...OWNERS4],
+        tags: ["tool", "created"],
+        when: "Tool is successfully created",
+        payload: ToolSummaryModel
+      }
+    ],
+    audit: ["tool.created"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "create-tool-happy-path",
+        given: ["User is authenticated", "Organization exists"],
+        when: ["User submits valid tool configuration"],
+        then: ["New tool is created", "ToolCreated event is emitted"]
+      },
+      {
+        key: "create-tool-slug-conflict",
+        given: ["Tool with same slug exists"],
+        when: ["User submits tool with duplicate slug"],
+        then: ["SLUG_EXISTS error is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "create-api-tool",
+        input: {
+          name: "Weather API",
+          slug: "weather-api",
+          category: "api",
+          description: "Fetches weather data"
+        },
+        output: {
+          id: "tool-123",
+          name: "Weather API",
+          slug: "weather-api",
+          status: "draft"
+        }
+      }
+    ]
+  }
+});
+var UpdateToolCommand = defineCommand3({
+  meta: {
+    key: "agent.tool.update",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS4],
+    tags: ["tool", "update"],
+    description: "Updates an existing AI tool definition.",
+    goal: "Allow users to modify tool settings and configuration.",
+    context: "Called from the tool settings UI."
+  },
+  io: {
+    input: UpdateToolInputModel,
+    output: defineSchemaModel7({
+      name: "UpdateToolOutput",
+      fields: {
+        id: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+        name: { type: ScalarTypeEnum7.NonEmptyString(), isOptional: false },
+        status: { type: ToolStatusEnum, isOptional: false },
+        updatedAt: { type: ScalarTypeEnum7.DateTime(), isOptional: false }
+      }
+    }),
+    errors: {
+      TOOL_NOT_FOUND: {
+        description: "The specified tool does not exist",
+        http: 404,
+        gqlCode: "TOOL_NOT_FOUND",
+        when: "Tool ID is invalid"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "tool.updated",
+        version: "1.0.0",
+        stability: "stable",
+        owners: [...OWNERS4],
+        tags: ["tool", "updated"],
+        when: "Tool is updated",
+        payload: ToolSummaryModel
+      }
+    ],
+    audit: ["tool.updated"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "update-tool-happy-path",
+        given: ["Tool exists", "User owns the tool"],
+        when: ["User submits updated configuration"],
+        then: ["Tool is updated", "ToolUpdated event is emitted"]
+      }
+    ],
+    examples: [
+      {
+        key: "update-description",
+        input: { toolId: "tool-123", description: "Updated weather API tool" },
+        output: {
+          id: "tool-123",
+          name: "Weather API",
+          status: "draft",
+          updatedAt: "2025-01-01T00:00:00Z"
+        }
+      }
+    ]
+  }
+});
+var GetToolQuery = defineQuery3({
+  meta: {
+    key: "agent.tool.get",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS4],
+    tags: ["tool", "get"],
+    description: "Retrieves a tool by its ID.",
+    goal: "View detailed tool configuration.",
+    context: "Called when viewing tool details or editing."
+  },
+  io: {
+    input: defineSchemaModel7({
+      name: "GetToolInput",
+      fields: {
+        toolId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false }
+      }
+    }),
+    output: ToolModel,
+    errors: {
+      TOOL_NOT_FOUND: {
+        description: "The specified tool does not exist",
+        http: 404,
+        gqlCode: "TOOL_NOT_FOUND",
+        when: "Tool ID is invalid"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-tool-happy-path",
+        given: ["Tool exists"],
+        when: ["User requests tool by ID"],
+        then: ["Tool details are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-basic",
+        input: { toolId: "tool-123" },
+        output: {
+          id: "tool-123",
+          name: "Weather API",
+          status: "active",
+          category: "api"
+        }
+      }
+    ]
+  }
+});
+var ListToolsQuery = defineQuery3({
+  meta: {
+    key: "agent.tool.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS4],
+    tags: ["tool", "list"],
+    description: "Lists tools for an organization with optional filtering.",
+    goal: "Browse and search available tools.",
+    context: "Tool list/dashboard view."
+  },
+  io: {
+    input: defineSchemaModel7({
+      name: "ListToolsInput",
+      fields: {
+        organizationId: {
+          type: ScalarTypeEnum7.String_unsecure(),
+          isOptional: false
+        },
+        category: { type: ToolCategoryEnum, isOptional: true },
+        status: { type: ToolStatusEnum, isOptional: true },
+        search: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
+        limit: {
+          type: ScalarTypeEnum7.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 20
+        },
+        offset: {
+          type: ScalarTypeEnum7.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel7({
+      name: "ListToolsOutput",
+      fields: {
+        items: { type: ToolSummaryModel, isArray: true, isOptional: false },
+        total: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum7.Boolean(), isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "list-tools-happy-path",
+        given: ["Organization has tools"],
+        when: ["User lists tools"],
+        then: ["Paginated list of tools is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "list-by-category",
+        input: { organizationId: "org-123", category: "api", limit: 10 },
+        output: { items: [], total: 0, hasMore: false }
+      }
+    ]
+  }
+});
+var TestToolCommand = defineCommand3({
+  meta: {
+    key: "agent.tool.test",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS4],
+    tags: ["tool", "test"],
+    description: "Tests a tool with sample input to verify it works correctly.",
+    goal: "Validate tool configuration before deployment.",
+    context: "Tool builder UI - test panel."
+  },
+  io: {
+    input: defineSchemaModel7({
+      name: "TestToolInput",
+      fields: {
+        toolId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+        testInput: { type: ScalarTypeEnum7.JSONObject(), isOptional: false }
+      }
+    }),
+    output: defineSchemaModel7({
+      name: "TestToolOutput",
+      fields: {
+        success: { type: ScalarTypeEnum7.Boolean(), isOptional: false },
+        output: { type: ScalarTypeEnum7.JSONObject(), isOptional: true },
+        error: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
+        durationMs: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: false }
+      }
+    }),
+    errors: {
+      TOOL_NOT_FOUND: {
+        description: "The specified tool does not exist",
+        http: 404,
+        gqlCode: "TOOL_NOT_FOUND",
+        when: "Tool ID is invalid"
+      },
+      TOOL_EXECUTION_ERROR: {
+        description: "Tool execution failed",
+        http: 500,
+        gqlCode: "TOOL_EXECUTION_ERROR",
+        when: "Tool returns an error"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  sideEffects: { audit: ["tool.tested"] },
+  acceptance: {
+    scenarios: [
+      {
+        key: "test-tool-success",
+        given: ["Tool exists", "Tool is configured correctly"],
+        when: ["User runs test with valid input"],
+        then: ["Tool executes successfully", "Output is returned"]
+      },
+      {
+        key: "test-tool-failure",
+        given: ["Tool exists", "Tool has configuration error"],
+        when: ["User runs test"],
+        then: ["TOOL_EXECUTION_ERROR is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "test-weather-api",
+        input: { toolId: "tool-123", testInput: { city: "Paris" } },
+        output: { success: true, output: { temperature: 22 }, durationMs: 150 }
+      }
+    ]
+  }
+});
+
 // src/handlers/agent.handlers.ts
 import { web } from "@contractspec/lib.runtime-sandbox";
 var { generateId } = web;
+var RUN_SORT_COLUMNS = {
+  queuedAt: "r.queuedAt",
+  totalTokens: "r.totalTokens",
+  durationMs: "r.durationMs",
+  estimatedCostUsd: "r.estimatedCostUsd",
+  status: "r.status",
+  agentName: "a.name"
+};
 function rowToAgent(row) {
   return {
     id: row.id,
@@ -476,7 +2348,15 @@ function createAgentHandlers(db) {
     };
   }
   async function listRuns(input) {
-    const { projectId, agentId, status, limit = 20, offset = 0 } = input;
+    const {
+      projectId,
+      agentId,
+      status,
+      sortBy,
+      sortDirection = "desc",
+      limit = 20,
+      offset = 0
+    } = input;
     let whereClause = "WHERE r.projectId = ?";
     const params = [projectId];
     if (agentId) {
@@ -489,11 +2369,13 @@ function createAgentHandlers(db) {
     }
     const countResult = (await db.query(`SELECT COUNT(*) as count FROM agent_run r ${whereClause}`, params)).rows;
     const total = countResult[0]?.count ?? 0;
+    const sortColumn = sortBy ? RUN_SORT_COLUMNS[sortBy] : RUN_SORT_COLUMNS.queuedAt;
+    const direction = sortDirection === "asc" ? "ASC" : "DESC";
     const rows = (await db.query(`SELECT r.*, a.name as agentName 
        FROM agent_run r 
        LEFT JOIN agent_definition a ON r.agentId = a.id 
        ${whereClause} 
-       ORDER BY r.queuedAt DESC LIMIT ? OFFSET ?`, [...params, limit, offset])).rows;
+       ORDER BY ${sortColumn} ${direction}, r.queuedAt DESC LIMIT ? OFFSET ?`, [...params, limit, offset])).rows;
     return {
       items: rows.map((r) => rowToRun(r, r.agentName)),
       total,
@@ -566,6 +2448,7 @@ var MOCK_RUNS = [
   {
     id: "run-1",
     organizationId: "demo-org",
+    projectId: "demo-project",
     agentId: "agent-1",
     agentName: "Customer Support Bot",
     userId: "user-1",
@@ -588,6 +2471,7 @@ var MOCK_RUNS = [
   {
     id: "run-2",
     organizationId: "demo-org",
+    projectId: "demo-project",
     agentId: "agent-2",
     agentName: "Code Review Assistant",
     userId: "user-2",
@@ -605,6 +2489,7 @@ var MOCK_RUNS = [
   {
     id: "run-3",
     organizationId: "demo-org",
+    projectId: "demo-project",
     agentId: "agent-1",
     agentName: "Customer Support Bot",
     userId: "user-1",
@@ -626,6 +2511,7 @@ var MOCK_RUNS = [
   {
     id: "run-4",
     organizationId: "demo-org",
+    projectId: "demo-project",
     agentId: "agent-3",
     agentName: "Data Analyst",
     userId: "user-3",
@@ -647,6 +2533,7 @@ var MOCK_RUNS = [
   {
     id: "run-5",
     organizationId: "demo-org",
+    projectId: "demo-project",
     agentId: "agent-2",
     agentName: "Code Review Assistant",
     userId: "user-2",
@@ -668,6 +2555,7 @@ var MOCK_RUNS = [
 ];
 
 // src/run/run.handler.ts
+var nextMockRunId = MOCK_RUNS.length + 1;
 async function mockListRunsHandler(input) {
   const { agentId, status, limit = 20, offset = 0 } = input;
   let filtered = [...MOCK_RUNS];
@@ -716,7 +2604,7 @@ async function mockExecuteAgentHandler(input) {
   if (agent.status !== "ACTIVE")
     throw new Error("AGENT_NOT_ACTIVE");
   return {
-    runId: `run-${Date.now()}`,
+    runId: `run-${nextMockRunId++}`,
     status: "QUEUED",
     estimatedWaitMs: 500
   };
@@ -731,6 +2619,7 @@ async function mockCancelRunHandler(input) {
 }
 
 // src/tool/tool.handler.ts
+var nextMockToolId = MOCK_TOOLS.length + 1;
 async function mockListToolsHandler(input) {
   const {
     organizationId,
@@ -773,7 +2662,7 @@ async function mockCreateToolHandler(input) {
   if (exists)
     throw new Error("SLUG_EXISTS");
   return {
-    id: `tool-${Date.now()}`,
+    id: `tool-${nextMockToolId++}`,
     name: input.name,
     slug: input.slug,
     status: "DRAFT"
@@ -794,12 +2683,256 @@ async function mockTestToolHandler(input) {
   const tool = MOCK_TOOLS.find((t) => t.id === input.toolId);
   if (!tool)
     throw new Error("TOOL_NOT_FOUND");
-  const startTime = Date.now();
   await new Promise((resolve) => setTimeout(resolve, 100));
   return {
     success: true,
     output: { result: "Test successful", input: input.testInput },
-    durationMs: Date.now() - startTime
+    durationMs: 100
+  };
+}
+// src/shared/demo-runtime-seed.ts
+var AGENT_CONSOLE_DEMO_ORGANIZATION_ID = "demo-org";
+var AGENT_CONSOLE_DEMO_PROJECT_ID = "agent-console-demo";
+function slugify(name) {
+  return name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function cloneAgent(agent) {
+  return { ...agent };
+}
+function cloneTool(tool) {
+  return { ...tool };
+}
+function cloneRun(run) {
+  return { ...run };
+}
+function createDefaultNow() {
+  let tick = 0;
+  const base = Date.parse("2026-03-20T09:00:00.000Z");
+  return () => new Date(base + tick++ * 60000);
+}
+function normalizeProvider(provider) {
+  return provider.toLowerCase();
+}
+function normalizeRunStatus(status) {
+  return status === "IN_PROGRESS" ? "RUNNING" : status;
+}
+function createSeedState(projectId, organizationId) {
+  const agents = MOCK_AGENTS.map((agent) => ({
+    id: agent.id,
+    projectId,
+    organizationId,
+    name: agent.name,
+    slug: agent.slug,
+    description: agent.description,
+    modelProvider: normalizeProvider(agent.modelProvider),
+    modelName: agent.modelName,
+    systemPrompt: agent.systemPrompt,
+    temperature: typeof agent.modelConfig?.temperature === "number" ? agent.modelConfig.temperature : 0.4,
+    maxTokens: 8192,
+    status: agent.status,
+    createdAt: agent.createdAt,
+    updatedAt: agent.updatedAt
+  }));
+  const tools = MOCK_TOOLS.map((tool) => ({
+    id: tool.id,
+    projectId,
+    organizationId,
+    name: tool.name,
+    description: tool.description,
+    version: tool.version,
+    category: tool.category,
+    status: tool.status,
+    inputSchema: JSON.stringify(tool.parametersSchema),
+    outputSchema: tool.outputSchema ? JSON.stringify(tool.outputSchema) : undefined,
+    endpoint: typeof tool.implementationConfig?.url === "string" ? tool.implementationConfig.url : undefined,
+    createdAt: tool.createdAt,
+    updatedAt: tool.updatedAt
+  }));
+  const agentNames = new Map(agents.map((agent) => [agent.id, agent.name]));
+  const runs = MOCK_RUNS.map((run) => ({
+    id: run.id,
+    projectId,
+    agentId: run.agentId,
+    agentName: agentNames.get(run.agentId) ?? run.agentName ?? "Unknown agent",
+    status: normalizeRunStatus(run.status),
+    input: JSON.stringify(run.input),
+    output: run.output ? JSON.stringify(run.output) : undefined,
+    totalTokens: run.totalTokens,
+    promptTokens: run.promptTokens,
+    completionTokens: run.completionTokens,
+    estimatedCostUsd: run.estimatedCostUsd ?? 0,
+    durationMs: run.durationMs,
+    errorMessage: run.errorMessage,
+    queuedAt: run.queuedAt,
+    startedAt: run.startedAt,
+    completedAt: run.completedAt
+  }));
+  return { agents, tools, runs };
+}
+function summarizeRunMetrics(runs) {
+  const totalRuns = runs.length;
+  const completedRuns = runs.filter((run) => run.status === "COMPLETED").length;
+  const completedDurations = runs.map((run) => run.durationMs).filter((duration) => typeof duration === "number");
+  return {
+    totalRuns,
+    successRate: totalRuns === 0 ? 0 : completedRuns / totalRuns,
+    averageDurationMs: completedDurations.length === 0 ? 0 : Math.round(completedDurations.reduce((sum, duration) => sum + duration, 0) / completedDurations.length),
+    totalTokens: runs.reduce((sum, run) => sum + run.totalTokens, 0),
+    totalCostUsd: runs.reduce((sum, run) => sum + run.estimatedCostUsd, 0)
+  };
+}
+
+// src/shared/demo-runtime.ts
+function createAgentConsoleDemoHandlers(options) {
+  const projectId = options.projectId;
+  const organizationId = options.organizationId ?? AGENT_CONSOLE_DEMO_ORGANIZATION_ID;
+  const now = options.now ?? createDefaultNow();
+  const state = createSeedState(projectId, organizationId);
+  let agentIndex = state.agents.length + 1;
+  let runIndex = state.runs.length + 1;
+  const nextId = (kind) => {
+    const nextIndex = kind === "agent" ? agentIndex++ : runIndex++;
+    return options.idFactory?.(kind, nextIndex) ?? `${kind}-demo-${nextIndex}`;
+  };
+  return {
+    async listAgents(input) {
+      const filtered = state.agents.filter((agent) => agent.projectId === input.projectId).filter((agent) => !input.organizationId || agent.organizationId === input.organizationId).filter((agent) => !input.status || input.status === "all" || agent.status === input.status).filter((agent) => {
+        if (!input.search)
+          return true;
+        const query = input.search.toLowerCase();
+        return agent.name.toLowerCase().includes(query) || (agent.description ?? "").toLowerCase().includes(query);
+      }).sort((left, right) => right.updatedAt.getTime() - left.updatedAt.getTime());
+      const limit = input.limit ?? 20;
+      const offset = input.offset ?? 0;
+      const items = filtered.slice(offset, offset + limit).map(cloneAgent);
+      return {
+        items,
+        total: filtered.length,
+        hasMore: offset + items.length < filtered.length
+      };
+    },
+    async getAgent(id) {
+      const agent = state.agents.find((item) => item.id === id);
+      return agent ? cloneAgent(agent) : null;
+    },
+    async createAgent(input, context) {
+      const name = input.name.trim();
+      const slug = slugify(name);
+      const duplicate = state.agents.find((agent2) => agent2.projectId === context.projectId && agent2.organizationId === context.organizationId && (agent2.slug === slug || agent2.name.toLowerCase() === name.toLowerCase()));
+      if (duplicate)
+        throw new Error("AGENT_NAME_OR_SLUG_EXISTS");
+      const timestamp = now();
+      const agent = {
+        id: nextId("agent"),
+        projectId: context.projectId,
+        organizationId: context.organizationId,
+        name,
+        slug,
+        description: input.description,
+        modelProvider: input.modelProvider ?? "openai",
+        modelName: input.modelName ?? "gpt-5.4",
+        systemPrompt: input.systemPrompt,
+        temperature: input.temperature ?? 0.4,
+        maxTokens: input.maxTokens ?? 8192,
+        status: "DRAFT",
+        createdAt: timestamp,
+        updatedAt: timestamp
+      };
+      state.agents.unshift(agent);
+      return cloneAgent(agent);
+    },
+    async updateAgent(input) {
+      const agent = state.agents.find((item) => item.id === input.id);
+      if (!agent)
+        throw new Error("AGENT_NOT_FOUND");
+      const nextName = input.name;
+      if (nextName && slugify(nextName) !== agent.slug) {
+        const duplicate = state.agents.find((item) => item.id !== agent.id && item.projectId === agent.projectId && item.organizationId === agent.organizationId && (item.slug === slugify(nextName) || item.name.toLowerCase() === nextName.toLowerCase()));
+        if (duplicate)
+          throw new Error("AGENT_NAME_OR_SLUG_EXISTS");
+        agent.slug = slugify(nextName);
+        agent.name = nextName;
+      }
+      if (input.description !== undefined)
+        agent.description = input.description;
+      if (input.status)
+        agent.status = input.status;
+      agent.updatedAt = now();
+      return cloneAgent(agent);
+    },
+    async executeAgent(input) {
+      const agent = state.agents.find((item) => item.id === input.agentId);
+      if (!agent)
+        throw new Error("AGENT_NOT_FOUND");
+      if (agent.status !== "ACTIVE")
+        throw new Error("AGENT_NOT_ACTIVE");
+      const queuedAt = now();
+      const startedAt = now();
+      const completedAt = now();
+      const durationMs = 2200 + input.message.length * 12;
+      const promptTokens = 600 + input.message.length * 3;
+      const completionTokens = 240 + agent.name.length * 4;
+      const run = {
+        id: nextId("run"),
+        projectId: input.context?.projectId ?? agent.projectId,
+        agentId: agent.id,
+        agentName: agent.name,
+        status: "COMPLETED",
+        input: input.message,
+        output: `Deterministic demo reply from ${agent.name}: ${input.message}`,
+        totalTokens: promptTokens + completionTokens,
+        promptTokens,
+        completionTokens,
+        estimatedCostUsd: Number(((promptTokens + completionTokens) / 1e6).toFixed(4)),
+        durationMs,
+        queuedAt,
+        startedAt,
+        completedAt
+      };
+      state.runs.unshift(run);
+      return cloneRun(run);
+    },
+    async listTools(input) {
+      const filtered = state.tools.filter((tool) => tool.projectId === input.projectId).filter((tool) => !input.organizationId || tool.organizationId === input.organizationId).filter((tool) => !input.category || input.category === "all" || tool.category === input.category).filter((tool) => !input.status || input.status === "all" || tool.status === input.status).filter((tool) => {
+        if (!input.search)
+          return true;
+        const query = input.search.toLowerCase();
+        return tool.name.toLowerCase().includes(query) || (tool.description ?? "").toLowerCase().includes(query);
+      }).sort((left, right) => left.name.localeCompare(right.name));
+      const limit = input.limit ?? 50;
+      const offset = input.offset ?? 0;
+      const items = filtered.slice(offset, offset + limit).map(cloneTool);
+      return {
+        items,
+        total: filtered.length,
+        hasMore: offset + items.length < filtered.length
+      };
+    },
+    async listRuns(input) {
+      const filtered = state.runs.filter((run) => run.projectId === input.projectId).filter((run) => !input.agentId || run.agentId === input.agentId).filter((run) => !input.status || input.status === "all" || run.status === input.status).sort((left, right) => right.queuedAt.getTime() - left.queuedAt.getTime());
+      const limit = input.limit ?? 20;
+      const offset = input.offset ?? 0;
+      const items = filtered.slice(offset, offset + limit).map(cloneRun);
+      return {
+        items,
+        total: filtered.length,
+        hasMore: offset + items.length < filtered.length
+      };
+    },
+    async getRunMetrics(input) {
+      const filtered = state.runs.filter((run) => {
+        if (run.projectId !== input.projectId)
+          return false;
+        if (input.agentId && run.agentId !== input.agentId)
+          return false;
+        if (input.startDate && run.queuedAt < input.startDate)
+          return false;
+        if (input.endDate && run.queuedAt > input.endDate)
+          return false;
+        return true;
+      });
+      return summarizeRunMetrics(filtered);
+    }
   };
 }
 export {
@@ -812,5 +2945,6 @@ export {
   mockExecuteAgentHandler,
   mockCreateToolHandler,
   mockCreateAgentHandler,
-  createAgentHandlers
+  createAgentHandlers,
+  createAgentConsoleDemoHandlers
 };