@vantageos/agent-engine 0.1.0-alpha.1 → 0.1.0-alpha.3

package/README.md

@@ -39,7 +39,8 @@ ligne"** below, in this table and in the code comments next to the field.
 | MCP/OpenAPI connections (`defineMcpClientConnection`) | `public/definitions/connections/mcp.ts:23-48` | `connections` child table | direct parity. Our VantagePeers tools (memory, tasks, messages, notes) are wired here as an MCP connection, on by default — **notre ligne**, mvp §2.2 |
 | Declared subagents, root-only `agent` tool | https://eve.dev/docs/subagents | `subagents` child table (`parentAgentId` -> `childAgentId`, recursive) | direct parity. **Isolation strict, "inherits nothing from the root's authored slots"** — a subagent row only declares the link + exposed tool name; it never inlines the parent's skills/connections/approvals |
 | `sandbox` | `agent-definition.ts:150-160` | `sandboxConfig` child table (Vercel Sandbox, egress policy, allowlist) | direct parity, I0 §8 |
-| `schedules` / hooks -> "habits" | `manifest.ts:143`, `:726` | `habits` child table (dynamic cron per agent/org, `@convex-dev/crons`) | **notre ligne (naming)** — Eve calls these schedules/hooks; we call them habits (product decision) and back them with runtime-registered crons instead of static config |
+| `schedules` / hooks -> "habits" | `manifest.ts:143`, `:726` | `habits` + `habitRuns` child tables (dynamic cron per agent/org, `@convex-dev/crons`, see "Mandates & habits (T4)" below) | **notre ligne (naming + mechanism)** — Eve calls these schedules/hooks; we call them habits (product decision) and back them with runtime-registered crons instead of static config |
+| *(no equivalent)* — bounded per-agent authority | not present in `vercel/eve` | `mandates` + `approvalRequests` child tables (`@convex-dev/rate-limiter` + `@convex-dev/sharded-counter`, see "Mandates & habits (T4)" below) | **notre ligne** — SYNTHESE §2 "la réponse à la peur de lâcher les commandes"; a weighted, data-driven spending cap per org+agent+scope, overrun => human approval request, never a silent workaround |
 | Session/turn resolver boundaries (`ALLOWED_DYNAMIC_INSTRUCTION_EVENTS = {session.started, turn.started}`) | `dynamic-tool-definition.ts:40-46` | `sessionEvents.name` union (`session.started`, `turn.started`, ...) + `engine/resolvers.ts:resolveManifest` | direct parity — same event names, same "reread the aggregate, never cache" contract |
 | `subagents` used for inter-agent collaboration | eve docs | **not used** — collaboration goes through VantagePeers MCP tools instead | **notre ligne** — explicit Laurent decision (mvp-evevantage.md §2.5): "la collaboration entre agents n'arrive pas par les `subagents` d'eve" |
 | `outputSchema`, `compaction`, `modelOptions`, `channels` | `agent-definition.ts:124-146,313-330`, `manifest.ts:56-77` | out of scope this lot | left for a later I-cycle, documented as deliberately deferred (mvp §2.5) |
@@ -53,10 +54,11 @@ Child tables (>= 7, every index starts with `orgId`):
 1. `skills` — contextual procedures
 2. `subagents` — recursive declared delegation, strict isolation
 3. `connections` — MCP/OpenAPI (VantagePeers tools included)
-4. `habits` — dynamic crons (habits, notre ligne naming)
+4. `habits` (+ `habitRuns`) — dynamic crons (habits, notre ligne, T4)
 5. `sandboxConfig` — Vercel Sandbox settings
 6. `toolApprovals` — `always` / `once` / `never` per tool
 7. `modelKeys` — BYOK, server-only, split from `agents`
+8. `mandates` (+ `approvalRequests`) — bounded authority (notre ligne, T4)
 
 Engine tables: `sessions`, `sessionEvents`, `awaitEventTimeouts`.
 
@@ -126,6 +128,72 @@ reads without needing to know our internals):
   job is marked `abandoned` with `abandonedAtStep` + `lastError`, and no
   further step runs.
 
