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

package/dist/component/_generated/dataModel.js

@@ -1,10 +1 @@
-/* eslint-disable */
-/**
- * Generated data model types.
- *
- * THIS CODE IS AUTOMATICALLY GENERATED.
- *
- * To regenerate, run `npx convex dev`.
- * @module
- */
 export {};

package/dist/component/_generated/server.js

@@ -1,77 +1,8 @@
-/* eslint-disable */
-/**
- * Generated utilities for implementing server-side Convex query and mutation functions.
- *
- * THIS CODE IS AUTOMATICALLY GENERATED.
- *
- * To regenerate, run `npx convex dev`.
- * @module
- */
 import { actionGeneric, httpActionGeneric, queryGeneric, mutationGeneric, internalActionGeneric, internalMutationGeneric, internalQueryGeneric, } from "convex/server";
-/**
- * Define a query in this Convex app's public API.
- *
- * This function will be allowed to read your Convex database and will be accessible from the client.
- *
- * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
- * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
- */
 export const query = queryGeneric;
-/**
- * Define a query that is only accessible from other Convex functions (but not from the client).
- *
- * This function will be allowed to read from your Convex database. It will not be accessible from the client.
- *
- * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
- * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
- */
 export const internalQuery = internalQueryGeneric;
-/**
- * Define a mutation in this Convex app's public API.
- *
- * This function will be allowed to modify your Convex database and will be accessible from the client.
- *
- * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
- * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
- */
 export const mutation = mutationGeneric;
-/**
- * Define a mutation that is only accessible from other Convex functions (but not from the client).
- *
- * This function will be allowed to modify your Convex database. It will not be accessible from the client.
- *
- * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
- * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
- */
 export const internalMutation = internalMutationGeneric;
-/**
- * Define an action in this Convex app's public API.
- *
- * An action is a function which can execute any JavaScript code, including non-deterministic
- * code and code with side-effects, like calling third-party services.
- * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
- * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
- *
- * @param func - The action. It receives an {@link ActionCtx} as its first argument.
- * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
- */
 export const action = actionGeneric;
-/**
- * Define an action that is only accessible from other Convex functions (but not from the client).
- *
- * @param func - The function. It receives an {@link ActionCtx} as its first argument.
- * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
- */
 export const internalAction = internalActionGeneric;
-/**
- * Define an HTTP action.
- *
- * The wrapped function will be used to respond to HTTP requests received
- * by a Convex deployment if the requests matches the path and method where
- * this action is routed. Be sure to route your httpAction in `convex/http.js`.
- *
- * @param func - The function. It receives an {@link ActionCtx} as its first argument
- * and a Fetch API `Request` object as its second.
- * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
- */
 export const httpAction = httpActionGeneric;

package/dist/component/convex.config.js

@@ -4,49 +4,6 @@ import workpool from "@convex-dev/workpool/convex.config";
 import agent from "@convex-dev/agent/convex.config";
 import rateLimiter from "@convex-dev/rate-limiter/convex.config";
 import shardedCounter from "@convex-dev/sharded-counter/convex.config";
