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

package/dist/component/engine/sandboxConfigProvider.js

@@ -0,0 +1,32 @@
+import { v } from "convex/values";
+import { mutation, query } from "../_generated/server.js";
+import { assertSameOrg, requireOrgId } from "../lib/auth.js";
+export const getBoxId = query({
+    args: { orgId: v.string(), agentId: v.id("agents") },
+    returns: v.union(v.string(), v.null()),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const row = await ctx.db
+            .query("sandboxConfig")
+            .withIndex("by_org_agent", (q) => q.eq("orgId", orgId).eq("agentId", args.agentId))
+            .unique();
+        return row?.boxId ?? null;
+    },
+});
+export const setBoxId = mutation({
+    args: { orgId: v.string(), agentId: v.id("agents"), boxId: v.string() },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        if (args.boxId.length === 0) {
+            throw new Error("Validation: boxId must not be empty");
+        }
+        const row = await ctx.db
+            .query("sandboxConfig")
+            .withIndex("by_org_agent", (q) => q.eq("orgId", orgId).eq("agentId", args.agentId))
+            .unique();
+        assertSameOrg(orgId, row, "sandboxConfig row not found for this agent");
+        await ctx.db.patch(row._id, { boxId: args.boxId, updatedAt: Date.now() });
+        return null;
+    },
+});

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