+## Mandates & habits (T4) — NOTRE LIGNE, EveVantage's two product differentiators
+
+SYNTHESE.md §2: *"Deux arguments de vente que personne n'a"* — mandates
+("cet agent peut engager jusqu'à X ; au-delà, il me demande") and habits
+("tous les matins, relève les mails, classe, fais le point"). Both are
+**declared divergences from `vercel/eve`** — Eve has no concept of a
+weighted spending cap or a runtime-editable recurrence; this is our line,
+not a silent gap.
+
+### Mandates — `convex/mandates.ts` (`mandates`, `approvalRequests` tables)
+
+**Notre ligne**: bounded authority per agent+org+scope. A mandate is a
+DATA ROW (`mandates.{kind,rate,period,capacity}`), never a constant in
+code — a client changing their mind is a `mandates.set` mutation, zero
+deploy. `spend(agentId, scope, cost, reason)` is the single choke point
+every costed action must pass through:
+
+- **fails-closed**: no mandate row for `orgId+agentId+scope` => throws
+  immediately (`Mandate refused: no mandate configured for scope "..."`).
+  There is no "unlimited by default" path.
+- **overrun => human approval, never a silent workaround**: when
+  `@convex-dev/rate-limiter`'s `limit()` (called with an **inline dynamic
+  `config`** built from the DB row — see rate-limiter README "Define a
+  rate limit inline / dynamically") returns `ok: false`, `spend` inserts
+  an `approvalRequests` row (`status: "pending"`) and returns
+  `{ ok: false, approvalId }`. It deliberately does **not** throw on this
+  path: Convex mutations are single transactions, and throwing after
+  `ctx.db.insert` would roll the insert back along with everything else —
+  destroying the very approval record the guard exists to leave behind.
+  Callers (the session/workflow engine) are REQUIRED to check `.ok` and
+  treat `false` as a hard refusal; the only way authority is restored is
+  an explicit human `resolveApproval(approvalId, "approved", resolvedBy)`.
+- **rollups via `@convex-dev/sharded-counter`** (`usageCount` query), one
+  bucket per `orgId:agentId:scope` key — I0 §7.4: no canary/alpha
+  dependency for a guardrail. `@convex-dev/aggregate` (also I0-approved,
+  also official, also no canary) is the natural next step for time-
+  windowed billing rollups; not wired in this lot, called out here rather
+  than silently left out.
+- `count` passed to `rateLimiter.limit` is a WEIGHTED cost (tokens, euros,
+  calls — whatever the scope means), never a bare call counter.
+
+### Habits — `convex/habits.ts` (`habits`, `habitRuns` tables)
+
+**Notre ligne (naming + mechanism)**: Eve's closest concept is
+`schedules`/`hooks`, statically declared in a compiled agent. Habits are
+runtime DATA: `habits.cronExpression` is a column, and the actual
+recurrence is a **dynamically registered `@convex-dev/crons` job**
+(`Crons.register`/`.delete`, never a static `convex/crons.ts` entry).
+
+- `create` writes the habit row and registers its cron in the SAME
+  mutation 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.
+- `updateSchedule` edits `cronExpression`/`prompt`/`name` at runtime:
+  deletes the old cron registration, registers a fresh one from the new
+  cadence, still inside one transaction.
+- `disable` is a HARD stop: it deletes the runtime cron registration
+  (not a soft `enabled` flag the target function checks) — after it
+  resolves there is no scheduled function left that could fire the habit.
+  `run` (the cron-invoked internal mutation) also re-checks `enabled` as
+  defence in depth for any run already in flight.
+- `enable` re-registers from the habit's own `cronExpression` data.
+- Every tick writes a `habitRuns` proof row — this is what makes "fires
+  its first run without a deploy" and "a disabled habit does not fire
+  again" PROVABLE in `habits.test.ts` rather than asserted on trust.
+
 ## `convex/_generated/` freshness -- two gates, not one
 
 `convex/_generated/api.d.ts` carries an "AUTOMATICALLY GENERATED" header
