Wire task runs to provider gateway

AgentCompany-New/tests/unit/domain-services.test.ts

@@ -23,7 +23,7 @@ describe("domain services", () => {
     const connection = createConnection();
 
     const rows = connection.db.prepare("select version from schema_migrations order by version asc").all() as Array<{ version: number }>;
-    expect(rows.map((row) => row.version)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]);
+    expect(rows.map((row) => row.version)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]);
     connection.close();
   });
 

AgentCompany-New/tests/unit/migration-service.test.ts

@@ -104,7 +104,7 @@ describe("migration service", () => {
       create table workspaces(id text primary key, org_id text, project_id text);
       create table goals(id text primary key, org_id text, owner_agent_id text);
       create table projects(id text primary key, org_id text, goal_id text, lead_agent_id text);
-      create table task_runs(id text primary key, org_id text, task_id text, agent_id text, provider_id text);
+      create table task_runs(id text primary key, org_id text, task_id text, agent_id text, provider_id text, provider_request_id text);
       create table approvals(id text primary key, org_id text, decided_by_employee_id text);
       create table approval_routing_rules(id text primary key, org_id text);
       create table approval_assignments(id text primary key, org_id text, approval_id text, routing_rule_id text);
@@ -173,7 +173,7 @@ describe("migration service", () => {
       insert into goals(id, org_id, owner_agent_id) values ('goal-1', 'org-1', 'agent-1');
       insert into projects(id, org_id, goal_id, lead_agent_id) values ('prj-1', 'org-1', 'goal-1', 'agent-1');
       insert into tasks(id, org_id, assignee_agent_id, project_id, goal_id, workspace_id) values ('task-1', 'org-1', 'agent-1', 'prj-1', 'goal-1', 'wsp-1');
-      insert into task_runs(id, org_id, task_id, agent_id, provider_id) values ('run-1', 'org-1', 'task-1', 'agent-1', 'prov-1');
+      insert into task_runs(id, org_id, task_id, agent_id, provider_id, provider_request_id) values ('run-1', 'org-1', 'task-1', 'agent-1', 'prov-1', 'req-1');
       insert into approvals(id, org_id, decided_by_employee_id) values ('approval-1', 'org-1', 'emp-1');
       insert into approval_routing_rules(id, org_id) values ('route-1', 'org-1');
       insert into approval_assignments(id, org_id, approval_id, routing_rule_id) values ('assign-1', 'org-1', 'approval-1', 'route-1');

AgentCompany-New/tests/unit/task-execution-service.test.ts

@@ -0,0 +1,206 @@
+import { randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import { DatabaseConnection } from "../../src/main/database/connection";
+import { OrganizationService } from "../../src/main/services/organization-service";
+import { ProviderService } from "../../src/main/services/provider-service";
+import { providerAdapters, type ProviderAdapterRegistry } from "../../src/main/services/provider-adapters";
+import { SnapshotService } from "../../src/main/services/snapshot-service";
+import { TaskExecutionService } from "../../src/main/services/task-execution-service";
+import { RISK_LEVEL, TASK_PRIORITY, TASK_STATUS } from "../../src/shared/domain";
+
+function createConnection(): DatabaseConnection {
+  return new DatabaseConnection(join(tmpdir(), `agentcompany-new-task-execution-${randomUUID()}.db`));
+}
+
+function openAiProviderId(connection: DatabaseConnection, orgId: string): string {
+  return (connection.db.prepare("select id from providers where org_id = ? and provider_key = 'openai'")
+    .get(orgId) as { id: string }).id;
+}
+
+const testVault = {
+  encryptSecret: (secret: string) => Buffer.from(secret, "utf8"),
+  decryptSecret: (ciphertext: Buffer) => ciphertext.toString("utf8"),
+};
+
+describe("task execution service", () => {
+  test("runs an assigned task through the provider gateway", async () => {
+    const connection = createConnection();
+    const organization = new OrganizationService(connection.db);
+    const snapshot = new SnapshotService(connection.db);
+    let capturedPrompt = "";
+    const adapters: ProviderAdapterRegistry = {
+      ...providerAdapters,
+      openai: {
+        ...providerAdapters.openai,
+        createResponse: async ({ prompt, model }) => {
+          capturedPrompt = prompt;
+          return {
+            text: `executed:${model}`,
+            rawResponseJson: JSON.stringify({ id: "resp-task-1" }),
+            rateLimitState: null,
+          };
+        },
+      },
+    };
+    const providers = new ProviderService(connection.db, adapters, testVault);
+    const execution = new TaskExecutionService(connection.db, providers);
+    let orgId = "";
+    let providerId = "";
+    let taskId = "";
+
+    connection.transaction(() => {
+      orgId = organization.createOrganization({
+        organizationName: "Acme Operations",
+        employeeName: "Dana Lee",
+        mission: "Coordinate agents with auditable approvals.",
+        goal: "Ship a verified control plane.",
+      });
+      providerId = openAiProviderId(connection, orgId);
+      providers.saveCredential({ orgId, providerId, secret: "sk-live-provider", model: "gpt-5.4" });
+      const agentId = organization.createAgent({
+        orgId,
+        name: "Ada",
+        role: "Execution lead",
+        department: "Engineering",
+        modelProviderId: providerId,
+        modelId: "gpt-5.4",
+        budgetCents: 10000,
+        managerAgentId: null,
+      });
+      taskId = organization.createTask({
+        orgId,
+        title: "Draft launch checklist",
+        description: "Prepare an auditable checklist for release readiness.",
+        status: TASK_STATUS.IN_PROGRESS,
+        assigneeAgentId: agentId,
+        risk: RISK_LEVEL.MEDIUM,
+        projectId: null,
+        goalId: null,
+        workspaceId: null,
+        priority: TASK_PRIORITY.HIGH,
+        requiresFilesystem: false,
+      });
+    });
+
+    const runId = await execution.runTask({ orgId, taskId });
+    const state = snapshot.load();
+    const run = state.taskRuns.find((item) => item.id === runId);
+    const request = state.providerRequests.find((item) => item.id === run?.providerRequestId);
+
+    expect(run).toMatchObject({ taskId, agentId: expect.any(String), providerId, state: "completed", errorMessage: null });
+    expect(request).toMatchObject({ providerId, state: "succeeded", responseText: "executed:gpt-5.4" });
+    expect(capturedPrompt).toContain("Task: Draft launch checklist");
+    expect(capturedPrompt).toContain("Assignee: Ada (Execution lead)");
+    expect(state.auditEvents.some((event) => event.entityType === "task_run" && event.action === "completed")).toBe(true);
+    connection.close();
+  });
+
+  test("marks task runs failed when provider execution fails", async () => {
+    const connection = createConnection();
+    const organization = new OrganizationService(connection.db);
+    const snapshot = new SnapshotService(connection.db);
+    const adapters: ProviderAdapterRegistry = {
+      ...providerAdapters,
+      openai: {
+        ...providerAdapters.openai,
+        createResponse: async () => {
+          throw new Error("provider rejected task");
+        },
+      },
+    };
+    const providers = new ProviderService(connection.db, adapters, testVault);
+    const execution = new TaskExecutionService(connection.db, providers);
+    let orgId = "";
+    let taskId = "";
+
+    connection.transaction(() => {
+      orgId = organization.createOrganization({
+        organizationName: "Acme Operations",
+        employeeName: "Dana Lee",
+        mission: "Coordinate agents with auditable approvals.",
+        goal: "Ship a verified control plane.",
+      });
+      const providerId = openAiProviderId(connection, orgId);
+      providers.saveCredential({ orgId, providerId, secret: "sk-live-provider", model: "gpt-5.4" });
+      const agentId = organization.createAgent({
+        orgId,
+        name: "Ada",
+        role: "Execution lead",
+        department: "Engineering",
+        modelProviderId: providerId,
+        modelId: "gpt-5.4",
+        budgetCents: 10000,
+        managerAgentId: null,
+      });
+      taskId = organization.createTask({
+        orgId,
+        title: "Draft launch checklist",
+        description: "Prepare an auditable checklist for release readiness.",
+        status: TASK_STATUS.IN_PROGRESS,
+        assigneeAgentId: agentId,
+        risk: RISK_LEVEL.MEDIUM,
+        projectId: null,
+        goalId: null,
+        workspaceId: null,
+        priority: TASK_PRIORITY.HIGH,
+        requiresFilesystem: false,
+      });
+    });
+
+    await expect(execution.runTask({ orgId, taskId })).rejects.toThrow("provider rejected task");
+    const state = snapshot.load();
+    const run = state.taskRuns[0];
+    const request = state.providerRequests.find((item) => item.id === run?.providerRequestId);
+
+    expect(run).toMatchObject({ taskId, state: "failed", errorMessage: "provider rejected task" });
+    expect(request).toMatchObject({ state: "failed", errorMessage: "provider rejected task" });
+    expect(state.auditEvents.some((event) => event.entityType === "task_run" && event.action === "failed")).toBe(true);
+    connection.close();
+  });
+
+  test("requires task assignees to have a model provider", async () => {
+    const connection = createConnection();
+    const organization = new OrganizationService(connection.db);
+    const execution = new TaskExecutionService(connection.db);
+    let orgId = "";
+    let taskId = "";
+
+    connection.transaction(() => {
+      orgId = organization.createOrganization({
+        organizationName: "Acme Operations",
+        employeeName: "Dana Lee",
+        mission: "Coordinate agents with auditable approvals.",
+        goal: "Ship a verified control plane.",
+      });
+      const agentId = organization.createAgent({
+        orgId,
+        name: "Ada",
+        role: "Execution lead",
+        department: "Engineering",
+        modelProviderId: null,
+        modelId: null,
+        budgetCents: 10000,
+        managerAgentId: null,
+      });
+      taskId = organization.createTask({
+        orgId,
+        title: "Draft launch checklist",
+        description: "Prepare an auditable checklist for release readiness.",
+        status: TASK_STATUS.IN_PROGRESS,
+        assigneeAgentId: agentId,
+        risk: RISK_LEVEL.MEDIUM,
+        projectId: null,
+        goalId: null,
+        workspaceId: null,
+        priority: TASK_PRIORITY.HIGH,
+        requiresFilesystem: false,
+      });
+    });
+
+    await expect(execution.runTask({ orgId, taskId })).rejects.toThrow("Task assignee requires a model provider.");
+    expect(connection.db.prepare("select count(*) as count from task_runs").get()).toEqual({ count: 0 });
+    connection.close();
+  });
+});