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

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

@@ -1,70 +0,0 @@
-export declare const create: import("convex/server").RegisteredMutation<"public", {
-    name: string;
-    orgId: string;
-    agentId: import("convex/values").GenericId<"agents">;
-    cronExpression: string;
-    prompt: string;
-}, Promise<import("convex/values").GenericId<"habits">>>;
-export declare const get: import("convex/server").RegisteredQuery<"public", {
-    orgId: string;
-    habitId: import("convex/values").GenericId<"habits">;
-}, Promise<{
-    _id: import("convex/values").GenericId<"habits">;
-    _creationTime: number;
-    cronJobId?: string | undefined;
-    lastRunAt?: number | undefined;
-    name: string;
-    orgId: string;
-    createdAt: number;
-    updatedAt: number;
-    agentId: import("convex/values").GenericId<"agents">;
-    cronExpression: string;
-    prompt: string;
-    enabled: boolean;
-} | null>>;
-export declare const listForAgent: import("convex/server").RegisteredQuery<"public", {
-    orgId: string;
-    agentId: import("convex/values").GenericId<"agents">;
-}, Promise<{
-    _id: import("convex/values").GenericId<"habits">;
-    _creationTime: number;
-    cronJobId?: string | undefined;
-    lastRunAt?: number | undefined;
-    name: string;
-    orgId: string;
-    createdAt: number;
-    updatedAt: number;
-    agentId: import("convex/values").GenericId<"agents">;
-    cronExpression: string;
-    prompt: string;
-    enabled: boolean;
-}[]>>;
-export declare const updateSchedule: import("convex/server").RegisteredMutation<"public", {
-    name?: string | undefined;
-    cronExpression?: string | undefined;
-    prompt?: string | undefined;
-    orgId: string;
-    habitId: import("convex/values").GenericId<"habits">;
-}, Promise<null>>;
-export declare const disable: import("convex/server").RegisteredMutation<"public", {
-    orgId: string;
-    habitId: import("convex/values").GenericId<"habits">;
-}, Promise<null>>;
-export declare const enable: import("convex/server").RegisteredMutation<"public", {
-    orgId: string;
-    habitId: import("convex/values").GenericId<"habits">;
-}, Promise<null>>;
-export declare const run: import("convex/server").RegisteredMutation<"internal", {
-    habitId: import("convex/values").GenericId<"habits">;
-}, Promise<null>>;
-export declare const listRuns: import("convex/server").RegisteredQuery<"public", {
-    orgId: string;
-    habitId: import("convex/values").GenericId<"habits">;
-}, Promise<{
-    _id: import("convex/values").GenericId<"habitRuns">;
-    _creationTime: number;
-    orgId: string;
-    agentId: import("convex/values").GenericId<"agents">;
-    habitId: import("convex/values").GenericId<"habits">;
-    ranAt: number;
-}[]>>;

package/dist/component/engine/habits.js