@@ -215,16 +283,32 @@ that all contributors run) is Pi's to make, not this PR's.
   interruption); a step that always fails is retried and the job is
   `abandoned` (never touching the next step); a step that fails once then
   succeeds still reaches `completed`; cross-org `getStatus` is denied.
+- `convex/mandates.test.ts` — mandates, three-pole probe: MUST_PASS (spend
+  under cap succeeds, rollup counts it), MUST_BLOCK (spend at cap is
+  refused, `approvalRequests` row created), MUST_REFUSE (no mandate
+  configured => fails-closed, names the missing scope, no approval row
+  created) + org isolation + human `resolveApproval`.
+- `convex/habits.test.ts` — habits, three-pole probe: MUST_PASS (a habit
+  created at runtime fires its first run with zero deploy), MUST_BLOCK (a
+  disabled habit does not fire again after further clock advances),
+  MUST_REFUSE (`enable` on an already-enabled habit is a documented
+  no-op, not a silent double-registration) + full runtime lifecycle
+  (create / updateSchedule / disable / enable, no redeploy at any step).
+- `component/durableJob.componentPackaging.test.ts` — the SAME contract
+  (long job survives, abandon-after-N, org isolation, cancel), but run
+  against `component/_generated/api` — the exact source tree compiled to
+  `dist/component/` and published — proving the migrated, packaged code
+  itself, not only the repo-root dev app.
 
 Run: `npx vitest run` (or `npm test`).
 
