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

package/dist/component/engine/sessions.js

@@ -1,61 +1,50 @@
 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, legacySessionOf, loadRun, openLegacyRun, 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, "sessions", 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 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 = "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) {
@@ -64,112 +53,95 @@ 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 legacySessionId = await ctx.db.insert("sessions", {
             orgId,
             agentId: args.agentId,
             status: "running",
             createdBy: args.createdBy,
             createdAt: now,
             updatedAt: now,
+            workflowVersion: CURRENT_SESSION_WORKFLOW_VERSION,
         });
-        await insertEvent(ctx, { orgId, sessionId, name: "session.started" });
-        await ctx.runQuery(api.engine.resolvers.resolveManifest, {
+        const runId = await openLegacyRun(ctx, {
             orgId,
-            sessionId,
+            table: "sessions",
+            legacyId: legacySessionId,
+            data: {
+                agentId: args.agentId,
+                createdBy: args.createdBy,
+                workflowVersion: CURRENT_SESSION_WORKFLOW_VERSION,
+            },
         });
-        const workflowId = await workflow.start(ctx, internal.engine.workflows.sessionWorkflowV1, { sessionId });
-        await ctx.db.patch(sessionId, {
-            workflowId,
-            workflowVersion: CURRENT_SESSION_WORKFLOW_VERSION,
+        const workflowId = await workflow.start(ctx, internal.engine.workflows.sessionWorkflowV2, { orgId, runId }, {
+            onComplete: internal.engine.workflows.onSessionWorkflowCompleteV2,
+            context: { orgId, runId },
         });
-        return { sessionId, workflowId };
+        await ctx.db.patch(legacySessionId, { 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() });
+        const legacy = await legacySessionOf(ctx, run, orgId);
+        if (legacy !== null) {
+            await ctx.db.patch(legacy._id, { 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 +150,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 +184,103 @@ 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" });
+        const legacy = await legacySessionOf(ctx, run, orgId);
+        if (legacy !== null) {
+            await ctx.db.patch(legacy._id, { updatedAt: Date.now() });
+        }
+        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() });
+        const legacy = await legacySessionOf(ctx, run, orgId);
+        if (legacy !== null) {
+            await ctx.db.patch(legacy._id, { status: args.outcome, 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;
+    cursor: string | null;
+    runId: string;
+    limit: number;
+}, 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;
+}[]>>;

package/dist/component/engine/streams.js

@@ -0,0 +1,162 @@
+import { v } from "convex/values";
+import { mutation, query } from "../_generated/server.js";
+import { requireOrgId } from "../lib/auth.js";
+const streamInfoResult = v.object({ tailIndex: v.number(), done: v.boolean() });
+const streamChunkResult = v.object({ index: v.number(), dataBase64: v.string() });
+async function getStreamDoc(ctx, orgId, runId, name) {
+    return await ctx.db
+        .query("worldStreams")
+        .withIndex("by_org_run_name", (q) => q.eq("orgId", orgId).eq("runId", runId).eq("name", name))
+        .unique();
+}
+export const writeChunk = mutation({
+    args: { orgId: v.string(), runId: v.string(), name: v.string(), dataBase64: v.string() },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const now = Date.now();
+        let stream = await getStreamDoc(ctx, orgId, args.runId, args.name);
+        if (stream && stream.orgId !== orgId) {
+            stream = null;
+        }
+        if (!stream) {
+            const id = await ctx.db.insert("worldStreams", {
+                orgId,
+                runId: args.runId,
+                name: args.name,
+                chunkCount: 0,
+                done: false,
+                createdAt: now,
+                updatedAt: now,
+            });
+            stream = await ctx.db.get(id);
+        }
+        if (!stream) {
+            throw new Error("Stream row failed to materialise");
+        }
+        if (stream.done) {
+            throw new Error(`Cannot write to a closed stream: ${args.runId}/${args.name}`);
+        }
+        const index = stream.chunkCount;
+        await ctx.db.insert("worldStreamChunks", {
+            orgId,
+            runId: args.runId,
+            name: args.name,
+            index,
+            dataBase64: args.dataBase64,
+            createdAt: now,
+        });
+        await ctx.db.patch(stream._id, { chunkCount: index + 1, updatedAt: now });
+        return null;
+    },
+});
+export const closeStream = mutation({
+    args: { orgId: v.string(), runId: v.string(), name: v.string() },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const now = Date.now();
+        let stream = await getStreamDoc(ctx, orgId, args.runId, args.name);
+        if (stream && stream.orgId !== orgId) {
+            stream = null;
+        }
+        if (!stream) {
+            const id = await ctx.db.insert("worldStreams", {
+                orgId,
+                runId: args.runId,
+                name: args.name,
+                chunkCount: 0,
+                done: true,
+                createdAt: now,
+                updatedAt: now,
+            });
+            stream = await ctx.db.get(id);
+        }
+        else {
+            await ctx.db.patch(stream._id, { done: true, updatedAt: now });
+        }
+        return null;
+    },
+});
+export const getStreamInfo = query({
+    args: { orgId: v.string(), runId: v.string(), name: v.string() },
+    returns: streamInfoResult,
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const doc = await getStreamDoc(ctx, orgId, args.runId, args.name);
+        if (!doc || doc.orgId !== orgId) {
+            return { tailIndex: -1, done: false };
+        }
+        return { tailIndex: doc.chunkCount - 1, done: doc.done };
+    },
+});
+export const listStreamNames = query({
+    args: { orgId: v.string(), runId: v.string() },
+    returns: v.array(v.string()),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const docs = await ctx.db
+            .query("worldStreams")
+            .withIndex("by_org_run", (q) => q.eq("orgId", orgId).eq("runId", args.runId))
+            .collect();
+        return docs.filter((d) => d.orgId === orgId).map((d) => d.name);
+    },
+});
+export const listChunksPage = query({
+    args: {
+        orgId: v.string(),
+        runId: v.string(),
+        name: v.string(),
+        limit: v.number(),
+        cursor: v.union(v.string(), v.null()),
+    },
+    returns: v.object({
+        page: v.array(streamChunkResult),
+        isDone: v.boolean(),
+        continueCursor: v.string(),
+    }),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const startIndex = args.cursor === null ? 0 : Number(args.cursor);
+        const docs = await ctx.db
+            .query("worldStreamChunks")
+            .withIndex("by_org_run_name_index", (q) => q
+            .eq("orgId", orgId)
+            .eq("runId", args.runId)
+            .eq("name", args.name)
+            .gte("index", startIndex))
+            .order("asc")
+            .take(args.limit + 1);
+        const owned = docs.filter((d) => d.orgId === orgId);
+        const isDone = owned.length <= args.limit;
+        const page = isDone ? owned : owned.slice(0, args.limit);
+        return {
+            page: page.map((c) => ({ index: c.index, dataBase64: c.dataBase64 })),
+            isDone,
+            continueCursor: isDone ? "" : String(page[page.length - 1].index + 1),
+        };
+    },
+});
+export const listChunksFromIndex = query({
+    args: {
+        orgId: v.string(),
+        runId: v.string(),
+        name: v.string(),
+        startIndex: v.number(),
+        limit: v.number(),
+    },
+    returns: v.array(streamChunkResult),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const docs = await ctx.db
+            .query("worldStreamChunks")
+            .withIndex("by_org_run_name_index", (q) => q
+            .eq("orgId", orgId)
+            .eq("runId", args.runId)
+            .eq("name", args.name)
+            .gte("index", args.startIndex))
+            .order("asc")
+            .take(args.limit);
+        return docs.filter((d) => d.orgId === orgId).map((c) => ({ index: c.index, dataBase64: c.dataBase64 }));
+    },
+});

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

@@ -2,6 +2,6 @@ export declare const respond: import("convex/server").RegisteredMutation<"public
     updatePolicy?: "always" | "once" | "never" | undefined;
     orgId: string;
     toolName: string;
-    sessionId: import("convex/values").GenericId<"sessions">;
+    sessionId: string;
     decision: "approved" | "denied";
 }, Promise<null>>;