@vantageos/agent-engine 0.1.0-alpha.8 → 0.3.0-alpha.1

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

@@ -1,11 +1,29 @@
 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">;
+export declare const resolveManifestInternalV2: import("convex/server").RegisteredQuery<"internal", {
+    orgId: string;
+    runId: string;
+}, Promise<null>>;
+export declare const sessionWorkflowV2: import("convex/server").RegisteredMutation<"internal", import("@convex-dev/workflow").WorkflowArgs<{
+    orgId: import("convex/values").VString<string, "required">;
+    runId: import("convex/values").VString<string, "required">;
 }>, import("@convex-dev/workflow").WorkflowId>;
+export declare const onSessionWorkflowCompleteV2: import("convex/server").RegisteredMutation<"internal", {
+    workflowId: import("@convex-dev/workflow").WorkflowId;
+    result: {
+        kind: "success";
+        returnValue: any;
+    } | {
+        kind: "failed";
+        error: string;
+    } | {
+        kind: "canceled";
+    };
+    context: {
+        orgId: string;
+        runId: string;
+    };
+}, Promise<null>>;
+export declare const stopBoxInternal: import("convex/server").RegisteredAction<"internal", {
+    boxId: string;
+}, Promise<null>>;

package/dist/component/engine/workflows.js

@@ -1,84 +1,79 @@
-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.
-export const resolveManifestInternal = internalQuery({
-    args: { sessionId: v.id("sessions") },
+import { internalAction, internalMutation, internalQuery } from "../_generated/server.js";
+import { agentIdOfRun, loadRun } from "./world.js";
+export const workflow = new WorkflowManager(components.workflow);
+export const resolveManifestInternalV2 = internalQuery({
+    args: { orgId: v.string(), runId: v.string() },
     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) {
+        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");
         }
-        // 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;
     },
 });
-export const recordTurnStartedInternal = internalMutation({
-    args: { sessionId: v.id("sessions") },
+export const sessionWorkflowV2 = workflow.define({
+    args: { orgId: v.string(), runId: v.string() },
     returns: v.null(),
-    handler: async (ctx, args) => {
-        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(),
+    handler: async (step, args) => {
+        await step.runQuery(internal.engine.workflows.resolveManifestInternalV2, {
+            orgId: args.orgId,
+            runId: args.runId,
         });
         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") },
+export const onSessionWorkflowCompleteV2 = internalMutation({
+    args: {
+        workflowId: vWorkflowId,
+        context: v.object({ orgId: v.string(), runId: v.string() }),
+        result: vResultValidator,
+    },
     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,
+    handler: async (ctx, args) => {
+        const { orgId, runId } = args.context;
+        let agentId;
+        try {
+            const run = await loadRun(ctx, orgId, runId, "session", "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,
         });
-        await step.runQuery(internal.engine.workflows.resolveManifestInternal, {
-            sessionId: args.sessionId,
+        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,250 @@
+import { type DatabaseReader, type MutationCtx } from "../_generated/server.js";
+import type { 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: "completed" | "failed" | "cancelled" | "running";
+        eventCount: number;
+        createdAt: number;
+        updatedAt: number;
+    };
+    step: {
+        runId: string;
+        stepId: string;
+        status: "completed" | "failed" | "running";
+        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: "completed" | "failed" | "cancelled" | "running";
+        eventCount: number;
+        createdAt: number;
+        updatedAt: number;
+    };
+    step: {
+        runId: string;
+        stepId: string;
+        status: "completed" | "failed" | "running";
+        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 RUN_KIND_PREFIX = "run:";
+export declare const LEGACY_KIND_PREFIX = "legacy:";
+export type RunKind = "session" | "job";
+export type RunStatus = "running" | "completed" | "failed" | "cancelled";
+export declare function legacyCorrelationId(kind: RunKind, legacyId: string): string;
+export declare function findRunIdByCorrelation(ctx: {
+    db: DatabaseReader;
+}, orgId: string, correlationId: string): Promise<string | null>;
+export declare function openRun(ctx: MutationCtx, args: {
+    orgId: string;
+    kind: RunKind;
+    data: Record<string, unknown>;
+}): Promise<string>;
+export declare const RUN_WORKFLOW_BOUND = "run_workflow_bound";
+export declare function bindWorkflowToRun(ctx: MutationCtx, args: {
+    orgId: string;
+    runId: string;
+    workflowId: string;
+    workflowVersion: string;
+}): Promise<void>;
+export declare function workflowOfRun(ctx: {
+    db: DatabaseReader;
+}, orgId: string, runId: string): Promise<{
+    workflowId: string;
+    workflowVersion: string;
+} | null>;
+export type LoadedRun = {
+    runId: string;
+    status: RunStatus;
+    eventCount: number;
+    created: Record<string, unknown>;
+};
+export declare function loadRun(ctx: {
+    db: DatabaseReader;
+}, orgId: string, runId: string, kind: RunKind, notFoundMessage: string): Promise<LoadedRun>;
+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: "completed" | "failed" | "cancelled" | "running";
+    eventCount: number;
+    createdAt: number;
+    updatedAt: number;
+} | null>>;
+export declare const listRuns: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+}, Promise<{
+    runId: string;
+    status: "completed" | "failed" | "cancelled" | "running";
+    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: "completed" | "failed" | "running";
+    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: "completed" | "failed" | "running";
+    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;
+}[]>>;