-## Packaging & publication (T2-TER)
+## Packaging & publication (T2-TER, functions since T2-QUATER)
 
 `@vantageos/agent-engine` is published to npm under the `alpha` dist-tag
 (`npm view @vantageos/agent-engine version` / `dist-tags`, read from the
 registry after publish, never from `npm publish`'s own exit status). The
 package exposes a resolvable `"./convex.config"` subpath (types + JS,
-built by `npm run build` from `convex/component/convex.config.ts` via
+built by `npm run build` from `component/convex.config.ts` via
 `tsc -p tsconfig.build.json` into `dist/component/`), so a consumer's
 `convex/convex.config.ts` can do:
 
@@ -237,21 +321,118 @@ app.use(agentEngine);
 export default app;
 ```
 
-**Known remaining gap, stated here where it is read (not only in a
-message):** `convex/component/convex.config.ts` currently declares only
-the component's identity (`defineComponent("agentEngine")`) and its
-sub-component composition (workflow + 2 workpools + agent). It does not
-yet re-host this repo's schema/functions (`convex/schema.ts`,
-`convex/agents.ts`, `convex/skills.ts`, `convex/engine/**`) inside the
-component boundary, so `components.agentEngine.engine.durableJob.*` etc.
-are not yet callable from a consumer through the published component --
-see `examples/vantage-peers-long-task/README.md` "Packaging note" for the
-full detail and exactly what remains.
+### What's callable, and what isn't (read this before wiring a consumer)
+
+Since T2-QUATER, `component/` (sibling of `convex/`, NOT nested under it —
+see "Why `component/` and not `convex/component/`" below) hosts the
+**actual, compiled, published functions** for a real slice of the engine,
+not just the component's identity. T2-QUINQUIES widens this to the
+SESSIONS surface — EveVantage V4's conversation thread.
+
+- `component/schema.ts` — `durableJobs`, `agents`, `toolApprovals`,
+  `sessions`, `sessionEvents` (+ a test-only `callerStepInvocations`
+  fixture table).
+- `component/engine/durableJob.ts` — `start` / `getStatus` / `cancel`.
+- `component/engine/agents.ts` — `create` / `get` (minimal root-sheet
+  bootstrap; no `update`/`list`/skills/connections in this pass).
+- `component/engine/resolvers.ts` — `resolveManifest` (dynamic reread at
+  session/turn boundaries; returns `agentId`/`name`/`instructions`/`model`/
+  `toolApprovals` — `skills`/`connections` NOT included in this pass).
+- `component/engine/sessions.ts` — the conversation thread contract.
+- `component/engine/toolApprovals.ts` — `respond`.
+- `component/lib/auth.ts` — `requireOrgId` / `assertSameOrg`: orgId is
+  derived server-side and is the first field of every index; deny by
+  default travels WITH the component, not just with this repo's own app.
+
+**Callable through the published component today** (function signatures —
+all args/returns are explicit Convex validators, see the source files
+above for the exact `v.*` shapes):
+
+```
+components.agentEngine.engine.durableJob.start({ kind, stepFunctionHandle, totalSteps, maxAttemptsPerStep }) -> Id<"durableJobs">
+components.agentEngine.engine.durableJob.getStatus({ jobId }) -> { status, cursor, totalSteps, lastError?, abandonedAtStep? }
+components.agentEngine.engine.durableJob.cancel({ jobId }) -> null
+
+components.agentEngine.engine.agents.create({ name, instructions, model }) -> Id<"agents">
+components.agentEngine.engine.agents.get({ agentId }) -> agent | null
+
+components.agentEngine.engine.resolvers.resolveManifest({ sessionId }) -> { agentId, name, instructions, model, toolApprovals[] }
+
+components.agentEngine.engine.sessions.start({ agentId }) -> Id<"sessions">                          // session.started
+components.agentEngine.engine.sessions.sendTurn({ sessionId, input }) -> null                          // turn.started, rereads resolveManifest
+components.agentEngine.engine.sessions.appendReasoning({ sessionId, chunk }) -> null                   // streamed reasoning event
+components.agentEngine.engine.sessions.requestToolCall({ sessionId, toolName, argsJson }) -> { authorized, approvalPending }
+components.agentEngine.engine.sessions.completeToolCall({ sessionId, toolName, resultJson }) -> null
+components.agentEngine.engine.sessions.completeTurn({ sessionId }) -> null                             // turn.completed
+components.agentEngine.engine.sessions.listEvents({ sessionId }) -> sessionEvent[]                     // replay on reconnect (ordered by createdAt)
+
+components.agentEngine.engine.toolApprovals.respond({ sessionId, toolName, approval: "always"|"once"|"never" }) -> null
+```
+
+Streaming model: `sessionEvents` IS the transport. Convex query
+subscriptions on `sessions.listEvents` push every new row (reasoning
+chunk, tool-call lifecycle, approval lifecycle) to every subscriber live —
+there is no separate streaming channel to wire. A client that reconnects
+calls `listEvents` once to rebuild the whole thread, then keeps
+subscribing.
+
+Tool-approval gate (`toolApprovals.approval`, default `"never"`):
+`"never"` never pauses; `"always"` pauses (raises
+`tool.approval.requested`) on every `requestToolCall`; `"once"` pauses
+unless `tool.approval.resolved` for that tool was already recorded EARLIER
+IN THE SAME SESSION. `toolApprovals.respond` both writes the standing
+policy (upsert on `orgId`+`agentId`+`toolName`) and appends
+`tool.approval.resolved` for the calling session.
+
+Verified two ways, same discipline as T2-QUATER: (1)
+`component/durableJob.componentPackaging.test.ts` +
+`component/sessions.componentPackaging.test.ts` run `convex-test` directly
+against `component/_generated/api` (the exact source tree
+`tsc -p tsconfig.build.json` compiles into `dist/component/`, which is
+what `npm pack` ships); (2) a from-scratch consumer probe (install the
+published tarball into a bare `npx convex dev` project, register the
+component, call `sessions.start`/`sendTurn` from the consumer's own
+function, confirm unauthenticated calls throw from the package's own
+`lib/auth`) — see the T2-QUINQUIES completion report for the verbatim
+transcript.
+
+**NOT yet callable through the published component** (still only exists in
+this repo's OWN dev/test deployment under `convex/schema.ts` +
+`convex/agents.ts` + `convex/skills.ts`, used by `npx convex dev` and the
+repo-root `convex-test` suite): `skills`, `connections`, `subagents`,
+`habits`, `sandboxConfig`, `modelKeys`, `mandates`, `approvalRequests`,
+`awaitEventTimeouts`, `wakeableWork`, `engine/wakeup.ts`,
+`engine/workflows.ts` (`sessionWorkflowV1` — this pass's `sessions` is
+deliberately NOT tied to a `@convex-dev/workflow` run; see
+`component/schema.ts`'s `sessions` table comment for why). Porting each of
+those under `component/` without a working component-level `convex-test`
+harness behind it would ship unverified code — Day 128 forbids that; it is
+deliberately left for the next, separately-scoped migration.
+
+### Why `component/` and not `convex/component/`
+
+`npx convex codegen --component-dir <path>` builds a synthetic root app
+that does `import component from "<relative-import-to-path>"`. When
+`<path>` is nested INSIDE the functions directory it resolves from
+(`convex/`), that relative import comes out as a bare specifier with no
+leading `./` or `../` (e.g. `"component/convex.config.js"`), which esbuild
+correctly refuses to resolve as a relative path — not a bug in our code,
+a corner case of running `--component-dir` against a directory nested
+under the default functions directory. Moving the component's source tree
+one level up, to `component/` (a sibling of `convex/`, mirroring how
+`@convex-dev/workflow` itself keeps its component source under `src/component`,
+outside its `example/convex` app directory) makes the generated relative
+import start with `../`, which resolves — measured empirically against
+this exact repo layout, not guessed.
 
 ## Status
 
 T1 (schema + durable session engine, PR #1) merged @
 `9f3401ba63e6e663af95e9e4f5da42bc30b3550b`. I1 (long-task survival
-contract, `engine/durableJob.ts`) — not merged, Eta reviews, merge on Pi
-token. T2-TER (this PR, npm packaging + component identity + publication)
-— see "Packaging & publication" above; **not merged**.
+contract, `engine/durableJob.ts`) — not merged, Eta reviews. T4 (mandates
++ habits) — **not merged** — Eta reviews, merge on Pi token. T2-TER (npm
+packaging + component identity + publication) and T2-QUATER (this pass:
+migrated `durableJob` + its schema + `lib/auth.ts` under the actual
+component boundary, `component/`, with its own `_generated/` and its own
+green `convex-test` suite) — see "Packaging & publication" above; **not
+merged**.

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

@@ -0,0 +1,50 @@
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type * as engine_agents from "../engine/agents.js";
+import type * as engine_durableJob from "../engine/durableJob.js";
+import type * as engine_resolvers from "../engine/resolvers.js";
+import type * as engine_sessions from "../engine/sessions.js";
+import type * as engine_toolApprovals from "../engine/toolApprovals.js";
+import type * as lib_auth from "../lib/auth.js";
+import type * as testFixtures_callerSteps from "../testFixtures/callerSteps.js";
+import type { ApiFromModules, FilterApi, FunctionReference } from "convex/server";
+declare const fullApi: ApiFromModules<{
+    "engine/agents": typeof engine_agents;
+    "engine/durableJob": typeof engine_durableJob;
+    "engine/resolvers": typeof engine_resolvers;
+    "engine/sessions": typeof engine_sessions;
+    "engine/toolApprovals": typeof engine_toolApprovals;
+    "lib/auth": typeof lib_auth;
+    "testFixtures/callerSteps": typeof testFixtures_callerSteps;
+}>;
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export declare const api: FilterApi<typeof fullApi, FunctionReference<any, "public">>;
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export declare const internal: FilterApi<typeof fullApi, FunctionReference<any, "internal">>;
+export declare const components: {
+    workflow: import("@convex-dev/workflow/_generated/component.js").ComponentApi<"workflow">;
+    agentTurnPool: import("@convex-dev/workpool/_generated/component.js").ComponentApi<"agentTurnPool">;
+    wakeupPool: import("@convex-dev/workpool/_generated/component.js").ComponentApi<"wakeupPool">;
+    agent: import("@convex-dev/agent/_generated/component.js").ComponentApi<"agent">;
+};
+export {};

package/dist/component/_generated/api.js

@@ -0,0 +1,30 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import { anyApi, componentsGeneric } from "convex/server";
+const fullApi = anyApi;
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api = anyApi;
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export const internal = anyApi;
+export const components = componentsGeneric();

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

@@ -0,0 +1,124 @@
+/**
+ * Generated `ComponentApi` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { FunctionReference } from "convex/server";
+/**
+ * A utility for referencing a Convex component's exposed API.
+ *
+ * Useful when expecting a parameter like `components.myComponent`.
+ * Usage:
+ * ```ts
+ * async function myFunction(ctx: QueryCtx, component: ComponentApi) {
+ *   return ctx.runQuery(component.someFile.someQuery, { ...args });
+ * }
+ * ```
+ */
+export type ComponentApi<Name extends string | undefined = string | undefined> = {
+    engine: {
+        agents: {
+            create: FunctionReference<"mutation", "internal", {
+                instructions: string;
+                model: string;
+                name: string;
+            }, string, Name>;
+            get: FunctionReference<"query", "internal", {
+                agentId: string;
+            }, {
+                _creationTime: number;
+                _id: string;
+                createdAt: number;
+                createdBy: string;
+                instructions: string;
+                model: string;
+                name: string;
+                orgId: string;
+                status: "draft" | "live" | "archived";
+                updatedAt: number;
+            } | null, Name>;
+        };
+        durableJob: {
+            cancel: FunctionReference<"mutation", "internal", {
+                jobId: string;
+            }, null, Name>;
+            getStatus: FunctionReference<"query", "internal", {
+                jobId: string;
+            }, {
+                abandonedAtStep?: number;
+                cursor: number;
+                lastError?: string;
+                status: "running" | "completed" | "abandoned" | "cancelled";
+                totalSteps: number;
+            }, Name>;
+            start: FunctionReference<"mutation", "internal", {
+                kind: string;
+                maxAttemptsPerStep: number;
+                stepFunctionHandle: string;
+                totalSteps: number;
+            }, string, Name>;
+        };
+        resolvers: {
+            resolveManifest: FunctionReference<"query", "internal", {
+                sessionId: string;
+            }, {
+                agentId: string;
+                instructions: string;
+                model: string;
+                name: string;
+                toolApprovals: Array<{
+                    approval: "always" | "once" | "never";
+                    toolName: string;
+                }>;
+            }, Name>;
+        };
+        sessions: {
+            appendReasoning: FunctionReference<"mutation", "internal", {
+                chunk: string;
+                sessionId: string;
+            }, null, Name>;
+            completeToolCall: FunctionReference<"mutation", "internal", {
+                resultJson: string;
+                sessionId: string;
+                toolName: string;
+            }, null, Name>;
+            completeTurn: FunctionReference<"mutation", "internal", {
+                sessionId: string;
+            }, null, Name>;
+            listEvents: FunctionReference<"query", "internal", {
+                sessionId: string;
+            }, Array<{
+                _creationTime: number;
+                _id: string;
+                createdAt: number;
+                name: "session.started" | "turn.started" | "turn.reasoning" | "turn.toolCall.requested" | "turn.toolCall.completed" | "turn.completed" | "tool.approval.requested" | "tool.approval.resolved";
+                payload?: string;
+            }>, Name>;
+            requestToolCall: FunctionReference<"mutation", "internal", {
+                argsJson: string;
+                sessionId: string;
+                toolName: string;
+            }, {
+                approvalPending: boolean;
+                authorized: boolean;
+            }, Name>;
+            sendTurn: FunctionReference<"mutation", "internal", {
+                input: string;
+                sessionId: string;
+            }, null, Name>;
+            start: FunctionReference<"mutation", "internal", {
+                agentId: string;
+            }, string, Name>;
+        };
+        toolApprovals: {
+            respond: FunctionReference<"mutation", "internal", {
+                approval: "always" | "once" | "never";
+                sessionId: string;
+                toolName: string;
+            }, null, Name>;
+        };
+    };
+};

package/dist/component/_generated/component.js

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

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

@@ -0,0 +1,45 @@
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { DataModelFromSchemaDefinition, DocumentByName, TableNamesInDataModel, SystemTableNames } from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<DataModel, TableName>;
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> = GenericId<TableName>;
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;

package/dist/component/_generated/dataModel.js

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

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

@@ -0,0 +1,120 @@
+/**
+ * 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>;