@@ -1,26 +1,38 @@
-import type { Id } from "../_generated/dataModel.js";
+import { type DatabaseReader, type MutationCtx } from "../_generated/server.js";
+import { type LoadedRun } from "./world.js";
+declare const SESSION_EVENT_NAMES: readonly ["session.started", "turn.started", "turn.reasoning", "turn.toolCall.requested", "turn.toolCall.completed", "turn.toolCall.denied", "turn.completed", "tool.approval.requested", "tool.approval.resolved", "sandbox.timeout"];
+type SessionEventName = (typeof SESSION_EVENT_NAMES)[number];
+export declare function loadSessionRun(ctx: {
+    db: DatabaseReader;
+}, orgId: string, sessionId: string): Promise<LoadedRun>;
+export declare function insertEvent(ctx: MutationCtx, args: {
+    orgId: string;
+    run: LoadedRun;
+    name: SessionEventName;
+    payload?: string;
+}): Promise<void>;
 export declare const start: import("convex/server").RegisteredMutation<"public", {
     orgId: string;
     createdBy: string;
     agentId: import("convex/values").GenericId<"agents">;
 }, Promise<{
-    sessionId: Id<"sessions">;
+    sessionId: string;
     workflowId: string;
 }>>;
 export declare const sendTurn: import("convex/server").RegisteredMutation<"public", {
     orgId: string;
-    sessionId: import("convex/values").GenericId<"sessions">;
+    sessionId: string;
     input: string;
 }, Promise<null>>;
 export declare const appendReasoning: import("convex/server").RegisteredMutation<"public", {
     orgId: string;
-    sessionId: import("convex/values").GenericId<"sessions">;
+    sessionId: string;
     chunk: string;
 }, Promise<null>>;
 export declare const requestToolCall: import("convex/server").RegisteredMutation<"public", {
     orgId: string;
     toolName: string;
-    sessionId: import("convex/values").GenericId<"sessions">;
+    sessionId: string;
     argsJson: string;
 }, Promise<{
     authorized: boolean;
@@ -30,20 +42,26 @@ export declare const requestToolCall: import("convex/server").RegisteredMutation
 export declare const completeToolCall: import("convex/server").RegisteredMutation<"public", {
     orgId: string;
     toolName: string;
-    sessionId: import("convex/values").GenericId<"sessions">;
+    sessionId: string;
     resultJson: string;
 }, Promise<null>>;
 export declare const completeTurn: import("convex/server").RegisteredMutation<"public", {
     orgId: string;
-    sessionId: import("convex/values").GenericId<"sessions">;
+    sessionId: string;
+}, Promise<null>>;
+export declare const end: import("convex/server").RegisteredMutation<"public", {
+    orgId: string;
+    sessionId: string;
+    outcome: "completed" | "cancelled";
 }, Promise<null>>;
 export declare const listEvents: import("convex/server").RegisteredQuery<"public", {
     orgId: string;
-    sessionId: import("convex/values").GenericId<"sessions">;
+    sessionId: string;
 }, Promise<{
-    _id: import("convex/values").GenericId<"sessionEvents">;
+    _id: string;
     _creationTime: number;
-    name: "session.started" | "turn.started" | "turn.reasoning" | "turn.toolCall.requested" | "turn.toolCall.completed" | "turn.toolCall.denied" | "turn.completed" | "tool.approval.requested" | "tool.approval.resolved" | "sandbox.timeout";
+    name: SessionEventName;
     payload: string | undefined;
     createdAt: number;
 }[]>>;
+export {};

package/dist/component/engine/sessions.js

@@ -1,61 +1,40 @@
 import { v } from "convex/values";
 import { api, internal } from "../_generated/api.js";
-import { mutation, query } from "../_generated/server.js";
+import { mutation, query, } from "../_generated/server.js";
 import { assertSameOrg, requireOrgId } from "../lib/auth.js";
 import { workflow } from "./workflows.js";
-// engine/sessions — THE FIL DE CONVERSATION contract (T2-QUINQUIES). This
-// is what unblocks EveVantage V4: open a session, send a turn, stream
-// reasoning/tool calls, gate on tool approval, replay the thread on
-// reconnect. See component/schema.ts for the event log this is built on
-// (`sessionEvents` IS the streaming transport via Convex reactivity — no
-// separate channel).
-//
-// Named events mirror eve's session/turn boundaries
-// (dynamic-tool-definition.ts:40-46): `session.started`, `turn.started`.
-// `resolvers.resolveManifest` (engine/resolvers.ts) is reread at BOTH of
-// those boundaries — never mid-turn — so an agent edit is visible at the
-// very next turn with zero redeploy.
-async function insertEvent(ctx, args) {
-    await ctx.db.insert("sessionEvents", {
+import { agentIdOfRun, appendEventCore, bindWorkflowToRun, loadRun, openRun, payloadOrUndefined, slotToEventId, } from "./world.js";
+const SESSION_EVENT_NAMES = [
+    "session.started",
+    "turn.started",
+    "turn.reasoning",
+    "turn.toolCall.requested",
+    "turn.toolCall.completed",
+    "turn.toolCall.denied",
+    "turn.completed",
+    "tool.approval.requested",
+    "tool.approval.resolved",
+    "sandbox.timeout",
+];
+function isSessionEventName(name) {
+    return SESSION_EVENT_NAMES.includes(name);
+}
+const NOT_FOUND = "Session not found";
+export async function loadSessionRun(ctx, orgId, sessionId) {
+    return await loadRun(ctx, orgId, sessionId, "session", NOT_FOUND);
+}
+export async function insertEvent(ctx, args) {
+    await appendEventCore(ctx, {
         orgId: args.orgId,
-        sessionId: args.sessionId,
-        name: args.name,
-        payload: args.payload,
-        createdAt: Date.now(),
+        runId: args.run.runId,
+        eventType: args.name,
+        dataJson: args.payload ?? "{}",
     });
 }
-const CURRENT_SESSION_WORKFLOW_VERSION = "v1";
-// start — opens a session (session.started boundary), rereading the
-// manifest immediately so a caller can act on it before the first turn,
-// then STARTS the durable, versioned session workflow
-// (engine/workflows.ts:sessionWorkflowV1) that pilots this session from
-// here on.
-//
-// RETURN CONTRACT ("intentional divergence from Eve"): `start` returns
-// `{ sessionId, workflowId }` instead of a bare `sessionId`. A bare ID
-// would be the shape for a session with no workflow to reference;
-// once a session IS piloted by a real, durable workflow run, silently
-// dropping that run's id would make it unobservable/uncancellable to
-// every caller except one that re-reads the session row. Returning both
-// fields explicitly, rather than only patching `workflowId` onto the row
-// and making callers re-fetch, keeps `start`'s result self-sufficient for
-// the common "immediately act on the new session" case while the session
-// row remains the durable source of truth for reconnects/replays.
+const CURRENT_SESSION_WORKFLOW_VERSION = "v2";
 export const start = mutation({
     args: { orgId: v.string(), agentId: v.id("agents"), createdBy: v.string() },
-    returns: v.object({ sessionId: v.id("sessions"), workflowId: v.string() }),
-    // EXPLICIT return-type annotation ("intentional divergence from Eve" -- Convex pattern for
-    // any handler that references `components`/a WorkflowManager built on
-    // `components.workflow`): `workflow.start` closes over `components`,
-    // which closes back over this component's own generated `api` --
-    // `sessions.start` -> `workflow.start` -> `components` -> `sessions` is
-    // a type-level cycle. Without an explicit handler return type, TS
-    // widens the inferred return to `any` while resolving that cycle, and
-    // `.d.ts` EMISSION (declaration:true, tsconfig.build.json) fails --
-    // TS2502/TS2615/TS7022 -- even though `tsc --noEmit` at the repo root
-    // stays green (noEmit skips the exact codepath that breaks). Measured
-    // on PR #13 (build gate review): `npm run build` is the build that SHIPS; a
-    // green `tsc --noEmit` is not sufficient proof by itself.
+    returns: v.object({ sessionId: v.string(), workflowId: v.string() }),
     handler: async (ctx, args) => {
         const orgId = requireOrgId(args.orgId);
         if (args.createdBy.trim().length === 0) {
@@ -63,113 +42,86 @@ export const start = mutation({
         }
         const agent = await ctx.db.get(args.agentId);
         assertSameOrg(orgId, agent, "Agent not found");
-        const now = Date.now();
-        const sessionId = await ctx.db.insert("sessions", {
+        const runId = await openRun(ctx, {
             orgId,
-            agentId: args.agentId,
-            status: "running",
-            createdBy: args.createdBy,
-            createdAt: now,
-            updatedAt: now,
+            kind: "session",
+            data: {
+                agentId: args.agentId,
+                createdBy: args.createdBy,
+                workflowVersion: CURRENT_SESSION_WORKFLOW_VERSION,
+            },
         });
-        await insertEvent(ctx, { orgId, sessionId, name: "session.started" });
-        await ctx.runQuery(api.engine.resolvers.resolveManifest, {
-            orgId,
-            sessionId,
+        const workflowId = await workflow.start(ctx, internal.engine.workflows.sessionWorkflowV2, { orgId, runId }, {
+            onComplete: internal.engine.workflows.onSessionWorkflowCompleteV2,
+            context: { orgId, runId },
         });
-        const workflowId = await workflow.start(ctx, internal.engine.workflows.sessionWorkflowV1, { sessionId });
-        await ctx.db.patch(sessionId, {
+        await bindWorkflowToRun(ctx, {
+            orgId,
+            runId,
             workflowId,
             workflowVersion: CURRENT_SESSION_WORKFLOW_VERSION,
         });
-        return { sessionId, workflowId };
+        const run = await loadSessionRun(ctx, orgId, runId);
+        await insertEvent(ctx, { orgId, run, name: "session.started" });
+        await ctx.runQuery(api.engine.resolvers.resolveManifest, {
+            orgId,
+            sessionId: runId,
+        });
+        return { sessionId: runId, workflowId };
     },
 });
-// sendTurn — turn.started boundary. Rereads the manifest (eve parity: dynamic
-// resolvers only allowed to reread at session.started/turn.started).
-// `input` is the caller-owned turn payload (already-serialized JSON/text);
-// this component does not interpret it -- it is stored verbatim as the
-// event payload for replay.
 export const sendTurn = mutation({
-    args: { orgId: v.string(), sessionId: v.id("sessions"), input: v.string() },
+    args: { orgId: v.string(), sessionId: v.string(), input: v.string() },
     returns: v.null(),
     handler: async (ctx, args) => {
         const orgId = requireOrgId(args.orgId);
-        const session = await ctx.db.get(args.sessionId);
-        assertSameOrg(orgId, session, "Session not found");
-        if (session.status !== "running") {
-            throw new Error(`Session is not running (status=${session.status})`);
+        const run = await loadSessionRun(ctx, orgId, args.sessionId);
+        if (run.status !== "running") {
+            throw new Error(`Session is not running (status=${run.status})`);
         }
-        await insertEvent(ctx, {
-            orgId,
-            sessionId: args.sessionId,
-            name: "turn.started",
-            payload: args.input,
-        });
+        await insertEvent(ctx, { orgId, run, name: "turn.started", payload: args.input });
         await ctx.runQuery(api.engine.resolvers.resolveManifest, {
             orgId,
             sessionId: args.sessionId,
         });
-        await ctx.db.patch(args.sessionId, { updatedAt: Date.now() });
         return null;
     },
 });
-// appendReasoning — one streamed reasoning chunk. Convex query reactivity
-// on `listEvents` is the streaming transport: each insert here is pushed to
-// every subscriber live, no separate channel needed.
 export const appendReasoning = mutation({
-    args: { orgId: v.string(), sessionId: v.id("sessions"), chunk: v.string() },
+    args: { orgId: v.string(), sessionId: v.string(), chunk: v.string() },
     returns: v.null(),
     handler: async (ctx, args) => {
         const orgId = requireOrgId(args.orgId);
-        const session = await ctx.db.get(args.sessionId);
-        assertSameOrg(orgId, session, "Session not found");
-        await insertEvent(ctx, {
-            orgId,
-            sessionId: args.sessionId,
-            name: "turn.reasoning",
-            payload: args.chunk,
-        });
+        const run = await loadSessionRun(ctx, orgId, args.sessionId);
+        await insertEvent(ctx, { orgId, run, name: "turn.reasoning", payload: args.chunk });
         return null;
     },
 });
-// requestToolCall — gates on the agent's toolApprovals row for `toolName`
-// (default "never" = no gate). "always" gates every call; "once" gates
-// unless already resolved earlier in THIS session. Returns whether the
-// caller may proceed immediately or must wait for
-// `toolApprovals.respond`.
 export const requestToolCall = mutation({
     args: {
         orgId: v.string(),
-        sessionId: v.id("sessions"),
+        sessionId: v.string(),
         toolName: v.string(),
         argsJson: v.string(),
     },
     returns: v.object({
         authorized: v.boolean(),
         approvalPending: v.boolean(),
-        // Explicit terminal refusal for THIS turn (VP
-        // k17ea6x3tht8xa3rxm139t23gx8ajkf3, defaut 2). Distinct from
-        // `approvalPending: false, authorized: true` (approved/never-gated)
-        // -- a caller must check this before treating the call as skippable.
         denied: v.boolean(),
     }),
     handler: async (ctx, args) => {
         const orgId = requireOrgId(args.orgId);
-        const session = await ctx.db.get(args.sessionId);
-        assertSameOrg(orgId, session, "Session not found");
+        const run = await loadSessionRun(ctx, orgId, args.sessionId);
+        const agentId = agentIdOfRun(ctx, run);
         await insertEvent(ctx, {
             orgId,
-            sessionId: args.sessionId,
+            run,
             name: "turn.toolCall.requested",
             payload: JSON.stringify({ toolName: args.toolName, args: args.argsJson }),
         });
         const approvalRow = await ctx.db
             .query("toolApprovals")
-            .withIndex("by_org_agent_tool", (q) => q
-            .eq("orgId", orgId)
-            .eq("agentId", session.agentId)
-            .eq("toolName", args.toolName))
+            .withIndex("by_org_agent_tool", (q) => q.eq("orgId", orgId).eq("agentId", agentId).eq("toolName", args.toolName))
             .unique();
         const approval = approvalRow?.approval ?? "never";
         if (approval === "never") {
@@ -178,34 +130,32 @@ export const requestToolCall = mutation({
         if (approval === "always") {
             await insertEvent(ctx, {
                 orgId,
-                sessionId: args.sessionId,
+                run,
                 name: "tool.approval.requested",
                 payload: JSON.stringify({ toolName: args.toolName }),
             });
             return { authorized: false, approvalPending: true, denied: false };
         }
-        // approval === "once": gate unless this tool's approval was already
-        // resolved with `decision: "approved"` in this session. A prior
-        // `decision: "denied"` resolution must NOT be treated as
-        // authorization (the tool would be skipped while the turn still
-        // completed) -- it is reported back as a terminal refusal
-        // instead, and the caller re-requests (a fresh human decision) rather
-        // than silently proceeding.
-        const events = await ctx.db
-            .query("sessionEvents")
-            .withIndex("by_org_session", (q) => q.eq("orgId", orgId).eq("sessionId", args.sessionId))
+        const journal = await ctx.db
+            .query("worldEvents")
+            .withIndex("by_org_run_seq", (q) => q.eq("orgId", orgId).eq("runId", run.runId))
             .collect();
-        const resolutionsForTool = events
-            .filter((e) => e.name === "tool.approval.resolved" &&
-            e.payload !== undefined &&
-            JSON.parse(e.payload).toolName ===
-                args.toolName)
-            .sort((a, b) => a.createdAt - b.createdAt);
-        const latestResolution = resolutionsForTool[resolutionsForTool.length - 1];
-        const latestDecision = latestResolution?.payload
-            ? JSON.parse(latestResolution.payload)
-                .decision
-            : undefined;
+        let latestDecision;
+        for (const e of journal) {
+            if (e.eventType !== "tool.approval.resolved")
+                continue;
+            let resolved;
+            try {
+                resolved = JSON.parse(e.dataJson);
+            }
+            catch {
+                continue;
+            }
+            if (resolved.toolName === args.toolName) {
+                latestDecision =
+                    typeof resolved.decision === "string" ? resolved.decision : undefined;
+            }
+        }
         if (latestDecision === "approved") {
             return { authorized: true, approvalPending: false, denied: false };
         }
@@ -214,85 +164,95 @@ export const requestToolCall = mutation({
         }
         await insertEvent(ctx, {
             orgId,
-            sessionId: args.sessionId,
+            run,
             name: "tool.approval.requested",
             payload: JSON.stringify({ toolName: args.toolName }),
         });
         return { authorized: false, approvalPending: true, denied: false };
     },
 });
-// completeToolCall — the caller invokes this after actually running the
-// tool (authorized immediately, or after `toolApprovals.respond` cleared
-// the gate).
 export const completeToolCall = mutation({
     args: {
         orgId: v.string(),
-        sessionId: v.id("sessions"),
+        sessionId: v.string(),
         toolName: v.string(),
         resultJson: v.string(),
     },
     returns: v.null(),
     handler: async (ctx, args) => {
         const orgId = requireOrgId(args.orgId);
-        const session = await ctx.db.get(args.sessionId);
-        assertSameOrg(orgId, session, "Session not found");
+        const run = await loadSessionRun(ctx, orgId, args.sessionId);
         await insertEvent(ctx, {
             orgId,
-            sessionId: args.sessionId,
+            run,
             name: "turn.toolCall.completed",
             payload: JSON.stringify({ toolName: args.toolName, result: args.resultJson }),
         });
         return null;
     },
 });
-// completeTurn — closes the current turn.
 export const completeTurn = mutation({
-    args: { orgId: v.string(), sessionId: v.id("sessions") },
+    args: { orgId: v.string(), sessionId: v.string() },
     returns: v.null(),
     handler: async (ctx, args) => {
         const orgId = requireOrgId(args.orgId);
-        const session = await ctx.db.get(args.sessionId);
-        assertSameOrg(orgId, session, "Session not found");
-        await insertEvent(ctx, {
+        const run = await loadSessionRun(ctx, orgId, args.sessionId);
+        await insertEvent(ctx, { orgId, run, name: "turn.completed" });
+        return null;
+    },
+});
+export const end = mutation({
+    args: {
+        orgId: v.string(),
+        sessionId: v.string(),
+        outcome: v.union(v.literal("completed"), v.literal("cancelled")),
+    },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const run = await loadSessionRun(ctx, orgId, args.sessionId);
+        if (run.status !== "running") {
+            if (run.status === args.outcome)
+                return null;
+            throw new Error(`Session already ended (status=${run.status}); cannot end as ${args.outcome}`);
+        }
+        await appendEventCore(ctx, {
             orgId,
-            sessionId: args.sessionId,
-            name: "turn.completed",
+            runId: run.runId,
+            eventType: args.outcome === "completed" ? "run_completed" : "run_cancelled",
+            dataJson: JSON.stringify({ outcome: args.outcome }),
         });
-        await ctx.db.patch(args.sessionId, { updatedAt: Date.now() });
         return null;
     },
 });
-// listEvents — REPLAY ON RECONNECT: the full ordered event log for a
-// session. A client that drops and reconnects calls this once to rebuild
-// the thread, then subscribes (Convex reactivity) for anything after.
 export const listEvents = query({
-    args: { orgId: v.string(), sessionId: v.id("sessions") },
+    args: { orgId: v.string(), sessionId: v.string() },
     returns: v.array(v.object({
-        _id: v.id("sessionEvents"),
+        _id: v.string(),
         _creationTime: v.number(),
-        name: v.union(v.literal("session.started"), v.literal("turn.started"), v.literal("turn.reasoning"), v.literal("turn.toolCall.requested"), v.literal("turn.toolCall.completed"), v.literal("turn.toolCall.denied"), v.literal("turn.completed"), v.literal("tool.approval.requested"), v.literal("tool.approval.resolved"), 
-        // Blank event auto-inserted by
-        // `engine/awaitEventTimeout.fire` (workflow#177).
-        v.literal("sandbox.timeout")),
+        name: v.union(v.literal("session.started"), v.literal("turn.started"), v.literal("turn.reasoning"), v.literal("turn.toolCall.requested"), v.literal("turn.toolCall.completed"), v.literal("turn.toolCall.denied"), v.literal("turn.completed"), v.literal("tool.approval.requested"), v.literal("tool.approval.resolved"), v.literal("sandbox.timeout")),
         payload: v.optional(v.string()),
         createdAt: v.number(),
     })),
     handler: async (ctx, args) => {
         const orgId = requireOrgId(args.orgId);
-        const session = await ctx.db.get(args.sessionId);
-        assertSameOrg(orgId, session, "Session not found");
-        const events = await ctx.db
-            .query("sessionEvents")
-            .withIndex("by_org_session", (q) => q.eq("orgId", orgId).eq("sessionId", args.sessionId))
+        const run = await loadSessionRun(ctx, orgId, args.sessionId);
+        const journal = await ctx.db
+            .query("worldEvents")
+            .withIndex("by_org_run_seq", (q) => q.eq("orgId", orgId).eq("runId", run.runId))
             .collect();
-        return events
-            .sort((a, b) => a.createdAt - b.createdAt)
-            .map((e) => ({
-            _id: e._id,
-            _creationTime: e._creationTime,
-            name: e.name,
-            payload: e.payload,
-            createdAt: e.createdAt,
-        }));
+        const out = [];
+        for (const e of journal) {
+            if (!isSessionEventName(e.eventType))
+                continue;
+            out.push({
+                _id: slotToEventId(e.seq),
+                _creationTime: e.createdAt,
+                name: e.eventType,
+                payload: payloadOrUndefined(e.dataJson),
+                createdAt: e.createdAt,
+            });
+        }
+        return out;
     },
 });

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

@@ -0,0 +1,47 @@
+export declare const writeChunk: import("convex/server").RegisteredMutation<"public", {
+    name: string;
+    orgId: string;
+    runId: string;
+    dataBase64: string;
+}, Promise<null>>;
+export declare const closeStream: import("convex/server").RegisteredMutation<"public", {
+    name: string;
+    orgId: string;
+    runId: string;
+}, Promise<null>>;
+export declare const getStreamInfo: import("convex/server").RegisteredQuery<"public", {
+    name: string;
+    orgId: string;
+    runId: string;
+}, Promise<{
+    tailIndex: number;
+    done: boolean;
+}>>;
+export declare const listStreamNames: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    runId: string;
+}, Promise<string[]>>;
+export declare const listChunksPage: import("convex/server").RegisteredQuery<"public", {
+    name: string;
+    orgId: string;
+    runId: string;
+    limit: number;
+    cursor: string | null;
+}, Promise<{
+    page: {
+        index: number;
+        dataBase64: string;
+    }[];
+    isDone: boolean;
+    continueCursor: string;
+}>>;
+export declare const listChunksFromIndex: import("convex/server").RegisteredQuery<"public", {
+    name: string;
+    orgId: string;
+    runId: string;
+    limit: number;
+    startIndex: number;
+}, Promise<{
+    index: number;
+    dataBase64: string;
+}[]>>;