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

package/dist/component/_generated/server.d.ts

@@ -1,120 +1,14 @@
-/**
- * Generated utilities for implementing server-side Convex query and mutation functions.
- *
- * THIS CODE IS AUTOMATICALLY GENERATED.
- *
- * To regenerate, run `npx convex dev`.
- * @module
- */
 import type { ActionBuilder, HttpActionBuilder, MutationBuilder, QueryBuilder, GenericActionCtx, GenericMutationCtx, GenericQueryCtx, GenericDatabaseReader, GenericDatabaseWriter } from "convex/server";
 import type { DataModel } from "./dataModel.js";
-/**
- * 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 declare const query: QueryBuilder<DataModel, "public">;
-/**
- * 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 declare const internalQuery: QueryBuilder<DataModel, "internal">;
-/**
- * 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 declare const mutation: MutationBuilder<DataModel, "public">;
-/**
- * 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 declare const internalMutation: MutationBuilder<DataModel, "internal">;
-/**
- * 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 declare const action: ActionBuilder<DataModel, "public">;
-/**
- * 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 declare const internalAction: ActionBuilder<DataModel, "internal">;
-/**
- * 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 declare const httpAction: HttpActionBuilder;
-/**
- * A set of services for use within Convex query functions.
- *
- * The query context is passed as the first argument to any Convex query
- * function run on the server.
- *
- * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
- */
 export type QueryCtx = GenericQueryCtx<DataModel>;
-/**
- * A set of services for use within Convex mutation functions.
- *
- * The mutation context is passed as the first argument to any Convex mutation
- * function run on the server.
- *
- * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
- */
 export type MutationCtx = GenericMutationCtx<DataModel>;
-/**
- * A set of services for use within Convex action functions.
- *
- * The action context is passed as the first argument to any Convex action
- * function run on the server.
- */
 export type ActionCtx = GenericActionCtx<DataModel>;
-/**
- * An interface to read from the database within Convex query functions.
- *
- * The two entry points are {@link DatabaseReader.get}, which fetches a single
- * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
- * building a query.
- */
 export type DatabaseReader = GenericDatabaseReader<DataModel>;
-/**
- * An interface to read from and write to the database within Convex mutation
- * functions.
- *
- * Convex guarantees that all writes within a single mutation are
- * executed atomically, so you never have to worry about partial writes leaving
- * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
- * for the guarantees Convex provides your functions.
- */
 export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

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.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,27 @@ 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, legacySessionOf, 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);
+        const legacy = await legacySessionOf(ctx, run, orgId);
         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,
+            sessionId: legacy?._id,
             awaitedEventName: args.awaitedEventName,
             deadlineAt: Date.now() + args.timeoutMs,
         });
@@ -59,22 +45,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("sessions", row.sessionId))) ?? undefined;
+        }
+        if (runId === undefined)
+            return null;
+        const run = await loadRun(ctx, row.orgId, runId, "sessions", "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;
+    workflowId: string;
+    awaitedEventName: 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";
+}>>;