@vantageos/agent-engine 0.1.0-alpha.7 → 0.3.0-alpha.0

package/dist/component/engine/workflows.js

@@ -1,21 +1,8 @@
-import { WorkflowManager } from "@convex-dev/workflow";
+import { WorkflowManager, vResultValidator, vWorkflowId } from "@convex-dev/workflow";
 import { v } from "convex/values";
 import { components, internal } from "../_generated/api.js";
-import { internalMutation, internalQuery } from "../_generated/server.js";
-// The durable, VERSIONED session workflow. This is what makes
-// `sessions.start` open a session PILOTED by `@convex-dev/workflow` rather
-// than a bare event table.
-//
-// Trust model at this boundary: the workflow engine runs with NO end-user
-// identity and NO client-supplied orgId (component isolation, same
-// discipline as component/engine/durableJob.ts and component/lib/auth.ts).
-// Every internal step below reads orgId from the `sessions` row itself --
-// never from an argument a workflow step could be handed by a caller.
-// Internal (server-to-server only) variants of the resolver/session
-// mutations, used by the workflow step handlers below. The workflow engine
-// runs with no end-user identity, so these read/write scoped strictly by
-// the orgId already recorded on the session row -- never trusting a
-// client-supplied orgId.
+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(),
@@ -27,9 +14,6 @@ export const resolveManifestInternal = internalQuery({
         if (!agent || agent.orgId !== session.orgId) {
             throw new Error("Agent not found");
         }
-        // Resolution result is consumed by the caller via the public
-        // engine/resolvers:resolveManifest query; this internal step exists to
-        // prove (and test) that the reread happens at each boundary.
         return null;
     },
 });
@@ -40,39 +24,17 @@ export const recordTurnStartedInternal = internalMutation({
         const session = await ctx.db.get(args.sessionId);
         if (!session)
             throw new Error("Session not found");
-        await ctx.db.insert("sessionEvents", {
-            orgId: session.orgId,
-            sessionId: args.sessionId,
-            name: "turn.started",
-            payload: undefined,
-            createdAt: Date.now(),
-        });
         return null;
     },
 });
-// Versioned workflow discipline (workflow#35): "if you change much
-// of anything in a workflow while there are ongoing workflows, they'll
-// fail." We never edit a workflow function in place once sessions
-// reference it -- a breaking change ships as `sessionWorkflowV2`, and the
-// deploy is preceded by draining v1 sessions (0 rows with
-// sessions.workflowVersion == "v1" and status == "running"). Same
-// discipline as `engine/durableJob.ts:durableJobWorkflowV1`.
 export const workflow = new WorkflowManager(components.workflow);
-// sessionWorkflowV1 -- the durable session loop. At `session.started` and
-// at every `turn.started` boundary it rereads the agent aggregate (never
-// cached, never compiled) via `resolveManifestInternal`. Tool approvals
-// pause the workflow via `step.awaitEvent`, guarded by the self-built
-// timeout (workflow#177) once that surface is ported into this component.
 export const sessionWorkflowV1 = workflow.define({
     args: { sessionId: v.id("sessions") },
     returns: v.null(),
     handler: async (step, args) => {
-        // session.started boundary: read the aggregate once at start.
         await step.runQuery(internal.engine.workflows.resolveManifestInternal, {
             sessionId: args.sessionId,
         });
-        // turn.started boundary: re-read on every turn so an agent/skill edit
-        // made mid-session is visible at the very next turn, with zero deploy.
         await step.runMutation(internal.engine.workflows.recordTurnStartedInternal, {
             sessionId: args.sessionId,
         });
@@ -82,3 +44,100 @@ export const sessionWorkflowV1 = workflow.define({
         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 agent = await ctx.db.get(agentIdOfRun(ctx, run));
+        if (!agent || agent.orgId !== args.orgId) {
+            throw new Error("Agent not found");
+        }
+        return null;
+    },
+});
+export const sessionWorkflowV2 = workflow.define({
+    args: { orgId: v.string(), runId: v.string() },
+    returns: v.null(),
+    handler: async (step, args) => {
+        await step.runQuery(internal.engine.workflows.resolveManifestInternalV2, {
+            orgId: args.orgId,
+            runId: args.runId,
+        });
+        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,
+        context: v.object({ orgId: v.string(), runId: v.string() }),
+        result: vResultValidator,
+    },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const { orgId, runId } = args.context;
+        let agentId;
+        try {
+            const run = await loadRun(ctx, orgId, runId, "sessions", "Session not found");
+            agentId = agentIdOfRun(ctx, run);
+        }
+        catch {
+            return null;
+        }
+        const sandboxConfigRow = await ctx.db
+            .query("sandboxConfig")
+            .withIndex("by_org_agent", (q) => q.eq("orgId", orgId).eq("agentId", agentId))
+            .unique();
+        const boxId = sandboxConfigRow?.boxId;
+        if (!boxId)
+            return null;
+        await ctx.scheduler.runAfter(0, internal.engine.workflows.stopBoxInternal, {
+            boxId,
+        });
+        return null;
+    },
+});
+export const stopBoxInternal = internalAction({
+    args: { boxId: v.string() },
+    returns: v.null(),
+    handler: async (_ctx, args) => {
+        const apiKey = process.env.BOAT_API_KEY;
+        if (!apiKey || apiKey.length === 0) {
+            throw new Error("stopBoxInternal: BOAT_API_KEY is not set; refusing to skip the box-stop call silently");
+        }
+        const baseUrl = process.env.BOX_API_BASE_URL ?? "https://ascii.dev/api/box/v1";
+        const response = await fetch(`${baseUrl.replace(/\/$/, "")}/boxes/${encodeURIComponent(args.boxId)}/stop`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`stopBoxInternal: POST /boxes/${args.boxId}/stop failed (${response.status}): ${text}`);
+        }
+        return null;
+    },
+});

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