-import crons from "@convex-dev/crons/convex.config";
-// @vantageos/agent-engine — Convex COMPONENT definition (pattern
-// `@convex-dev/*`, verified against the published shape of
-// `@convex-dev/workflow` — `defineComponent(name)` + a `convex.config.ts`
-// at the root of the *package that gets published*, not merely at the
-// root of the git repo).
-//
-// This is what a consumer registers via:
-//   import agentEngine from "@vantageos/agent-engine/convex.config";
-//   app.use(agentEngine);
-//
-// This file declares agent-engine's COMPONENT IDENTITY and its
-// sub-component composition (workflow + 2 named workpools + agent), which
-// is what makes the `@vantageos/agent-engine/convex.config` import
-// RESOLVE for a consumer and what makes `app.use(agentEngine)` build
-// without throwing.
-//
-// T2-QUATER (this pass): `convex/component/engine/durableJob.ts` +
-// `convex/component/schema.ts` (its `durableJobs` table) +
-// `convex/component/lib/auth.ts` (orgId isolation) are now CO-LOCATED in
-// this same directory tree, alongside this file — this is what a
-// consumer's `npx convex dev`/`deploy` actually bundles and deploys under
-// the component boundary, and what makes
-// `components.agentEngine.engine.durableJob.start(...)` resolve to a real
-// function instead of `undefined`. See README.md "What's callable" for
-// the exact, current boundary: durableJob is IN; the rest of the agent
-// aggregate (agents, skills, subagents, connections, habits,
-// sandboxConfig, toolApprovals, modelKeys, sessions, sessionEvents,
-// awaitEventTimeouts, wakeableWork) is deliberately NOT yet re-hosted
-// here — porting those without a working component-level test harness
-// behind each of them would violate Day 128 (never ship unverified).
-// Mandates (bounded, weighted spending authority per agent/org/scope) are
-// hosted under this component boundary, using official `@convex-dev/*`
-// libraries only -- no canary/alpha dependency for a guardrail:
-// `rate-limiter` for the fails-closed spend gate itself, `sharded-counter`
-// for the usage rollup. See component/engine/mandates.ts.
-// Habits (a dynamic, per-agent/org cron schedule editable at runtime) are
-// also hosted under this component boundary, ported byte-identical from the
-// repo-root prototype (convex/habits.ts). `crons` is a sub-component of
-// THIS component -- create/updateSchedule/enable/disable register or tear
-// down a runtime cron job via `@convex-dev/crons` inside the SAME Convex
-// mutation transaction that writes the `habits` row, so no habit schedule
-// change ever requires a redeploy. See component/engine/habits.ts.
 const component = defineComponent("agentEngine");
 component.use(workflow);
 component.use(workpool, { name: "agentTurnPool" });
@@ -54,5 +11,4 @@ component.use(workpool, { name: "wakeupPool" });
 component.use(agent);
 component.use(rateLimiter);
 component.use(shardedCounter);
-component.use(crons);
 export default component;

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

@@ -23,10 +23,10 @@ export declare const get: import("convex/server").RegisteredQuery<"public", {
     maxInputTokensPerSession?: number | false | undefined;
     name: string;
     orgId: string;
-    status: "draft" | "live" | "archived";
-    createdAt: number;
-    updatedAt: number;
     instructions: string;
     model: string;
+    status: "draft" | "live" | "archived";
     createdBy: string;
+    createdAt: number;
+    updatedAt: number;
 } | null>>;

package/dist/component/engine/agents.js

@@ -1,13 +1,6 @@
 import { v } from "convex/values";
 import { mutation, query } from "../_generated/server.js";
 import { requireOrgId } from "../lib/auth.js";
-// engine/agents — MINIMAL root-sheet bootstrap for the sessions surface
-// (T2-QUINQUIES). `sessions.start` needs an `agentId` it can read INSIDE
-// the component boundary (component isolation: it cannot reach into a
-// consumer app's own `agents` table). This is deliberately narrow: only
-// `create`/`get`, no `update`/`list`/skills/connections — the full agent
-// aggregate CRUD stays out of this component boundary for this pass (see
-// component/schema.ts SCOPE note).
 const reasoningEffort = v.union(v.literal("none"), v.literal("low"), v.literal("medium"), v.literal("high"));
 const modelProvider = v.union(v.literal("gateway"), v.literal("openrouter"));
 const maxInputTokensPerSession = v.union(v.number(), v.literal(false));

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

@@ -1,6 +1,6 @@
 export declare const schedule: import("convex/server").RegisteredMutation<"public", {
     orgId: string;
-    sessionId: import("convex/values").GenericId<"sessions">;
+    sessionId: string;
     awaitedEventName: string;
     timeoutMs: number;
 }, Promise<import("convex/values").GenericId<"awaitEventTimeouts">>>;

package/dist/component/engine/awaitEventTimeout.js

@@ -2,41 +2,25 @@ import { v } from "convex/values";
 import { internal } from "../_generated/api.js";
 import { internalMutation, mutation } from "../_generated/server.js";
 import { assertSameOrg, requireOrgId } from "../lib/auth.js";