@@ -1,218 +0,0 @@
-import { v } from "convex/values";
-import { Crons } from "@convex-dev/crons";
-import { internal, components } from "../_generated/api.js";
-import { internalMutation, mutation, query } from "../_generated/server.js";
-import { assertSameOrg, requireOrgId } from "../lib/auth.js";
-// engine/habits — "intentional divergence from Eve": a habit is what turns
-// a chat into an employee. A habit is a DYNAMIC cron per agent/org,
-// registered at runtime via @convex-dev/crons — never a static
-// `convex/crons.ts`. Creating, running, editing or disabling one deploys
-// nothing: the `cronExpression` is DATA carried by the `habits` row, and
-// the runtime cron is merely a reflection of it.
-//
-// orgId discipline (component/lib/auth.ts): every PUBLIC function takes
-// `orgId` as an explicit ARGUMENT (auth does not propagate across a
-// component boundary), same as engine/mandates.ts. The cron runtime
-// target is `internal.engine.habits.run` -- the component-boundary path
-// for this module, mirroring `internal.habits.run` at the app level.
-const crons = new Crons(components.crons);
-const habitDoc = v.object({
-    _id: v.id("habits"),
-    _creationTime: v.number(),
-    orgId: v.string(),
-    agentId: v.id("agents"),
-    name: v.string(),
-    cronExpression: v.string(),
-    prompt: v.string(),
-    enabled: v.boolean(),
-    cronJobId: v.optional(v.string()),
-    lastRunAt: v.optional(v.number()),
-    createdAt: v.number(),
-    updatedAt: v.number(),
-});
-// create — writes the habit row AND registers its runtime cron in the same
-// transaction. @convex-dev/crons guarantees the cron "is guaranteed to
-// exist after the mutation that creates them has run" (README) -- so the
-// very next tick can fire it, with zero deploy.
-export const create = mutation({
-    args: {
-        orgId: v.string(),
-        agentId: v.id("agents"),
-        name: v.string(),
-        cronExpression: v.string(),
-        prompt: v.string(),
-    },
-    returns: v.id("habits"),
-    handler: async (ctx, args) => {
-        const orgId = requireOrgId(args.orgId);
-        const agent = await ctx.db.get(args.agentId);
-        assertSameOrg(orgId, agent, "Agent not found");
-        if (args.name.trim().length === 0) {
-            throw new Error("Validation: name must not be empty");
-        }
-        if (args.cronExpression.trim().length === 0) {
-            throw new Error("Validation: cronExpression must not be empty");
-        }
-        const now = Date.now();
-        const habitId = await ctx.db.insert("habits", {
-            orgId,
-            agentId: args.agentId,
-            name: args.name,
-            cronExpression: args.cronExpression,
-            prompt: args.prompt,
-            enabled: true,
-            createdAt: now,
-            updatedAt: now,
-        });
-        const cronJobId = await crons.register(ctx, { kind: "cron", cronspec: args.cronExpression }, internal.engine.habits.run, { habitId }, `habit:${habitId}`);
-        await ctx.db.patch(habitId, { cronJobId, updatedAt: Date.now() });
-        return habitId;
-    },
-});
-export const get = query({
-    args: { orgId: v.string(), habitId: v.id("habits") },
-    returns: v.union(habitDoc, v.null()),
-    handler: async (ctx, args) => {
-        const orgId = requireOrgId(args.orgId);
-        const doc = await ctx.db.get(args.habitId);
-        if (!doc || doc.orgId !== orgId)
-            return null;
-        return doc;
-    },
-});
-export const listForAgent = query({
-    args: { orgId: v.string(), agentId: v.id("agents") },
-    returns: v.array(habitDoc),
-    handler: async (ctx, args) => {
-        const orgId = requireOrgId(args.orgId);
-        return await ctx.db
-            .query("habits")
-            .withIndex("by_org_agent", (q) => q.eq("orgId", orgId).eq("agentId", args.agentId))
-            .collect();
-    },
-});
-// updateSchedule — edits the habit AT EXECUTION TIME. Deletes the old
-// runtime cron and registers a fresh one from the new `cronExpression`,
-// still inside a single Convex mutation transaction. No redeploy, no
-// downtime window: @convex-dev/crons crons are transactional (README).
-export const updateSchedule = mutation({
-    args: {
-        orgId: v.string(),
-        habitId: v.id("habits"),
-        cronExpression: v.optional(v.string()),
-        prompt: v.optional(v.string()),
-        name: v.optional(v.string()),
-    },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        const orgId = requireOrgId(args.orgId);
-        const existing = await ctx.db.get(args.habitId);
-        assertSameOrg(orgId, existing, "Habit not found");
-        const { orgId: _orgId, habitId, cronExpression, ...rest } = args;
-        await ctx.db.patch(habitId, { ...rest, updatedAt: Date.now() });
-        if (cronExpression !== undefined && cronExpression !== existing.cronExpression) {
-            if (cronExpression.trim().length === 0) {
-                throw new Error("Validation: cronExpression must not be empty");
-            }
-            if (existing.enabled && existing.cronJobId) {
-                await crons.delete(ctx, { id: existing.cronJobId });
-            }
-            await ctx.db.patch(habitId, { cronExpression, updatedAt: Date.now() });
-            if (existing.enabled) {
-                const cronJobId = await crons.register(ctx, { kind: "cron", cronspec: cronExpression }, internal.engine.habits.run, { habitId }, `habit:${habitId}:${Date.now()}`);
-                await ctx.db.patch(habitId, { cronJobId, updatedAt: Date.now() });
-            }
-        }
-        return null;
-    },
-});
-// disable — stops future runs by DELETING the runtime cron registration.
-// This is a hard stop, not a soft "skip if disabled" flag: after `disable`
-// resolves, there is no scheduled function left that could fire this habit.
-export const disable = mutation({
-    args: { orgId: v.string(), habitId: v.id("habits") },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        const orgId = requireOrgId(args.orgId);
-        const existing = await ctx.db.get(args.habitId);
-        assertSameOrg(orgId, existing, "Habit not found");
-        if (existing.enabled && existing.cronJobId) {
-            await crons.delete(ctx, { id: existing.cronJobId });
-        }
-        await ctx.db.patch(args.habitId, {
-            enabled: false,
-            cronJobId: undefined,
-            updatedAt: Date.now(),
-        });
-        return null;
-    },
-});
-// enable — re-registers the runtime cron from the habit's own
-// `cronExpression` DATA. No redeploy: the schedule was never lost, only its
-// runtime registration.
-export const enable = mutation({
-    args: { orgId: v.string(), habitId: v.id("habits") },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        const orgId = requireOrgId(args.orgId);
-        const existing = await ctx.db.get(args.habitId);
-        assertSameOrg(orgId, existing, "Habit not found");
-        if (existing.enabled)
-            return null;
-        const cronJobId = await crons.register(ctx, { kind: "cron", cronspec: existing.cronExpression }, internal.engine.habits.run, { habitId: args.habitId }, `habit:${args.habitId}:${Date.now()}`);
-        await ctx.db.patch(args.habitId, {
-            enabled: true,
-            cronJobId,
-            updatedAt: Date.now(),
-        });
-        return null;
-    },
-});
-// run — the cron-invoked target (internal only, never client-facing).
-// Writes a `habitRuns` proof row and bumps `lastRunAt`. This is what makes
-// "a habit fires its first run without a deploy" and "a disabled habit does
-// not fire again" PROVABLE rather than asserted on trust
-// (component/habits.componentPackaging.test.ts). No `orgId` argument: this
-// mutation is reachable ONLY by the runtime cron scheduler (never a
-// client), and it derives `orgId` from the habit row itself, which is the
-// same trust boundary `spendInternal` uses in engine/mandates.ts.
-export const run = internalMutation({
-    args: { habitId: v.id("habits") },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        const habit = await ctx.db.get(args.habitId);
-        if (!habit || !habit.enabled) {
-            // Defence in depth: `disable` already removes the cron registration,
-            // but if a run was already in flight when disable landed, refuse to
-            // record it as having run.
-            return null;
-        }
-        const now = Date.now();
-        await ctx.db.insert("habitRuns", {
-            orgId: habit.orgId,
-            habitId: args.habitId,
-            agentId: habit.agentId,
-            ranAt: now,
-        });
-        await ctx.db.patch(args.habitId, { lastRunAt: now });
-        return null;
-    },
-});
-export const listRuns = query({
-    args: { orgId: v.string(), habitId: v.id("habits") },
-    returns: v.array(v.object({
-        _id: v.id("habitRuns"),
-        _creationTime: v.number(),
-        orgId: v.string(),
-        habitId: v.id("habits"),
-        agentId: v.id("agents"),
-        ranAt: v.number(),
-    })),
-    handler: async (ctx, args) => {
-        const orgId = requireOrgId(args.orgId);
-        return await ctx.db
-            .query("habitRuns")
-            .withIndex("by_org_habit", (q) => q.eq("orgId", orgId).eq("habitId", args.habitId))
-            .collect();
-    },
-});

