@contractspec/example.agent-console 3.7.6 → 3.8.2

package/dist/agent/agent.handler.js

@@ -1,4 +1,136 @@
 // @bun
+// 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 = [
   {
@@ -223,7 +355,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,
@@ -277,7 +1006,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"