-// engine/awaitEventTimeout — self-built timeout for step.awaitEvent
-// (workflow#177: "Convex does not provide a native timeout for
-// awaitEvent"). We schedule a mutation that
-// fires a "blank" `sandbox.timeout` sessionEvent at the deadline; the
-// workflow's `awaitEvent` call is written to also accept this event name so
-// it wakes up even if the awaited event never arrives. Pattern:
-// maintainer's posted code in workflow#177, adapted to our sessionEvents
-// table.
-//
-// NOTE ("intentional divergence from Eve"): orgId is an EXPLICIT ARGUMENT on
-// every public function, never derived from `ctx.auth` -- auth does NOT
-// propagate across a component boundary (component/lib/auth.ts). Also:
-// `sessionEvents.name`'s union in component/schema.ts did not previously
-// include `sandbox.timeout` -- it has been added there (and mirrored in
-// `engine/sessions.listEvents`'s return validator) as part of this
-// migration, otherwise `fire`'s insert below would not compile under the
-// strict build.
+import { insertEvent, loadSessionRun } from "./sessions.js";
+import { findRunIdByCorrelation, legacyCorrelationId, loadRun, } from "./world.js";
 export const schedule = mutation({
     args: {
         orgId: v.string(),
-        sessionId: v.id("sessions"),
+        sessionId: v.string(),
         awaitedEventName: v.string(),
         timeoutMs: v.number(),
     },
     returns: v.id("awaitEventTimeouts"),
     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);
         if (args.timeoutMs <= 0) {
             throw new Error("Validation: timeoutMs must be > 0");
         }
         const timeoutRowId = await ctx.db.insert("awaitEventTimeouts", {
             orgId,
-            sessionId: args.sessionId,
+            runId: run.runId,
             awaitedEventName: args.awaitedEventName,
             deadlineAt: Date.now() + args.timeoutMs,
         });
@@ -59,22 +43,28 @@ export const cancel = mutation({
         return null;
     },
 });
