@vantageos/agent-engine 0.3.0-alpha.0 → 0.3.0-alpha.1

package/dist/component/engine/durableJob.js

@@ -3,10 +3,10 @@ import { WorkflowManager } from "@convex-dev/workflow";
 import { components, internal } from "../_generated/api.js";
 import { internalMutation, internalQuery, mutation, query, } from "../_generated/server.js";
 import { requireOrgId } from "../lib/auth.js";
-import { appendEventCore, legacyJobOf, loadRun, mirrorToRun, openLegacyRun, } from "./world.js";
+import { appendEventCore, bindWorkflowToRun, loadRun, openRun, workflowOfRun, } from "./world.js";
 const CURRENT_WORKFLOW_VERSION = "v2";
 async function readJob(ctx, orgId, runId, notFoundMessage = "Job not found") {
-    const run = await loadRun(ctx, orgId, runId, "durableJobs", notFoundMessage);
+    const run = await loadRun(ctx, orgId, runId, "job", notFoundMessage);
     const num = (field) => {
         const value = run.created[field];
         if (typeof value !== "number") {
@@ -55,23 +55,9 @@ export const start = mutation({
         if (args.stepFunctionHandle.length === 0) {
             throw new Error("Validation: stepFunctionHandle must not be empty");
         }
-        const now = Date.now();
-        const legacyJobId = await ctx.db.insert("durableJobs", {
+        const runId = await openRun(ctx, {
             orgId,
-            kind: args.kind,
-            stepFunctionHandle: args.stepFunctionHandle,
-            totalSteps: args.totalSteps,
-            maxAttemptsPerStep: args.maxAttemptsPerStep,
-            cursor: 0,
-            status: "running",
-            workflowVersion: CURRENT_WORKFLOW_VERSION,
-            createdAt: now,
-            updatedAt: now,
-        });
-        const runId = await openLegacyRun(ctx, {
-            orgId,
-            table: "durableJobs",
-            legacyId: legacyJobId,
+            kind: "job",
             data: {
                 kind: args.kind,
                 stepFunctionHandle: args.stepFunctionHandle,
@@ -81,7 +67,12 @@ export const start = mutation({
             },
         });
         const workflowId = await workflow.start(ctx, internal.engine.durableJob.durableJobWorkflowV2, { orgId, runId });
-        await ctx.db.patch(legacyJobId, { workflowId });
+        await bindWorkflowToRun(ctx, {
+            orgId,
+            runId,
+            workflowId,
+            workflowVersion: CURRENT_WORKFLOW_VERSION,
+        });
         return runId;
     },
 });
@@ -133,7 +124,7 @@ export const cancel = mutation({
     returns: v.null(),
     handler: async (ctx, args) => {
         const orgId = requireOrgId(args.orgId);
-        const run = await loadRun(ctx, orgId, args.jobId, "durableJobs", "Job not found");
+        const run = await loadRun(ctx, orgId, args.jobId, "job", "Job not found");
         if (run.status !== "running")
             return null;
         await appendEventCore(ctx, {
@@ -142,184 +133,10 @@ export const cancel = mutation({
             eventType: "run_cancelled",
             dataJson: "{}",
         });
-        const legacy = await legacyJobOf(ctx, run, orgId);
-        if (legacy !== null) {
-            await ctx.db.patch(legacy._id, {
-                status: "cancelled",
-                updatedAt: Date.now(),
-            });
-            if (legacy.workflowId) {
-                await workflow.cancel(ctx, legacy.workflowId);
-            }
-        }
-        return null;
-    },
-});
-export const getJobInternal = internalQuery({
-    args: { jobId: v.id("durableJobs") },
-    returns: v.union(v.object({
-        cursor: v.number(),
-        totalSteps: v.number(),
-        maxAttemptsPerStep: v.number(),
-        status: v.union(v.literal("running"), v.literal("completed"), v.literal("abandoned"), v.literal("cancelled")),
-    }), v.null()),
-    handler: async (ctx, args) => {
-        const job = await ctx.db.get(args.jobId);
-        if (!job)
-            return null;
-        return {
-            cursor: job.cursor,
-            totalSteps: job.totalSteps,
-            maxAttemptsPerStep: job.maxAttemptsPerStep,
-            status: job.status,
-        };
-    },
-});
-export const runStepInternal = internalMutation({
-    args: { jobId: v.id("durableJobs"), stepIndex: v.number() },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        const job = await ctx.db.get(args.jobId);
-        if (!job)
-            throw new Error("Job not found");
-        if (job.status === "cancelled")
-            return null;
-        if (args.stepIndex < job.cursor) {
-            return null;
-        }
-        const stepId = String(args.stepIndex);
-        await mirrorToRun(ctx, {
-            orgId: job.orgId,
-            table: "durableJobs",
-            legacyId: args.jobId,
-            eventType: "step_created",
-            stepId,
-        });
-        await mirrorToRun(ctx, {
-            orgId: job.orgId,
-            table: "durableJobs",
-            legacyId: args.jobId,
-            eventType: "step_started",
-            stepId,
-        });
-        let lastError;
-        for (let attempt = 1; attempt <= job.maxAttemptsPerStep; attempt++) {
-            try {
-                await ctx.runMutation(job.stepFunctionHandle, { orgId: job.orgId, jobId: args.jobId, stepIndex: args.stepIndex });
-                await ctx.db.patch(args.jobId, {
-                    cursor: args.stepIndex + 1,
-                    updatedAt: Date.now(),
-                });
-                await mirrorToRun(ctx, {
-                    orgId: job.orgId,
-                    table: "durableJobs",
-                    legacyId: args.jobId,
-                    eventType: "step_completed",
-                    stepId,
-                    dataJson: JSON.stringify({ attempt }),
-                });
-                return null;
-            }
-            catch (err) {
-                lastError = err;
-            }
-        }
-        throw lastError instanceof Error
-            ? lastError
-            : new Error(String(lastError));
-    },
-});
-export const markAbandonedInternal = internalMutation({
-    args: { jobId: v.id("durableJobs"), stepIndex: v.number(), error: v.string() },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        const job = await ctx.db.get(args.jobId);
-        if (!job || job.status !== "running")
-            return null;
-        await ctx.db.patch(args.jobId, {
-            status: "abandoned",
-            abandonedAtStep: args.stepIndex,
-            lastError: args.error,
-            updatedAt: Date.now(),
-        });
-        const stepId = String(args.stepIndex);
-        await mirrorToRun(ctx, {
-            orgId: job.orgId,
-            table: "durableJobs",
-            legacyId: args.jobId,
-            eventType: "step_created",
-            stepId,
-        });
-        await mirrorToRun(ctx, {
-            orgId: job.orgId,
-            table: "durableJobs",
-            legacyId: args.jobId,
-            eventType: "step_failed",
-            stepId,
-            dataJson: JSON.stringify({ error: args.error }),
-        });
-        await mirrorToRun(ctx, {
-            orgId: job.orgId,
-            table: "durableJobs",
-            legacyId: args.jobId,
-            eventType: "run_failed",
-            dataJson: JSON.stringify({
-                reason: "abandoned",
-                abandonedAtStep: args.stepIndex,
-                lastError: args.error,
-            }),
-        });
-        return null;
-    },
-});
-export const markCompletedInternal = internalMutation({
-    args: { jobId: v.id("durableJobs") },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        const job = await ctx.db.get(args.jobId);
-        if (!job || job.status !== "running")
-            return null;
-        await ctx.db.patch(args.jobId, {
-            status: "completed",
-            updatedAt: Date.now(),
-        });
-        await mirrorToRun(ctx, {
-            orgId: job.orgId,
-            table: "durableJobs",
-            legacyId: args.jobId,
-            eventType: "run_completed",
-        });
-        return null;
-    },
-});
-export const durableJobWorkflowV1 = workflow.define({
-    args: { jobId: v.id("durableJobs") },
-    returns: v.null(),
-    handler: async (step, args) => {
-        const job = await step.runQuery(internal.engine.durableJob.getJobInternal, {
-            jobId: args.jobId,
-        });
-        if (!job || job.status !== "running")
-            return null;
-        for (let i = job.cursor; i < job.totalSteps; i++) {
-            try {
-                await step.runMutation(internal.engine.durableJob.runStepInternal, {
-                    jobId: args.jobId,
-                    stepIndex: i,
-                });
-            }
-            catch (err) {
-                await step.runMutation(internal.engine.durableJob.markAbandonedInternal, {
-                    jobId: args.jobId,
-                    stepIndex: i,
-                    error: err instanceof Error ? err.message : String(err),
-                });
-                return null;
-            }
+        const bound = await workflowOfRun(ctx, orgId, run.runId);
+        if (bound !== null) {
+            await workflow.cancel(ctx, bound.workflowId);
         }
-        await step.runMutation(internal.engine.durableJob.markCompletedInternal, {
-            jobId: args.jobId,
-        });
         return null;
     },
 });
@@ -379,13 +196,6 @@ export const runStepInternalV2 = internalMutation({
         for (let attempt = 1; attempt <= job.maxAttemptsPerStep; attempt++) {
             try {
                 await ctx.runMutation(job.stepFunctionHandle, { orgId: args.orgId, jobId: args.runId, stepIndex: args.stepIndex });
-                const legacy = await legacyJobOf(ctx, job.run, args.orgId);
-                if (legacy !== null) {
-                    await ctx.db.patch(legacy._id, {
-                        cursor: args.stepIndex + 1,
-                        updatedAt: Date.now(),
-                    });
-                }
                 await appendEventCore(ctx, {
                     orgId: args.orgId,
                     runId: args.runId,
@@ -416,15 +226,6 @@ export const markAbandonedInternalV2 = internalMutation({
         const job = await readJob(ctx, args.orgId, args.runId);
         if (job.run.status !== "running")
             return null;
-        const legacy = await legacyJobOf(ctx, job.run, args.orgId);
-        if (legacy !== null) {
-            await ctx.db.patch(legacy._id, {
-                status: "abandoned",
-                abandonedAtStep: args.stepIndex,
-                lastError: args.error,
-                updatedAt: Date.now(),
-            });
-        }
         const stepId = String(args.stepIndex);
         await appendEventCore(ctx, {
             orgId: args.orgId,
@@ -460,10 +261,6 @@ export const markCompletedInternalV2 = internalMutation({
         const job = await readJob(ctx, args.orgId, args.runId);
         if (job.run.status !== "running")
             return null;
-        const legacy = await legacyJobOf(ctx, job.run, args.orgId);
-        if (legacy !== null) {
-            await ctx.db.patch(legacy._id, { status: "completed", updatedAt: Date.now() });
-        }
         await appendEventCore(ctx, {
             orgId: args.orgId,
             runId: args.runId,

package/dist/component/engine/mandates.d.ts

@@ -2,11 +2,11 @@ import type { Id } from "../_generated/dataModel.js";
 export declare const set: import("convex/server").RegisteredMutation<"public", {
     capacity?: number | undefined;
     orgId: string;
-    kind: "token bucket" | "fixed window";
     agentId: import("convex/values").GenericId<"agents">;
     scope: string;
     rate: number;
     period: number;
+    kind: "token bucket" | "fixed window";
 }, Promise<import("convex/values").GenericId<"mandates">>>;
 export declare const get: import("convex/server").RegisteredQuery<"public", {
     orgId: string;
@@ -19,11 +19,11 @@ export declare const get: import("convex/server").RegisteredQuery<"public", {
     orgId: string;
     createdAt: number;
     updatedAt: number;
-    kind: "token bucket" | "fixed window";
     agentId: import("convex/values").GenericId<"agents">;
     scope: string;
     rate: number;
     period: number;
+    kind: "token bucket" | "fixed window";
 } | null>>;
 export declare const spend: import("convex/server").RegisteredMutation<"public", {
     orgId: string;

package/dist/component/engine/resolvers.js

@@ -16,7 +16,7 @@ export const resolveManifest = query({
     }),
     handler: async (ctx, args) => {
         const orgId = requireOrgId(args.orgId);
-        const run = await loadRun(ctx, orgId, args.sessionId, "sessions", "Session not found");
+        const run = await loadRun(ctx, orgId, args.sessionId, "session", "Session not found");
         const agentId = agentIdOfRun(ctx, run);
         const agent = await ctx.db.get(agentId);
         assertSameOrg(orgId, agent, "Agent not found");

package/dist/component/engine/sandboxCallback.d.ts

@@ -1,7 +1,7 @@
 export declare const startRun: import("convex/server").RegisteredMutation<"public", {
     orgId: string;
-    workflowId: string;
     awaitedEventName: string;
+    workflowId: string;
     timeoutMs: number;
 }, Promise<import("convex/values").GenericId<"sandboxRuns">>>;
 export declare const attachSandboxId: import("convex/server").RegisteredMutation<"public", {

package/dist/component/engine/sessions.js

@@ -3,7 +3,7 @@ import { api, internal } from "../_generated/api.js";
 import { mutation, query, } from "../_generated/server.js";
 import { assertSameOrg, requireOrgId } from "../lib/auth.js";
 import { workflow } from "./workflows.js";
-import { agentIdOfRun, appendEventCore, legacySessionOf, loadRun, openLegacyRun, payloadOrUndefined, slotToEventId, } from "./world.js";
+import { agentIdOfRun, appendEventCore, bindWorkflowToRun, loadRun, openRun, payloadOrUndefined, slotToEventId, } from "./world.js";
 const SESSION_EVENT_NAMES = [
     "session.started",
     "turn.started",
@@ -21,7 +21,7 @@ function isSessionEventName(name) {
 }
 const NOT_FOUND = "Session not found";
 export async function loadSessionRun(ctx, orgId, sessionId) {
-    return await loadRun(ctx, orgId, sessionId, "sessions", NOT_FOUND);
+    return await loadRun(ctx, orgId, sessionId, "session", NOT_FOUND);
 }
 export async function insertEvent(ctx, args) {
     await appendEventCore(ctx, {
@@ -30,16 +30,6 @@ export async function insertEvent(ctx, args) {
         eventType: args.name,
         dataJson: args.payload ?? "{}",
     });
-    const legacy = await legacySessionOf(ctx, args.run, args.orgId);
-    if (legacy !== null) {
-        await ctx.db.insert("sessionEvents", {
-            orgId: args.orgId,
-            sessionId: legacy._id,
-            name: args.name,
-            payload: args.payload,
-            createdAt: Date.now(),
-        });
-    }
 }
 const CURRENT_SESSION_WORKFLOW_VERSION = "v2";
 export const start = mutation({
@@ -52,20 +42,9 @@ export const start = mutation({
         }
         const agent = await ctx.db.get(args.agentId);
         assertSameOrg(orgId, agent, "Agent not found");
-        const now = Date.now();
-        const legacySessionId = await ctx.db.insert("sessions", {
+        const runId = await openRun(ctx, {
             orgId,
-            agentId: args.agentId,
-            status: "running",
-            createdBy: args.createdBy,
-            createdAt: now,
-            updatedAt: now,
-            workflowVersion: CURRENT_SESSION_WORKFLOW_VERSION,
-        });
-        const runId = await openLegacyRun(ctx, {
-            orgId,
-            table: "sessions",
-            legacyId: legacySessionId,
+            kind: "session",
             data: {
                 agentId: args.agentId,
                 createdBy: args.createdBy,
@@ -76,7 +55,12 @@ export const start = mutation({
             onComplete: internal.engine.workflows.onSessionWorkflowCompleteV2,
             context: { orgId, runId },
         });
-        await ctx.db.patch(legacySessionId, { workflowId });
+        await bindWorkflowToRun(ctx, {
+            orgId,
+            runId,
+            workflowId,
+            workflowVersion: CURRENT_SESSION_WORKFLOW_VERSION,
+        });
         const run = await loadSessionRun(ctx, orgId, runId);
         await insertEvent(ctx, { orgId, run, name: "session.started" });
         await ctx.runQuery(api.engine.resolvers.resolveManifest, {
@@ -100,10 +84,6 @@ export const sendTurn = mutation({
             orgId,
             sessionId: args.sessionId,
         });
-        const legacy = await legacySessionOf(ctx, run, orgId);
-        if (legacy !== null) {
-            await ctx.db.patch(legacy._id, { updatedAt: Date.now() });
-        }
         return null;
     },
 });
@@ -218,10 +198,6 @@ export const completeTurn = mutation({
         const orgId = requireOrgId(args.orgId);
         const run = await loadSessionRun(ctx, orgId, args.sessionId);
         await insertEvent(ctx, { orgId, run, name: "turn.completed" });
-        const legacy = await legacySessionOf(ctx, run, orgId);
-        if (legacy !== null) {
-            await ctx.db.patch(legacy._id, { updatedAt: Date.now() });
-        }
         return null;
     },
 });
@@ -246,10 +222,6 @@ export const end = mutation({
             eventType: args.outcome === "completed" ? "run_completed" : "run_cancelled",
             dataJson: JSON.stringify({ outcome: args.outcome }),
         });
-        const legacy = await legacySessionOf(ctx, run, orgId);
-        if (legacy !== null) {
-            await ctx.db.patch(legacy._id, { status: args.outcome, updatedAt: Date.now() });
-        }
         return null;
     },
 });

package/dist/component/engine/streams.d.ts

@@ -24,9 +24,9 @@ export declare const listStreamNames: import("convex/server").RegisteredQuery<"p
 export declare const listChunksPage: import("convex/server").RegisteredQuery<"public", {
     name: string;
     orgId: string;
-    cursor: string | null;
     runId: string;
     limit: number;
+    cursor: string | null;
 }, Promise<{
     page: {
         index: number;

package/dist/component/engine/wakeup.d.ts

@@ -3,19 +3,19 @@ export declare const wakeupPool: Workpool;
 export declare const enqueue: import("convex/server").RegisteredAction<"public", {
     payload?: string | undefined;
     orgId: string;
-    workflowId: string;
     agentId: import("convex/values").GenericId<"agents">;
     awaitedEventName: string;
     scope: string;
     reason: string;
+    workflowId: string;
     cost: number;
     workFunctionHandle: string;
 }, Promise<string>>;
 export declare const enqueueInternal: import("convex/server").RegisteredMutation<"internal", {
     payload?: string | undefined;
     orgId: string;
-    workflowId: string;
     awaitedEventName: string;
+    workflowId: string;
     workFunctionHandle: string;
 }, Promise<string>>;
 export declare const cancel: import("convex/server").RegisteredMutation<"public", {

package/dist/component/engine/workflows.d.ts

@@ -1,14 +1,5 @@
 import { WorkflowManager } from "@convex-dev/workflow";
-export declare const resolveManifestInternal: import("convex/server").RegisteredQuery<"internal", {
-    sessionId: import("convex/values").GenericId<"sessions">;
-}, Promise<null>>;
-export declare const recordTurnStartedInternal: import("convex/server").RegisteredMutation<"internal", {
-    sessionId: import("convex/values").GenericId<"sessions">;
-}, Promise<null>>;
 export declare const workflow: WorkflowManager;
-export declare const sessionWorkflowV1: import("convex/server").RegisteredMutation<"internal", import("@convex-dev/workflow").WorkflowArgs<{
-    sessionId: import("convex/values").VId<import("convex/values").GenericId<"sessions">, "required">;
-}>, import("@convex-dev/workflow").WorkflowId>;
 export declare const resolveManifestInternalV2: import("convex/server").RegisteredQuery<"internal", {
     orgId: string;
     runId: string;
@@ -17,21 +8,6 @@ export declare const sessionWorkflowV2: import("convex/server").RegisteredMutati
     orgId: import("convex/values").VString<string, "required">;
     runId: import("convex/values").VString<string, "required">;
 }>, import("@convex-dev/workflow").WorkflowId>;
-export declare const onSessionWorkflowComplete: import("convex/server").RegisteredMutation<"internal", {
-    workflowId: import("@convex-dev/workflow").WorkflowId;
-    result: {
-        kind: "success";
-        returnValue: any;
-    } | {
-        kind: "failed";
-        error: string;
-    } | {
-        kind: "canceled";
-    };
-    context: {
-        sessionId: import("convex/values").GenericId<"sessions">;
-    };
-}, Promise<null>>;
 export declare const onSessionWorkflowCompleteV2: import("convex/server").RegisteredMutation<"internal", {
     workflowId: import("@convex-dev/workflow").WorkflowId;
     result: {

package/dist/component/engine/workflows.js

@@ -3,52 +3,12 @@ import { v } from "convex/values";
 import { components, internal } from "../_generated/api.js";
 import { internalAction, internalMutation, internalQuery } from "../_generated/server.js";
 import { agentIdOfRun, loadRun } from "./world.js";
-export const resolveManifestInternal = internalQuery({
-    args: { sessionId: v.id("sessions") },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        const session = await ctx.db.get(args.sessionId);
-        if (!session)
-            throw new Error("Session not found");
-        const agent = await ctx.db.get(session.agentId);
-        if (!agent || agent.orgId !== session.orgId) {
-            throw new Error("Agent not found");
-        }
-        return null;
-    },
-});
-export const recordTurnStartedInternal = internalMutation({
-    args: { sessionId: v.id("sessions") },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        const session = await ctx.db.get(args.sessionId);
-        if (!session)
-            throw new Error("Session not found");
-        return null;
-    },
-});
 export const workflow = new WorkflowManager(components.workflow);
-export const sessionWorkflowV1 = workflow.define({
-    args: { sessionId: v.id("sessions") },
-    returns: v.null(),
-    handler: async (step, args) => {
-        await step.runQuery(internal.engine.workflows.resolveManifestInternal, {
-            sessionId: args.sessionId,
-        });
-        await step.runMutation(internal.engine.workflows.recordTurnStartedInternal, {
-            sessionId: args.sessionId,
-        });
-        await step.runQuery(internal.engine.workflows.resolveManifestInternal, {
-            sessionId: args.sessionId,
-        });
-        return null;
-    },
-});
 export const resolveManifestInternalV2 = internalQuery({
     args: { orgId: v.string(), runId: v.string() },
     returns: v.null(),
     handler: async (ctx, args) => {
-        const run = await loadRun(ctx, args.orgId, args.runId, "sessions", "Session not found");
+        const run = await loadRun(ctx, args.orgId, args.runId, "session", "Session not found");
         const agent = await ctx.db.get(agentIdOfRun(ctx, run));
         if (!agent || agent.orgId !== args.orgId) {
             throw new Error("Agent not found");
@@ -67,30 +27,6 @@ export const sessionWorkflowV2 = workflow.define({
         return null;
     },
 });
-export const onSessionWorkflowComplete = internalMutation({
-    args: {
-        workflowId: vWorkflowId,
-        context: v.object({ sessionId: v.id("sessions") }),
-        result: vResultValidator,
-    },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        const session = await ctx.db.get(args.context.sessionId);
-        if (!session)
-            return null;
-        const sandboxConfigRow = await ctx.db
-            .query("sandboxConfig")
-            .withIndex("by_org_agent", (q) => q.eq("orgId", session.orgId).eq("agentId", session.agentId))
-            .unique();
-        const boxId = sandboxConfigRow?.boxId;
-        if (!boxId)
-            return null;
-        await ctx.scheduler.runAfter(0, internal.engine.workflows.stopBoxInternal, {
-            boxId,
-        });
-        return null;
-    },
-});
 export const onSessionWorkflowCompleteV2 = internalMutation({
     args: {
         workflowId: vWorkflowId,
@@ -102,7 +38,7 @@ export const onSessionWorkflowCompleteV2 = internalMutation({
         const { orgId, runId } = args.context;
         let agentId;
         try {
-            const run = await loadRun(ctx, orgId, runId, "sessions", "Session not found");
+            const run = await loadRun(ctx, orgId, runId, "session", "Session not found");
             agentId = agentIdOfRun(ctx, run);
         }
         catch {