@@ -0,0 +1,249 @@
+import { type DatabaseReader, type MutationCtx } from "../_generated/server.js";
+import type { Doc, Id } from "../_generated/dataModel.js";
+declare function slotToEventId(seq: number): string;
+export type AppendEventArgs = {
+    orgId: string;
+    runId: string | null;
+    eventType: string;
+    stepId?: string;
+    hookId?: string;
+    correlationId?: string;
+    dataJson: string;
+};
+export declare function appendEventCore(ctx: MutationCtx, args: AppendEventArgs): Promise<{
+    event: {
+        eventId: string;
+        seq: number;
+        runId: string;
+        eventType: string;
+        stepId: string | undefined;
+        hookId: string | undefined;
+        correlationId: string | undefined;
+        dataJson: string;
+        createdAt: number;
+    };
+    run: {
+        runId: string;
+        status: "running" | "completed" | "cancelled" | "failed";
+        eventCount: number;
+        createdAt: number;
+        updatedAt: number;
+    };
+    step: {
+        runId: string;
+        stepId: string;
+        status: "running" | "completed" | "failed";
+        dataJson: string | undefined;
+        createdAt: number;
+        updatedAt: number;
+    } | null;
+    hook: {
+        runId: string;
+        hookId: string;
+        token: string;
+        status: "pending" | "disposed";
+        createdAt: number;
+        updatedAt: number;
+    } | null;
+}>;
+export declare const appendEvent: import("convex/server").RegisteredMutation<"public", {
+    stepId?: string | undefined;
+    hookId?: string | undefined;
+    correlationId?: string | undefined;
+    orgId: string;
+    runId: string | null;
+    dataJson: string;
+    eventType: string;
+}, Promise<{
+    event: {
+        eventId: string;
+        seq: number;
+        runId: string;
+        eventType: string;
+        stepId: string | undefined;
+        hookId: string | undefined;
+        correlationId: string | undefined;
+        dataJson: string;
+        createdAt: number;
+    };
+    run: {
+        runId: string;
+        status: "running" | "completed" | "cancelled" | "failed";
+        eventCount: number;
+        createdAt: number;
+        updatedAt: number;
+    };
+    step: {
+        runId: string;
+        stepId: string;
+        status: "running" | "completed" | "failed";
+        dataJson: string | undefined;
+        createdAt: number;
+        updatedAt: number;
+    } | null;
+    hook: {
+        runId: string;
+        hookId: string;
+        token: string;
+        status: "pending" | "disposed";
+        createdAt: number;
+        updatedAt: number;
+    } | null;
+}>>;
+export declare function legacyCorrelationId(table: "sessions" | "durableJobs", legacyId: string): string;
+export declare function findRunIdByCorrelation(ctx: MutationCtx, orgId: string, correlationId: string): Promise<string | null>;
+export declare function openLegacyRun(ctx: MutationCtx, args: {
+    orgId: string;
+    table: "sessions" | "durableJobs";
+    legacyId: string;
+    data: Record<string, unknown>;
+}): Promise<string>;
+export declare function mirrorToRun(ctx: MutationCtx, args: {
+    orgId: string;
+    table: "sessions" | "durableJobs";
+    legacyId: string;
+    eventType: string;
+    stepId?: string;
+    dataJson?: string;
+}): Promise<boolean>;
+export type RunKind = "sessions" | "durableJobs";
+export type RunStatus = "running" | "completed" | "failed" | "cancelled";
+export type LoadedRun = {
+    runId: string;
+    status: RunStatus;
+    eventCount: number;
+    legacyId: string | null;
+    created: Record<string, unknown>;
+};
+export declare function loadRun(ctx: {
+    db: DatabaseReader;
+}, orgId: string, runId: string, kind: RunKind, notFoundMessage: string): Promise<LoadedRun>;
+export declare function legacySessionOf(ctx: {
+    db: DatabaseReader;
+}, run: LoadedRun, orgId: string): Promise<Doc<"sessions"> | null>;
+export declare function legacyJobOf(ctx: {
+    db: DatabaseReader;
+}, run: LoadedRun, orgId: string): Promise<Doc<"durableJobs"> | null>;
+export declare function agentIdOfRun(ctx: {
+    db: DatabaseReader;
+}, run: LoadedRun): Id<"agents">;
+export declare function payloadOrUndefined(dataJson: string): string | undefined;
+export { slotToEventId };
+export declare const getRun: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    runId: string;
+}, Promise<{
+    runId: string;
+    status: "running" | "completed" | "cancelled" | "failed";
+    eventCount: number;
+    createdAt: number;
+    updatedAt: number;
+} | null>>;
+export declare const listRuns: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+}, Promise<{
+    runId: string;
+    status: "running" | "completed" | "cancelled" | "failed";
+    eventCount: number;
+    createdAt: number;
+    updatedAt: number;
+}[]>>;
+export declare const getStep: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    runId: string;
+    stepId: string;
+}, Promise<{
+    runId: string;
+    stepId: string;
+    status: "running" | "completed" | "failed";
+    dataJson: string | undefined;
+    createdAt: number;
+    updatedAt: number;
+} | null>>;
+export declare const listSteps: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    runId: string;
+}, Promise<{
+    runId: string;
+    stepId: string;
+    status: "running" | "completed" | "failed";
+    dataJson: string | undefined;
+    createdAt: number;
+    updatedAt: number;
+}[]>>;
+export declare const getEvent: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    runId: string;
+    eventId: string;
+}, Promise<{
+    eventId: string;
+    seq: number;
+    runId: string;
+    eventType: string;
+    stepId: string | undefined;
+    hookId: string | undefined;
+    correlationId: string | undefined;
+    dataJson: string;
+    createdAt: number;
+} | null>>;
+export declare const listEvents: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    runId: string;
+}, Promise<{
+    eventId: string;
+    seq: number;
+    runId: string;
+    eventType: string;
+    stepId: string | undefined;
+    hookId: string | undefined;
+    correlationId: string | undefined;
+    dataJson: string;
+    createdAt: number;
+}[]>>;
+export declare const listEventsByCorrelationId: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    correlationId: string;
+}, Promise<{
+    eventId: string;
+    seq: number;
+    runId: string;
+    eventType: string;
+    stepId: string | undefined;
+    hookId: string | undefined;
+    correlationId: string | undefined;
+    dataJson: string;
+    createdAt: number;
+}[]>>;
+export declare const getHook: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    hookId: string;
+}, Promise<{
+    runId: string;
+    hookId: string;
+    token: string;
+    status: "pending" | "disposed";
+    createdAt: number;
+    updatedAt: number;
+} | null>>;
+export declare const getHookByToken: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    token: string;
+}, Promise<{
+    runId: string;
+    hookId: string;
+    token: string;
+    status: "pending" | "disposed";
+    createdAt: number;
+    updatedAt: number;
+} | null>>;
+export declare const listHooks: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    runId: string;
+}, Promise<{
+    runId: string;
+    hookId: string;
+    token: string;
+    status: "pending" | "disposed";
+    createdAt: number;
+    updatedAt: number;
+}[]>>;