package/dist/component/testFixtures/callerSteps.d.ts

@@ -1,20 +0,0 @@
-export declare const getAttemptCount: import("convex/server").RegisteredQuery<"internal", {
-    jobId: import("convex/values").GenericId<"durableJobs">;
-    stepIndex: number;
-}, Promise<number>>;
-export declare const resetAttemptCounts: import("convex/server").RegisteredMutation<"internal", {}, Promise<null>>;
-export declare const alwaysSucceeds: import("convex/server").RegisteredMutation<"internal", {
-    orgId: string;
-    jobId: import("convex/values").GenericId<"durableJobs">;
-    stepIndex: number;
-}, Promise<null>>;
-export declare const alwaysFails: import("convex/server").RegisteredMutation<"internal", {
-    orgId: string;
-    jobId: import("convex/values").GenericId<"durableJobs">;
-    stepIndex: number;
-}, Promise<never>>;
-export declare const failsFirstAttemptThenSucceeds: import("convex/server").RegisteredMutation<"internal", {
-    orgId: string;
-    jobId: import("convex/values").GenericId<"durableJobs">;
-    stepIndex: number;
-}, Promise<null>>;

package/dist/component/testFixtures/callerSteps.js

@@ -1,90 +0,0 @@
-import { v } from "convex/values";
-import { internalMutation, internalQuery } from "../_generated/server.js";
-// testFixtures/callerSteps — stand-ins for a CALLER'S OWN step function
-// (the thing a real consumer, e.g. VantagePeers, would define in ITS OWN
-// app and pass to `engine/durableJob.start` as `stepFunctionHandle` via
-// `createFunctionHandle`). These exist ONLY to drive the contract tests in
-// convex/engineDurableJob.test.ts -- they are not part of the public
-// surface (see examples/vantage-peers-long-task for the real, documented
-// integration a consumer would write).
-//
-// Attempt counts are tracked IN-MEMORY (module-level Map), not via a DB
-// write, because a mutation that throws rolls back every write made in its
-// OWN transaction -- including a "record that I was called" insert made
-// just before the throw. In-memory state survives the rollback since it is
-// plain JS state, not part of the Convex transaction.
-const attemptCounts = new Map();
-function bump(jobId, stepIndex) {
-    const key = `${jobId}:${stepIndex}`;
-    const next = (attemptCounts.get(key) ?? 0) + 1;
-    attemptCounts.set(key, next);
-    return next;
-}
-export const getAttemptCount = internalQuery({
-    args: { jobId: v.id("durableJobs"), stepIndex: v.number() },
-    returns: v.number(),
-    handler: async (_ctx, args) => {
-        return attemptCounts.get(`${args.jobId}:${args.stepIndex}`) ?? 0;
-    },
-});
-// TEST-ONLY: `convexTest()` reuses deterministic, low-cardinality document
-// IDs across SEPARATE test instances within the same process, so this
-// module-level Map must be cleared between tests to avoid one test's
-// counters leaking into the next via a colliding `${jobId}:${stepIndex}`
-// key. Called from `beforeEach` in engineDurableJob.test.ts.
-export const resetAttemptCounts = internalMutation({
-    args: {},
-    returns: v.null(),
-    handler: async () => {
-        attemptCounts.clear();
-        return null;
-    },
-});
-// Records one row per SUCCESSFUL invocation so tests can assert exactly
-// which step indices actually completed (idempotent-replay assertions).
-export const alwaysSucceeds = internalMutation({
-    args: { orgId: v.string(), jobId: v.id("durableJobs"), stepIndex: v.number() },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        bump(args.jobId, args.stepIndex);
-        await ctx.db.insert("callerStepInvocations", {
-            orgId: args.orgId,
-            jobId: args.jobId,
-            stepIndex: args.stepIndex,
-            createdAt: Date.now(),
-        });
-        return null;
-    },
-});
-// Fails on every attempt -- used to prove abandonment after N failures. Attempt
-// count is observable via `getAttemptCount` even though every DB write this
-// function might otherwise make would be rolled back by the throw.
-export const alwaysFails = internalMutation({
-    args: { orgId: v.string(), jobId: v.id("durableJobs"), stepIndex: v.number() },
-    returns: v.null(),
-    handler: async (_ctx, args) => {
-        bump(args.jobId, args.stepIndex);
-        throw new Error(`simulated failure at step ${args.stepIndex}`);
-    },
-});
-// Fails on the FIRST attempt of ANY step, then succeeds on every
-// subsequent attempt of that same step -- used to prove retry-then-succeed
-// still advances the cursor (not just outright failure), exercising the
-// `maxAttemptsPerStep > 1` path distinctly from `alwaysFails`.
-export const failsFirstAttemptThenSucceeds = internalMutation({
-    args: { orgId: v.string(), jobId: v.id("durableJobs"), stepIndex: v.number() },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        const attemptNumber = bump(args.jobId, args.stepIndex);
-        if (attemptNumber === 1) {
-            throw new Error(`simulated single failure at step ${args.stepIndex}`);
-        }
-        await ctx.db.insert("callerStepInvocations", {
-            orgId: args.orgId,
-            jobId: args.jobId,
-            stepIndex: args.stepIndex,
-            createdAt: Date.now(),
-        });
-        return null;
-    },
-});

