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

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

@@ -1,5 +1,5 @@
 import { type DatabaseReader, type MutationCtx } from "../_generated/server.js";
-import type { Doc, Id } from "../_generated/dataModel.js";
+import type { Id } from "../_generated/dataModel.js";
 declare function slotToEventId(seq: number): string;
 export type AppendEventArgs = {
     orgId: string;
@@ -24,7 +24,7 @@ export declare function appendEventCore(ctx: MutationCtx, args: AppendEventArgs)
     };
     run: {
         runId: string;
-        status: "running" | "completed" | "cancelled" | "failed";
+        status: "completed" | "failed" | "cancelled" | "running";
         eventCount: number;
         createdAt: number;
         updatedAt: number;
@@ -32,7 +32,7 @@ export declare function appendEventCore(ctx: MutationCtx, args: AppendEventArgs)
     step: {
         runId: string;
         stepId: string;
-        status: "running" | "completed" | "failed";
+        status: "completed" | "failed" | "running";
         dataJson: string | undefined;
         createdAt: number;
         updatedAt: number;
@@ -68,7 +68,7 @@ export declare const appendEvent: import("convex/server").RegisteredMutation<"pu
     };
     run: {
         runId: string;
-        status: "running" | "completed" | "cancelled" | "failed";
+        status: "completed" | "failed" | "cancelled" | "running";
         eventCount: number;
         createdAt: number;
         updatedAt: number;
@@ -76,7 +76,7 @@ export declare const appendEvent: import("convex/server").RegisteredMutation<"pu
     step: {
         runId: string;
         stepId: string;
-        status: "running" | "completed" | "failed";
+        status: "completed" | "failed" | "running";
         dataJson: string | undefined;
         createdAt: number;
         updatedAt: number;
@@ -90,40 +90,38 @@ export declare const appendEvent: import("convex/server").RegisteredMutation<"pu
         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: {
+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 openRun(ctx: MutationCtx, args: {
     orgId: string;
-    table: "sessions" | "durableJobs";
-    legacyId: string;
+    kind: RunKind;
     data: Record<string, unknown>;
 }): Promise<string>;
-export declare function mirrorToRun(ctx: MutationCtx, args: {
+export declare const RUN_WORKFLOW_BOUND = "run_workflow_bound";
+export declare function bindWorkflowToRun(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";
+    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;
-    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">;
@@ -134,7 +132,7 @@ export declare const getRun: import("convex/server").RegisteredQuery<"public", {
     runId: string;
 }, Promise<{
     runId: string;
-    status: "running" | "completed" | "cancelled" | "failed";
+    status: "completed" | "failed" | "cancelled" | "running";
     eventCount: number;
     createdAt: number;
     updatedAt: number;
@@ -143,7 +141,7 @@ export declare const listRuns: import("convex/server").RegisteredQuery<"public",
     orgId: string;
 }, Promise<{
     runId: string;
-    status: "running" | "completed" | "cancelled" | "failed";
+    status: "completed" | "failed" | "cancelled" | "running";
     eventCount: number;
     createdAt: number;
     updatedAt: number;
@@ -155,7 +153,7 @@ export declare const getStep: import("convex/server").RegisteredQuery<"public",
 }, Promise<{
     runId: string;
     stepId: string;
-    status: "running" | "completed" | "failed";
+    status: "completed" | "failed" | "running";
     dataJson: string | undefined;
     createdAt: number;
     updatedAt: number;
@@ -166,7 +164,7 @@ export declare const listSteps: import("convex/server").RegisteredQuery<"public"
 }, Promise<{
     runId: string;
     stepId: string;
-    status: "running" | "completed" | "failed";
+    status: "completed" | "failed" | "running";
     dataJson: string | undefined;
     createdAt: number;
     updatedAt: number;

package/dist/component/engine/world.js

@@ -1,5 +1,6 @@
 import { v } from "convex/values";
 import { mutation, query, } from "../_generated/server.js";
+import { internal } from "../_generated/api.js";
 import { assertSameOrg, requireOrgId } from "../lib/auth.js";
 function pad26(n) {
     return String(n).padStart(26, "0");
@@ -243,15 +244,31 @@ export async function appendEventCore(ctx, args) {
             if (!parsed.token) {
                 throw new Error("Validation: hook_created payload requires token");
             }
+            const hasDeadline = parsed.expiresAt !== undefined;
+            if (hasDeadline) {
+                if (!Number.isFinite(parsed.expiresAt)) {
+                    throw new Error("Validation: hook_created expiresAt must be a number");
+                }
+                if (!parsed.awaitedEventName) {
+                    throw new Error("Validation: a hook with expiresAt requires awaitedEventName");
+                }
+                await loadRun(ctx, orgId, runId, "session", "Validation: a hook with a deadline requires a session run");
+            }
             const hookDocId = await ctx.db.insert("worldHooks", {
                 orgId,
                 runId,
                 hookId: args.hookId,
                 token: parsed.token,
                 status: "pending",
+                expiresAt: hasDeadline ? parsed.expiresAt : undefined,
+                awaitedEventName: hasDeadline ? parsed.awaitedEventName : undefined,
                 createdAt: now,
                 updatedAt: now,
             });
+            if (hasDeadline) {
+                const scheduledFunctionId = await ctx.scheduler.runAt(parsed.expiresAt, internal.engine.awaitEventTimeout.expire, { orgId, hookId: args.hookId });
+                await ctx.db.patch(hookDocId, { scheduledFunctionId });
+            }
             hookDoc = await ctx.db.get(hookDocId);
             break;
         }
@@ -264,6 +281,9 @@ export async function appendEventCore(ctx, args) {
                 .withIndex("by_org_hook", (q) => q.eq("orgId", orgId).eq("hookId", args.hookId))
                 .unique();
             assertSameOrg(orgId, existing, "Hook not found");
+            if (existing.scheduledFunctionId !== undefined) {
+                await ctx.scheduler.cancel(existing.scheduledFunctionId);
+            }
             await ctx.db.delete(existing._id);
             hookDoc = null;
             break;
@@ -346,44 +366,81 @@ export const appendEvent = mutation({
         hook: v.union(hookResult, v.null()),
     }),
     handler: async (ctx, args) => {
-        if (args.correlationId?.startsWith("legacy:")) {
+        if (args.correlationId?.startsWith(RUN_KIND_PREFIX) ||
+            args.correlationId?.startsWith(LEGACY_KIND_PREFIX)) {
             throw new Error("Validation: invalid correlationId");
         }
+        if (args.eventType === RUN_WORKFLOW_BOUND) {
+            throw new Error("Validation: invalid eventType");
+        }
         return appendEventCore(ctx, args);
     },
 });
-export function legacyCorrelationId(table, legacyId) {
-    return `legacy:${table}:${legacyId}`;
+export const RUN_KIND_PREFIX = "run:";
+export const LEGACY_KIND_PREFIX = "legacy:";
+const LEGACY_KIND_NAME = {
+    session: "sessions",
+    job: "durableJobs",
+};
+function runKindPrefix(kind) {
+    return `${RUN_KIND_PREFIX}${kind}:`;
 }
-export async function findRunIdByCorrelation(ctx, orgId, correlationId) {
-    const events = await ctx.db
-        .query("worldEvents")
-        .withIndex("by_org_correlation", (q) => q.eq("orgId", orgId).eq("correlationId", correlationId))
-        .collect();
-    return events.find((e) => e.eventType === "run_created")?.runId ?? null;
+function legacyKindPrefix(kind) {
+    return `${LEGACY_KIND_PREFIX}${LEGACY_KIND_NAME[kind]}:`;
 }
-export async function openLegacyRun(ctx, args) {
+export function legacyCorrelationId(kind, legacyId) {
+    return `${legacyKindPrefix(kind)}${legacyId}`;
+}
+export async function openRun(ctx, args) {
     const result = await appendEventCore(ctx, {
         orgId: args.orgId,
         runId: null,
         eventType: "run_created",
-        correlationId: legacyCorrelationId(args.table, args.legacyId),
+        correlationId: `${runKindPrefix(args.kind)}${crypto.randomUUID()}`,
         dataJson: JSON.stringify(args.data),
     });
     return result.event.runId;
 }
-export async function mirrorToRun(ctx, args) {
-    const runId = await findRunIdByCorrelation(ctx, args.orgId, legacyCorrelationId(args.table, args.legacyId));
-    if (runId === null)
-        return false;
+export const RUN_WORKFLOW_BOUND = "run_workflow_bound";
+function workflowCorrelationId(runId) {
+    return `workflow:${runId}`;
+}
+export async function bindWorkflowToRun(ctx, args) {
     await appendEventCore(ctx, {
         orgId: args.orgId,
-        runId,
-        eventType: args.eventType,
-        stepId: args.stepId,
-        dataJson: args.dataJson ?? "{}",
+        runId: args.runId,
+        eventType: RUN_WORKFLOW_BOUND,
+        correlationId: workflowCorrelationId(args.runId),
+        dataJson: JSON.stringify({
+            workflowId: args.workflowId,
+            workflowVersion: args.workflowVersion,
+        }),
     });
-    return true;
+}
+export async function workflowOfRun(ctx, orgId, runId) {
+    const events = await ctx.db
+        .query("worldEvents")
+        .withIndex("by_org_correlation", (q) => q.eq("orgId", orgId).eq("correlationId", workflowCorrelationId(runId)))
+        .collect();
+    let latest = null;
+    for (const e of events) {
+        if (e.eventType !== RUN_WORKFLOW_BOUND || e.runId !== runId)
+            continue;
+        if (latest === null || e.seq > latest.seq)
+            latest = e;
+    }
+    if (latest === null)
+        return null;
+    try {
+        const data = JSON.parse(latest.dataJson);
+        if (typeof data.workflowId !== "string" || typeof data.workflowVersion !== "string") {
+            return null;
+        }
+        return { workflowId: data.workflowId, workflowVersion: data.workflowVersion };
+    }
+    catch {
+        return null;
+    }
 }
 export async function loadRun(ctx, orgId, runId, kind, notFoundMessage) {
     const run = await ctx.db
@@ -395,11 +452,11 @@ export async function loadRun(ctx, orgId, runId, kind, notFoundMessage) {
         .query("worldEvents")
         .withIndex("by_org_run_seq", (q) => q.eq("orgId", orgId).eq("runId", runId).eq("seq", 1))
         .unique();
-    const prefix = `legacy:${kind}:`;
     if (!first ||
         first.eventType !== "run_created" ||
         first.correlationId === undefined ||
-        !first.correlationId.startsWith(prefix)) {
+        !(first.correlationId.startsWith(runKindPrefix(kind)) ||
+            first.correlationId.startsWith(legacyKindPrefix(kind)))) {
         throw new Error(notFoundMessage);
     }
     let created = {};
@@ -412,33 +469,13 @@ export async function loadRun(ctx, orgId, runId, kind, notFoundMessage) {
     catch {
         created = {};
     }
-    const legacyId = first.correlationId.slice(prefix.length);
     return {
         runId: run.runId,
         status: run.status,
         eventCount: run.eventCount,
-        legacyId: legacyId.length > 0 ? legacyId : null,
         created,
     };
 }
-export async function legacySessionOf(ctx, run, orgId) {
-    if (run.legacyId === null)
-        return null;
-    const id = ctx.db.normalizeId("sessions", run.legacyId);
-    if (id === null)
-        return null;
-    const doc = await ctx.db.get(id);
-    return doc !== null && doc.orgId === orgId ? doc : null;
-}
-export async function legacyJobOf(ctx, run, orgId) {
-    if (run.legacyId === null)
-        return null;
-    const id = ctx.db.normalizeId("durableJobs", run.legacyId);
-    if (id === null)
-        return null;
-    const doc = await ctx.db.get(id);
-    return doc !== null && doc.orgId === orgId ? doc : null;
-}
 export function agentIdOfRun(ctx, run) {
     const raw = run.created.agentId;
     const id = typeof raw === "string" ? ctx.db.normalizeId("agents", raw) : null;