-// internal — invoked only by the scheduler, never by a client.
 export const fire = internalMutation({
     args: { timeoutRowId: v.id("awaitEventTimeouts") },
     returns: v.null(),
     handler: async (ctx, args) => {
         const row = await ctx.db.get(args.timeoutRowId);
         if (!row || row.firedAt || row.cancelledAt) {
-            return null; // already resolved by the real event or by a prior fire
+            return null;
         }
         await ctx.db.patch(args.timeoutRowId, { firedAt: Date.now() });
-        await ctx.db.insert("sessionEvents", {
+        let runId = row.runId;
+        if (runId === undefined && row.sessionId !== undefined) {
+            runId =
+                (await findRunIdByCorrelation(ctx, row.orgId, legacyCorrelationId("session", row.sessionId))) ?? undefined;
+        }
+        if (runId === undefined)
+            return null;
+        const run = await loadRun(ctx, row.orgId, runId, "session", "Session not found");
+        await insertEvent(ctx, {
             orgId: row.orgId,
-            sessionId: row.sessionId,
+            run,
             name: "sandbox.timeout",
             payload: JSON.stringify({ awaitedEventName: row.awaitedEventName }),
-            createdAt: Date.now(),
         });
         return null;
     },

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

@@ -0,0 +1,74 @@
+import type { Id } from "../_generated/dataModel.js";
+export declare const create: import("convex/server").RegisteredMutation<"public", {
+    secretPlaintext?: string | undefined;
+    encryptionKeyBase64?: string | undefined;
+    name: string;
+    orgId: string;
+    type: "mcp" | "openapi";
+    agentId: import("convex/values").GenericId<"agents">;
+    serverConfig: string;
+    authMode: "none" | "app-token" | "user-oauth" | "header";
+}, Promise<Id<"connections">>>;
+export declare const get: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    connectionId: import("convex/values").GenericId<"connections">;
+}, Promise<{
+    _id: Id<"connections">;
+    _creationTime: number;
+    orgId: string;
+    agentId: Id<"agents">;
+    type: "mcp" | "openapi";
+    name: string;
+    serverConfig: string;
+    authMode: "none" | "app-token" | "user-oauth" | "header";
+    principalType: "app" | "user";
+    status: "active" | "pending_authorization" | "error";
+    hasSecret: boolean;
+    createdAt: number;
+    updatedAt: number;
+}>>;
+export declare const listByAgent: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    agentId: import("convex/values").GenericId<"agents">;
+}, Promise<{
+    _id: Id<"connections">;
+    _creationTime: number;
+    orgId: string;
+    agentId: Id<"agents">;
+    type: "mcp" | "openapi";
+    name: string;
+    serverConfig: string;
+    authMode: "none" | "app-token" | "user-oauth" | "header";
+    principalType: "app" | "user";
+    status: "active" | "pending_authorization" | "error";
+    hasSecret: boolean;
+    createdAt: number;
+    updatedAt: number;
+}[]>>;
+export declare const requestAuthorization: import("convex/server").RegisteredMutation<"public", {
+    orgId: string;
+    awaitedEventName: string;
+    workflowId: string;
+    connectionId: import("convex/values").GenericId<"connections">;
+    url: string;
+    userCode: string;
+}, Promise<Id<"connectionAuthorizations">>>;
+export declare const getAuthorizationStatus: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    connectionAuthorizationId: import("convex/values").GenericId<"connectionAuthorizations">;
+}, Promise<{
+    status: "pending" | "denied" | "authorized";
+    url: string;
+    userCode: string;
+    resultSummary: string | undefined;
+}>>;
+export declare const completeAuthorization: import("convex/server").RegisteredMutation<"public", {
+    resultSummary?: string | undefined;
+    secretPlaintext?: string | undefined;
+    encryptionKeyBase64?: string | undefined;
+    orgId: string;
+    outcome: "denied" | "authorized";
+    connectionAuthorizationId: import("convex/values").GenericId<"connectionAuthorizations">;
+}, Promise<{
+    outcome: "woke" | "already-resolved";
+}>>;

package/dist/component/engine/connections.js

@@ -0,0 +1,254 @@
+import { WorkflowManager } from "@convex-dev/workflow";
+import { v } from "convex/values";
+import { components } from "../_generated/api.js";
+import { mutation, query } from "../_generated/server.js";
+import { assertSameOrg, requireOrgId } from "../lib/auth.js";
+import { encryptSecret } from "../lib/connectionSecret.js";
+const workflow = new WorkflowManager(components.workflow);
+const authModeValidator = v.union(v.literal("app-token"), v.literal("user-oauth"), v.literal("none"), v.literal("header"));
+function principalTypeForAuthMode(authMode) {
+    return authMode === "user-oauth" ? "user" : "app";
+}
+const connectionTypeValidator = v.union(v.literal("mcp"), v.literal("openapi"));
+const connectionStatusValidator = v.union(v.literal("active"), v.literal("pending_authorization"), v.literal("error"));
+const connectionPublicDoc = v.object({
+    _id: v.id("connections"),
+    _creationTime: v.number(),
+    orgId: v.string(),
+    agentId: v.id("agents"),
+    type: connectionTypeValidator,
+    name: v.string(),
+    serverConfig: v.string(),
+    authMode: authModeValidator,
+    principalType: v.union(v.literal("app"), v.literal("user")),
+    status: connectionStatusValidator,
+    hasSecret: v.boolean(),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+});
+function toPublicDoc(row) {
+    return {
+        _id: row._id,
+        _creationTime: row._creationTime,
+        orgId: row.orgId,
+        agentId: row.agentId,
+        type: row.type,
+        name: row.name,
+        serverConfig: row.serverConfig,
+        authMode: row.authMode,
+        principalType: principalTypeForAuthMode(row.authMode),
+        status: row.status,
+        hasSecret: row.encryptedSecretCiphertext !== undefined,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+export const create = mutation({
+    args: {
+        orgId: v.string(),
+        agentId: v.id("agents"),
+        type: connectionTypeValidator,
+        name: v.string(),
+        serverConfig: v.string(),
+        authMode: authModeValidator,
+        secretPlaintext: v.optional(v.string()),
+        encryptionKeyBase64: v.optional(v.string()),
+    },
+    returns: v.id("connections"),
+    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");
+        }
+        let encryptedSecretCiphertext;
+        let encryptedSecretIv;
+        if (args.authMode === "app-token" || args.authMode === "header") {
+            if (!args.secretPlaintext) {
+                throw new Error(`MUST_REFUSE: connection authMode "${args.authMode}" requires secretPlaintext, none was supplied`);
+            }
+            if (!args.encryptionKeyBase64) {
+                throw new Error(`MUST_REFUSE: connection authMode "${args.authMode}" requires encryptionKeyBase64, none was supplied`);
+            }
+            const encrypted = await encryptSecret(args.secretPlaintext, args.encryptionKeyBase64);
+            encryptedSecretCiphertext = encrypted.ciphertextBase64;
+            encryptedSecretIv = encrypted.ivBase64;
+        }
+        else if (args.authMode === "none") {
+            if (args.secretPlaintext) {
+                throw new Error('MUST_REFUSE: connection authMode "none" must not carry a secretPlaintext');
+            }
+        }
+        const now = Date.now();
+        return await ctx.db.insert("connections", {
+            orgId,
+            agentId: args.agentId,
+            type: args.type,
+            name: args.name,
+            serverConfig: args.serverConfig,
+            authMode: args.authMode,
+            encryptedSecretCiphertext,
+            encryptedSecretIv,
+            status: "active",
+            createdAt: now,
+            updatedAt: now,
+        });
+    },
+});
+export const get = query({
+    args: { orgId: v.string(), connectionId: v.id("connections") },
+    returns: connectionPublicDoc,
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const row = await ctx.db.get(args.connectionId);
+        assertSameOrg(orgId, row, "Connection not found");
+        return toPublicDoc(row);
+    },
+});
+export const listByAgent = query({
+    args: { orgId: v.string(), agentId: v.id("agents") },
+    returns: v.array(connectionPublicDoc),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const agent = await ctx.db.get(args.agentId);
+        assertSameOrg(orgId, agent, "Agent not found");
+        const rows = await ctx.db
+            .query("connections")
+            .withIndex("by_org_agent", (q) => q.eq("orgId", orgId).eq("agentId", args.agentId))
+            .collect();
+        return rows.map((row) => toPublicDoc(row));
+    },
+});
+export const requestAuthorization = mutation({
+    args: {
+        orgId: v.string(),
+        connectionId: v.id("connections"),
+        workflowId: v.string(),
+        awaitedEventName: v.string(),
+        url: v.string(),
+        userCode: v.string(),
+    },
+    returns: v.id("connectionAuthorizations"),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const connection = await ctx.db.get(args.connectionId);
+        assertSameOrg(orgId, connection, "Connection not found");
+        if (connection.authMode !== "user-oauth") {
+            throw new Error(`MUST_REFUSE: requestAuthorization requires authMode "user-oauth", connection has "${connection.authMode}"`);
+        }
+        if (args.workflowId.length === 0) {
+            throw new Error("MUST_REFUSE: workflowId must not be empty");
+        }
+        if (args.awaitedEventName.length === 0) {
+            throw new Error("MUST_REFUSE: awaitedEventName must not be empty");
+        }
+        if (args.url.trim().length === 0) {
+            throw new Error("MUST_REFUSE: authorization.required challenge requires a non-empty url, none was supplied");
+        }
+        if (args.userCode.trim().length === 0) {
+            throw new Error("MUST_REFUSE: authorization.required challenge requires a non-empty userCode, none was supplied");
+        }
+        const now = Date.now();
+        const authorizationId = await ctx.db.insert("connectionAuthorizations", {
+            orgId,
+            connectionId: args.connectionId,
+            workflowId: args.workflowId,
+            awaitedEventName: args.awaitedEventName,
+            url: args.url,
+            userCode: args.userCode,
+            status: "pending",
+            createdAt: now,
+            updatedAt: now,
+        });
+        await ctx.db.patch(args.connectionId, {
+            status: "pending_authorization",
+            updatedAt: now,
+        });
+        return authorizationId;
+    },
+});
+export const getAuthorizationStatus = query({
+    args: { orgId: v.string(), connectionAuthorizationId: v.id("connectionAuthorizations") },
+    returns: v.object({
+        status: v.union(v.literal("pending"), v.literal("authorized"), v.literal("denied")),
+        url: v.string(),
+        userCode: v.string(),
+        resultSummary: v.optional(v.string()),
+    }),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const row = await ctx.db.get(args.connectionAuthorizationId);
+        assertSameOrg(orgId, row, "Connection authorization not found");
+        return {
+            status: row.status,
+            url: row.url,
+            userCode: row.userCode,
+            resultSummary: row.resultSummary,
+        };
+    },
+});
+export const completeAuthorization = mutation({
+    args: {
+        orgId: v.string(),
+        connectionAuthorizationId: v.id("connectionAuthorizations"),
+        outcome: v.union(v.literal("authorized"), v.literal("denied")),
+        secretPlaintext: v.optional(v.string()),
+        encryptionKeyBase64: v.optional(v.string()),
+        resultSummary: v.optional(v.string()),
+    },
+    returns: v.object({
+        outcome: v.union(v.literal("woke"), v.literal("already-resolved")),
+    }),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const authorization = await ctx.db.get(args.connectionAuthorizationId);
+        assertSameOrg(orgId, authorization, "Connection authorization not found");
+        if (authorization.status !== "pending") {
+            return { outcome: "already-resolved" };
+        }
+        const connection = await ctx.db.get(authorization.connectionId);
+        assertSameOrg(orgId, connection, "Connection not found");
+        let encryptedSecretCiphertext = connection.encryptedSecretCiphertext;
+        let encryptedSecretIv = connection.encryptedSecretIv;
+        let connectionStatus = "error";
+        if (args.outcome === "authorized") {
+            if (!args.secretPlaintext) {
+                throw new Error('MUST_REFUSE: completeAuthorization outcome "authorized" requires secretPlaintext, none was supplied');
+            }
+            if (!args.encryptionKeyBase64) {
+                throw new Error('MUST_REFUSE: completeAuthorization outcome "authorized" requires encryptionKeyBase64, none was supplied');
+            }
+            const encrypted = await encryptSecret(args.secretPlaintext, args.encryptionKeyBase64);
+            encryptedSecretCiphertext = encrypted.ciphertextBase64;
+            encryptedSecretIv = encrypted.ivBase64;
+            connectionStatus = "active";
+        }
+        const now = Date.now();
+        await ctx.db.patch(authorization._id, {
+            status: args.outcome,
+            resultSummary: args.resultSummary,
+            updatedAt: now,
+            resolvedAt: now,
+        });
+        await ctx.db.patch(connection._id, {
+            encryptedSecretCiphertext,
+            encryptedSecretIv,
+            status: connectionStatus,
+            updatedAt: now,
+        });
+        await workflow.sendEvent(ctx, {
+            workflowId: authorization.workflowId,
+            name: authorization.awaitedEventName,
+            validator: v.object({
+                status: v.union(v.literal("completed"), v.literal("failed")),
+                resultSummary: v.optional(v.string()),
+            }),
+            value: {
+                status: args.outcome === "authorized" ? "completed" : "failed",
+                resultSummary: args.resultSummary,
+            },
+        });
+        return { outcome: "woke" };
+    },
+});

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