package/dist/component/testFixtures/delegationDemoWorkflow.d.ts

@@ -1,18 +0,0 @@
-import { WorkflowManager } from "@convex-dev/workflow";
-export declare const workflow: WorkflowManager;
-export declare const start: import("convex/server").RegisteredMutation<"public", {
-    orgId: string;
-    awaitedEventName: string;
-}, Promise<{
-    workflowId: string;
-}>>;
-export declare const delegationDemoWorkflowV1: import("convex/server").RegisteredMutation<"internal", import("@convex-dev/workflow").WorkflowArgs<{
-    orgId: import("convex/values").VString<string, "required">;
-    awaitedEventName: import("convex/values").VString<string, "required">;
-}>, import("@convex-dev/workflow").WorkflowId>;
-export declare const recordDelegationResolvedByEventInternal: import("convex/server").RegisteredMutation<"internal", {
-    resultSummary?: string | undefined;
-    orgId: string;
-    status: "completed" | "cancelled" | "failed";
-    awaitedEventName: string;
-}, Promise<null>>;

package/dist/component/testFixtures/delegationDemoWorkflow.js

@@ -1,75 +0,0 @@
-import { WorkflowManager } from "@convex-dev/workflow";
-import { v } from "convex/values";
-import { components, internal } from "../_generated/api.js";
-import { internalMutation, mutation } from "../_generated/server.js";
-import { requireOrgId } from "../lib/auth.js";
-// testFixtures/delegationDemoWorkflow — TEST-ONLY reference PARENT-side
-// recipient for delegation. This is exactly the "bespoke
-// workflow" shape `engine/wakeup.ts`'s own comment describes ("any
-// workflow -- a session, a durable job, or a bespoke one -- can be the wake
-// target"): it parks on `step.awaitEvent` and, once
-// `engine.wakeup.onWorkComplete` fires `sendEvent` (via
-// `engine.delegation.delegateToSubagent` -> `engine.wakeup.enqueue`, the
-// same public action this component ships), it patches the SAME `delegationRuns`
-// row `delegateToSubagent` created -- proving A paused and was woken by
-// B's completion, with zero polling.
-export const workflow = new WorkflowManager(components.workflow);
-export const start = mutation({
-    args: { orgId: v.string(), awaitedEventName: v.string() },
-    returns: v.object({ workflowId: v.string() }),
-    handler: async (ctx, args) => {
-        const orgId = requireOrgId(args.orgId);
-        const workflowId = await workflow.start(ctx, internal.testFixtures.delegationDemoWorkflow.delegationDemoWorkflowV1, { orgId, awaitedEventName: args.awaitedEventName });
-        return { workflowId };
-    },
-});
-export const delegationDemoWorkflowV1 = workflow.define({
-    args: { orgId: v.string(), awaitedEventName: v.string() },
-    returns: v.null(),
-    handler: async (step, args) => {
-        // A pauses here. Resumes ONLY when engine.wakeup.onWorkComplete calls
-        // sendEvent with this exact name -- no loop, no timer.
-        const result = await step.awaitEvent({
-            name: args.awaitedEventName,
-            validator: v.object({
-                status: v.union(v.literal("completed"), v.literal("failed"), v.literal("cancelled")),
-                resultSummary: v.optional(v.string()),
-            }),
-        });
-        await step.runMutation(internal.testFixtures.delegationDemoWorkflow.recordDelegationResolvedByEventInternal, {
-            orgId: args.orgId,
-            awaitedEventName: args.awaitedEventName,
-            status: result.status,
-            resultSummary: result.resultSummary,
-        });
-        return null;
-    },
-});
-// recordDelegationResolvedByEventInternal — looks up the delegationRuns row
-// created for THIS (orgId, awaitedEventName) pair via `by_org_awaitedEvent`
-// (no `.filter()`) and patches it. Kept as one mutation (rather than two
-// round trips from the workflow step) so the lookup and patch land in the
-// same transaction.
-export const recordDelegationResolvedByEventInternal = internalMutation({
-    args: {
-        orgId: v.string(),
-        awaitedEventName: v.string(),
-        status: v.union(v.literal("completed"), v.literal("failed"), v.literal("cancelled")),
-        resultSummary: v.optional(v.string()),
-    },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        const row = await ctx.db
-            .query("delegationRuns")
-            .withIndex("by_org_awaitedEvent", (q) => q.eq("orgId", args.orgId).eq("awaitedEventName", args.awaitedEventName))
-            .first();
-        if (!row)
-            return null;
-        await ctx.db.patch(row._id, {
-            status: args.status,
-            resultSummary: args.resultSummary,
-            updatedAt: Date.now(),
-        });
-        return null;
-    },
-});

package/dist/component/testFixtures/sandboxDemoWorkflow.d.ts

@@ -1,19 +0,0 @@
-import { WorkflowManager } from "@convex-dev/workflow";
-import type { Id } from "../_generated/dataModel.js";
-export declare const workflow: WorkflowManager;
-export declare const start: import("convex/server").RegisteredMutation<"public", {
-    orgId: string;
-    awaitedEventName: string;
-}, Promise<{
-    workflowId: string;
-    resultId: Id<"wakeupDemoResults">;
-}>>;
-export declare const recordWokenInternal: import("convex/server").RegisteredMutation<"internal", {
-    resultSummary?: string | undefined;
-    status: "completed" | "failed";
-    resultId: import("convex/values").GenericId<"wakeupDemoResults">;
-}, Promise<null>>;
-export declare const sandboxDemoWorkflowV1: import("convex/server").RegisteredMutation<"internal", import("@convex-dev/workflow").WorkflowArgs<{
-    resultId: import("convex/values").VId<import("convex/values").GenericId<"wakeupDemoResults">, "required">;
-    awaitedEventName: import("convex/values").VString<string, "required">;
-}>, import("@convex-dev/workflow").WorkflowId>;

package/dist/component/testFixtures/sandboxDemoWorkflow.js

@@ -1,69 +0,0 @@
-import { WorkflowManager } from "@convex-dev/workflow";
-import { v } from "convex/values";
-import { components, internal } from "../_generated/api.js";
-import { internalMutation, mutation } from "../_generated/server.js";
-import { requireOrgId } from "../lib/auth.js";
-// testFixtures/sandboxDemoWorkflow — TEST-ONLY reference recipient for the
-// sandbox bridge, same shape/role as testFixtures/wakeupDemoWorkflow.ts.
-// A real consumer's
-// own workflow parks on `step.awaitEvent({ name: <awaitedEventName passed
-// to engine/sandboxCallback.startRun> })` and does nothing else. Proves
-// (component/sandboxCallback.componentPackaging.test.ts) the ONLY way this
-// resumes is a signed, deduplicated callback reaching
-// `engine/sandboxCallback.processCallback` (or the self-built timeout) --
-// no poll, no interval, no direct call.
-export const workflow = new WorkflowManager(components.workflow);
-export const start = mutation({
-    args: { orgId: v.string(), awaitedEventName: v.string() },
-    returns: v.object({
-        workflowId: v.string(),
-        resultId: v.id("wakeupDemoResults"),
-    }),
-    handler: async (ctx, args) => {
-        const orgId = requireOrgId(args.orgId);
-        // Reuses wakeupDemoResults -- same test-observation shape (enqueuedAt /
-        // wokenAt / observedStatus), decoupled from the wake-up-pool path by
-        // definition since nothing here touches wakeableWork.
-        const resultId = await ctx.db.insert("wakeupDemoResults", { orgId, enqueuedAt: Date.now() });
-        const workflowId = await workflow.start(ctx, internal.testFixtures.sandboxDemoWorkflow.sandboxDemoWorkflowV1, { resultId, awaitedEventName: args.awaitedEventName });
-        return { workflowId, resultId };
-    },
-});
-export const recordWokenInternal = internalMutation({
-    args: {
-        resultId: v.id("wakeupDemoResults"),
-        status: v.union(v.literal("completed"), v.literal("failed")),
-        resultSummary: v.optional(v.string()),
-    },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        await ctx.db.patch(args.resultId, {
-            wokenAt: Date.now(),
-            observedStatus: args.status,
-            observedResultSummary: args.resultSummary,
-        });
-        return null;
-    },
-});
-export const sandboxDemoWorkflowV1 = workflow.define({
-    args: { resultId: v.id("wakeupDemoResults"), awaitedEventName: v.string() },
-    returns: v.null(),
-    handler: async (step, args) => {
-        // Blocks here -- resumes ONLY when a signed, non-duplicate sandbox
-        // callback (or the self-built timeout) calls `workflow.sendEvent` with
-        // this exact name. No loop, no timer polling this workflow's state.
-        const result = await step.awaitEvent({
-            name: args.awaitedEventName,
-            validator: v.object({
-                status: v.union(v.literal("completed"), v.literal("failed")),
-                resultSummary: v.optional(v.string()),
-            }),
-        });
-        await step.runMutation(internal.testFixtures.sandboxDemoWorkflow.recordWokenInternal, {
-            resultId: args.resultId,
-            status: result.status,
-            resultSummary: result.resultSummary,
-        });
-        return null;
-    },
-});