@@ -17,17 +17,17 @@ export declare const listSubagents: import("convex/server").RegisteredQuery<"pub
     orgId: string;
     createdAt: number;
     toolName: string;
-    enabled: boolean;
     parentAgentId: import("convex/values").GenericId<"agents">;
     childAgentId: import("convex/values").GenericId<"agents">;
+    enabled: boolean;
 }[]>>;
 export declare const delegateToSubagent: import("convex/server").RegisteredAction<"public", {
     payload?: string | undefined;
     orgId: string;
-    workflowId: string;
     awaitedEventName: string;
     scope: string;
     reason: string;
+    workflowId: string;
     cost: number;
     subagentId: import("convex/values").GenericId<"subagents">;
     workFunctionHandle: string;
@@ -35,11 +35,11 @@ export declare const delegateToSubagent: import("convex/server").RegisteredActio
 export declare const invokeAgentClone: import("convex/server").RegisteredAction<"public", {
     payload?: string | undefined;
     orgId: string;
-    workflowId: string;
     agentId: import("convex/values").GenericId<"agents">;
     awaitedEventName: string;
     scope: string;
     reason: string;
+    workflowId: string;
     cost: number;
     workFunctionHandle: string;
     viaAgentTool: boolean;
@@ -61,15 +61,15 @@ export declare const getAgentInternal: import("convex/server").RegisteredQuery<"
 } | null>>;
 export declare const recordDelegationStartInternal: import("convex/server").RegisteredMutation<"internal", {
     orgId: string;
-    workflowId: string;
     toolName: string;
     awaitedEventName: string;
+    workflowId: string;
     parentAgentId: import("convex/values").GenericId<"agents">;
     childAgentId: import("convex/values").GenericId<"agents">;
 }, Promise<import("convex/values").GenericId<"delegationRuns">>>;
 export declare const recordCloneStartInternal: import("convex/server").RegisteredMutation<"internal", {
     orgId: string;
-    workflowId: string;
     agentId: import("convex/values").GenericId<"agents">;
     awaitedEventName: string;
+    workflowId: string;
 }, Promise<import("convex/values").GenericId<"agentCloneRuns">>>;