package/dist/component/testFixtures/vpTool.d.ts

@@ -1,4 +0,0 @@
-export declare const writeToTenant: import("convex/server").RegisteredMutation<"internal", {
-    orgId: string;
-    argsJson: string;
-}, Promise<null>>;

package/dist/component/testFixtures/vpTool.js

@@ -1,25 +0,0 @@
-import { v } from "convex/values";
-import { internalMutation } from "../_generated/server.js";
-// testFixtures/vpTool — stand-in for a VantagePeers-owned mutation reached
-// via `createFunctionHandle` (same discipline as testFixtures/wakeupWork.ts
-// and durableJob's caller-step fixtures). Ported from
-// convex/testFixtures/vpTool.ts. This engine never owns VantagePeers'
-// schema, so its own `vpTenantFixture` table plays the role of "VP's own
-// tenant table" for `component/engine/vpConnection.test.ts`). Writes
-// EXACTLY the orgId it was handed -- it does not derive one from
-// `ctx.auth` -- so the caller (`engine.vpConnection.invokeVpTool`) is what
-// determines tenant isolation, which is precisely the property under test.
-export const writeToTenant = internalMutation({
-    args: { orgId: v.string(), argsJson: v.string() },
-    returns: v.null(),
-    handler: async (ctx, args) => {
-        const parsed = JSON.parse(args.argsJson);
-        await ctx.db.insert("vpTenantFixture", {
-            orgId: args.orgId,
-            tool: parsed.tool,
-            argsJson: args.argsJson,
-            createdAt: Date.now(),
-        });
-        return null;
-    },
-});

package/dist/component/testFixtures/wakeupDemoWorkflow.d.ts

@@ -1,19 +0,0 @@
-import { WorkflowManager } from "@convex-dev/workflow";
-import type { Id } from "../_generated/dataModel.js";
-export declare const workflow: WorkflowManager;
-export declare const start: import("convex/server").RegisteredMutation<"public", {
-    orgId: string;
-    awaitedEventName: string;
-}, Promise<{
-    workflowId: string;
-    resultId: Id<"wakeupDemoResults">;
-}>>;
-export declare const recordWokenInternal: import("convex/server").RegisteredMutation<"internal", {
-    resultSummary?: string | undefined;
-    status: "completed" | "cancelled" | "failed";
-    resultId: import("convex/values").GenericId<"wakeupDemoResults">;
-}, Promise<null>>;
-export declare const wakeupDemoWorkflowV1: import("convex/server").RegisteredMutation<"internal", import("@convex-dev/workflow").WorkflowArgs<{
-    resultId: import("convex/values").VId<import("convex/values").GenericId<"wakeupDemoResults">, "required">;
-    awaitedEventName: import("convex/values").VString<string, "required">;
-}>, import("@convex-dev/workflow").WorkflowId>;