@happyvertical/smrt-agents 0.38.21 → 0.38.23

package/AGENTS.md

@@ -130,11 +130,39 @@ The framework provides only the per-instance **identity**; a package scopes its
 
 The **`default` persona reuses the singleton identity** (a `null` key), which is what makes the singleton→multi upgrade non-destructive — see `@happyvertical/smrt-personas` (`personaInstanceKey`, `upgradeSingletonToDefaultPersona`).
 
+## Principal Execution (issue #1888)
+
+`executeAsPrincipal(options, fn)` runs agent work **AS a persona's bound user**, reusing the existing RBAC cascade with no snapshotting. It publishes `(user_id, tenant_id, permissions[])` onto the DB session (Postgres RLS then bounds every query per-`(table, action)` and per-tenant) and hands `fn` a `PrincipalRun` whose `assertToolAllowed()` / `assertOperation()` enforce the persona tool ceiling and the RLS-off catalog gate. Effective authority = **bound-user RBAC ∩ agent-class ceiling ∩ persona `allowedTools`**. Actions audit as on-behalf-of the originating user via a `PrincipalAuditSink`.
+
+## Agent Orchestration (issue #1892) — invoke-agent + principal delegation
+
+A conversational (orchestrator) agent can invoke worker agents with **principal delegation**. This is *not* a new engine — it is a standard `invoke-agent` tool plus a completion-dispatch convention on top of `executeAsPrincipal` + the DispatchBus.
+
+```typescript
+import { createInvokeAgentTool, rootDelegationEnvelope } from '@happyvertical/smrt-agents';
+
+const tool = createInvokeAgentTool({
+  db,
+  parentEnvelope: rootDelegationEnvelope({ runAsUserId, tenantId, onBehalfOfUserId }),
+  worker: async ({ run, agentClass, task }) => runWorker(run, agentClass, task),
+});
+// Offered through the chat tool loop as an `extraTools` entry, gated by the
+// persona's allowedTools like any other tool (slug: 'agents.invoke').
+```
+
+- **`DelegationEnvelope`** carries the **immutable principal** (`runAsUserId` + `tenantId` + originating `onBehalfOfUserId`) and a bounded `depth`. `deriveDelegationEnvelope()` copies the principal verbatim and asserts `depth <= MAX_DELEGATION_DEPTH` (3) — a worker cannot invoke a further worker under a broader principal (`PrincipalWideningError` / `DelegationDepthExceededError`).
+- **`createInvokeAgentTool()`** → a `PrincipalTool` whose handler derives the child envelope with the principal taken **from the live run context, never the tool args**, so the invoke-agent tool is structurally immune to principal widening.
+- **`executeDelegatedInvocation()`** runs the worker via `executeAsPrincipal` under that same principal and emits a correlated `agent.completed` dispatch; **`surfaceAgentCompletions(bus, correlationId)`** reads it back into the conversation.
+- **Transports** (pluggable): the default `inlineInvokeAgentTransport` runs the worker in-process (completion surfaces in the same turn); `createDispatchInvokeTransport(bus)` emits an `agent.invoke` signal a worker processes via `processAgentInvocations()` (async). A job-queue transport (enqueue on the `agents` queue) is a consumer-supplied `InvokeAgentTransport` — orchestration never hard-depends on `@happyvertical/smrt-jobs`, which sits *below* agents in the dependency graph.
+
 ## Key Files
 
 | File | Purpose |
 |------|---------|
 | `src/agent.ts` | Base Agent class — lifecycle, dispatch, interests, config, opt-in learning trait, multi-instance identity |
+| `src/execute-as-principal.ts` | `executeAsPrincipal` / `PrincipalRun` — run agent work as a persona's bound user (#1888) |
+| `src/delegation.ts` | `DelegationEnvelope` — immutable principal + bounded delegation depth (#1892) |
+| `src/invoke-agent.ts` | `invoke-agent` tool, worker executor, completion-dispatch convention, transports (#1892) |
 | `src/learning.ts` | `AgentLearningConfig` + `resolveAgentLearning()` declaration normalisation |
 | `src/schedule.ts` | AgentSchedule model — cron, execution tracking |
 | `src/tenant-agent.ts` | TenantAgent — junction table, hierarchical resolution |

package/dist/delegation.d.ts

@@ -0,0 +1,189 @@
+/**
+ * Delegation envelope — the immutable principal + bounded depth carried along an
+ * agent-orchestration chain (L3 of the learning-agents epic, #1892).
+ *
+ * When a conversational (orchestrator) agent invokes a worker agent, and that
+ * worker in turn invokes a further worker, the whole chain must run as **one**
+ * principal — the originating user — and can never widen it. This module is the
+ * pure value object that encodes that invariant:
+ *
+ * - **Principal immutability.** `runAsUserId`, `tenantId`, and the originating
+ *   `onBehalfOfUserId` are copied verbatim from parent to child by
+ *   {@link deriveDelegationEnvelope}; there is no parameter to change them. A
+ *   caller that *requests* a different principal (e.g. a compromised worker
+ *   passing `runAsUserId` through the invoke-agent tool) is rejected by
+ *   {@link assertPrincipalNotWidened} — the request is honoured only when it
+ *   exactly equals the parent principal.
+ * - **Bounded depth.** Every derivation increments `depth` and asserts it stays
+ *   within {@link MAX_DELEGATION_DEPTH}, so an orchestration chain (or an
+ *   accidental invoke-yourself loop) can never recurse without limit.
+ *
+ * The envelope carries no authority of its own: the actual permission bound is
+ * still the originating user's live RBAC, enforced when the worker runs via
+ * `executeAsPrincipal` (Postgres RLS, or the catalog assert on RLS-off
+ * adapters). The envelope only guarantees *which* principal that is and *how
+ * deep* the chain may go.
+ *
+ * @module
+ */
+/**
+ * Maximum delegation depth for an orchestration chain. The orchestrator's own
+ * conversation is depth `0`; the first worker it invokes is depth `1`. A worker
+ * may invoke a further worker only while the resulting child depth stays within
+ * this ceiling, so a chain is at most `MAX_DELEGATION_DEPTH` workers long.
+ */
+export declare const MAX_DELEGATION_DEPTH = 3;
+/**
+ * The immutable principal + bounded depth carried from an orchestrator to a
+ * worker (and along any further delegation). Serializable, so it can travel in a
+ * job's args or a DispatchBus payload to a worker running out of process.
+ */
+export interface DelegationEnvelope {
+    /**
+     * The user whose live permissions bound the worker's execution. Immutable
+     * along the chain — copied verbatim from parent to child.
+     */
+    runAsUserId: string;
+    /** Tenant the principal acts within. Immutable along the chain. */
+    tenantId: string | null;
+    /**
+     * The originating user the whole chain acts **on behalf of** (audited). This
+     * is the human who started the conversation; it never changes as delegation
+     * deepens, so every action along the chain audits back to the same person.
+     */
+    onBehalfOfUserId: string;
+    /**
+     * Current delegation depth. `0` for the orchestrator, `1` for its first
+     * worker, and so on — bounded by {@link MAX_DELEGATION_DEPTH}.
+     */
+    depth: number;
+    /**
+     * Correlation id linking a worker invocation to the completion dispatch it
+     * emits, so the orchestrator can surface the result back into the
+     * conversation.
+     */
+    correlationId: string;
+    /**
+     * The worker's tool ceiling (its persona's `allowedTools`), carried so a
+     * worker that itself runs a tool loop is bounded fail-closed. `undefined`
+     * normalizes to "no tools" at `executeAsPrincipal` — it never widens.
+     */
+    allowedTools?: string[];
+}
+/**
+ * The principal fields a caller may *request* when deriving a child envelope.
+ * Any field that is provided must equal the parent's, or
+ * {@link assertPrincipalNotWidened} throws — the principal can only ever be
+ * inherited, never changed.
+ */
+export interface RequestedPrincipal {
+    runAsUserId?: string;
+    tenantId?: string | null;
+    onBehalfOfUserId?: string;
+}
+/**
+ * Thrown when a delegation would exceed {@link MAX_DELEGATION_DEPTH}.
+ */
+export declare class DelegationDepthExceededError extends Error {
+    readonly depth: number;
+    readonly maxDepth: number;
+    readonly status = 400;
+    constructor(depth: number, maxDepth: number);
+}
+/**
+ * Thrown when a delegation would *widen* the principal — i.e. a caller requests
+ * a `runAsUserId` / `tenantId` / `onBehalfOfUserId` that differs from the
+ * parent's. The principal is immutable along an orchestration chain.
+ */
+export declare class PrincipalWideningError extends Error {
+    readonly field: keyof RequestedPrincipal;
+    readonly status = 403;
+    constructor(field: keyof RequestedPrincipal, expected: unknown, got: unknown);
+}
+/**
+ * Assert a delegation depth is a valid, in-bounds depth.
+ *
+ * Rejects a non-integer, negative, or non-finite depth as well as one past the
+ * ceiling. This matters for the untrusted-payload path: an envelope
+ * reconstructed from a persisted dispatch/job could carry `NaN`, a negative, or
+ * a string-coerced value, and `NaN > maxDepth` is `false` — so a bare
+ * upper-bound check would let it silently bypass the bound and make delegation
+ * effectively unbounded.
+ *
+ * @throws {@link DelegationDepthExceededError} when `depth` is not an integer in `[0, maxDepth]`.
+ */
+export declare function assertWithinDelegationDepth(depth: number, maxDepth?: number): void;
+/**
+ * Assert a *requested* principal does not widen the parent's.
+ *
+ * Each provided field must exactly equal the parent's; a mismatch throws
+ * {@link PrincipalWideningError}. Omitted fields are fine — they inherit. This
+ * is the defence-in-depth guard for the case where an envelope is reconstructed
+ * from an untrusted source (a worker's invoke-agent arguments, a job payload):
+ * the principal is only ever accepted when it matches, so it can never expand.
+ */
+export declare function assertPrincipalNotWidened(parent: Pick<DelegationEnvelope, 'runAsUserId' | 'tenantId' | 'onBehalfOfUserId'>, requested: RequestedPrincipal): void;
+/**
+ * Options for {@link rootDelegationEnvelope}.
+ */
+export interface RootDelegationEnvelopeOptions {
+    /** The principal the orchestrator (and thus the whole chain) runs as. */
+    runAsUserId: string;
+    /** Tenant the principal acts within. */
+    tenantId: string | null;
+    /**
+     * The originating user the chain acts on behalf of. Defaults to
+     * `runAsUserId` when the orchestrator is itself operating directly.
+     */
+    onBehalfOfUserId?: string;
+    /** Correlation id. A fresh UUID is generated when omitted. */
+    correlationId?: string;
+    /**
+     * The orchestrator's own tool ceiling. Carried for completeness; workers do
+     * **not** inherit it — a worker's ceiling comes from trusted per-worker policy
+     * (`resolveWorkerAllowedTools`) and is fail-closed (no tools) when absent.
+     */
+    allowedTools?: string[];
+}
+/**
+ * Build the depth-`0` (orchestrator) envelope that seeds an orchestration chain.
+ *
+ * The orchestrator's conversation is depth `0`; {@link deriveDelegationEnvelope}
+ * produces the depth-`1` envelope for the first worker it invokes.
+ */
+export declare function rootDelegationEnvelope(options: RootDelegationEnvelopeOptions): DelegationEnvelope;
+/**
+ * Options for {@link deriveDelegationEnvelope}.
+ */
+export interface DeriveDelegationEnvelopeOptions {
+    /** Correlation id for the child invocation. A fresh UUID when omitted. */
+    correlationId?: string;
+    /**
+     * The invoked worker's tool ceiling. When omitted the child carries no tools
+     * (fail-closed); it is **not** inherited from the parent so a worker never
+     * silently gains the orchestrator's tools.
+     */
+    allowedTools?: string[];
+    /**
+     * A principal a caller is *requesting* the child run as. Accepted only when it
+     * matches the parent principal exactly (see {@link assertPrincipalNotWidened});
+     * otherwise {@link PrincipalWideningError} is thrown. Omit to inherit.
+     */
+    requestedPrincipal?: RequestedPrincipal;
+    /** Depth ceiling override (mainly for tests). */
+    maxDepth?: number;
+}
+/**
+ * Derive the child envelope for a worker invoked by the holder of `parent`.
+ *
+ * The child **inherits the parent's principal verbatim** (`runAsUserId`,
+ * `tenantId`, `onBehalfOfUserId`) — there is no way to change it — increments
+ * the depth (asserting the ceiling), and carries the invoked worker's own tool
+ * ceiling. A `requestedPrincipal` that differs from the parent's is rejected, so
+ * a worker can never invoke a further worker under a broader principal.
+ *
+ * @throws {@link DelegationDepthExceededError} when the child would exceed the depth ceiling.
+ * @throws {@link PrincipalWideningError} when a requested principal widens the parent's.
+ */
+export declare function deriveDelegationEnvelope(parent: DelegationEnvelope, options?: DeriveDelegationEnvelopeOptions): DelegationEnvelope;
+//# sourceMappingURL=delegation.d.ts.map

package/dist/delegation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegation.d.ts","sourceRoot":"","sources":["../src/delegation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,qBAAa,4BAA6B,SAAQ,KAAK;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,OAAO;gBAEV,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAS5C;AAED;;;;GAIG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,kBAAkB,CAAC;IACzC,QAAQ,CAAC,MAAM,OAAO;gBAGpB,KAAK,EAAE,MAAM,kBAAkB,EAC/B,QAAQ,EAAE,OAAO,EACjB,GAAG,EAAE,OAAO;CAUf;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,EACb,QAAQ,GAAE,MAA6B,GACtC,IAAI,CAIN;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,IAAI,CACV,kBAAkB,EAClB,aAAa,GAAG,UAAU,GAAG,kBAAkB,CAChD,EACD,SAAS,EAAE,kBAAkB,GAC5B,IAAI,CA+BN;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C,yEAAyE;IACzE,WAAW,EAAE,MAAM,CAAC;IACpB,wCAAwC;IACxC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,8DAA8D;IAC9D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,6BAA6B,GACrC,kBAAkB,CASpB;AAED;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC9C,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,kBAAkB,EAC1B,OAAO,GAAE,+BAAoC,GAC5C,kBAAkB,CAepB"}

package/dist/index.d.ts

@@ -3,10 +3,12 @@ export { getClassConfigResolvers, getConfigResolver, isLazyConfigSentinel, listC
 export { Agent, type AgentOptions } from './agent.js';
 export { type AgentAIOptions, type AgentAISecretFallback, resolveAgentAIOptions, } from './ai-config.js';
 export { AgentConfig, AgentConfigCollection } from './config.js';
+export { assertPrincipalNotWidened, assertWithinDelegationDepth, DelegationDepthExceededError, type DelegationEnvelope, type DeriveDelegationEnvelopeOptions, deriveDelegationEnvelope, MAX_DELEGATION_DEPTH, PrincipalWideningError, type RequestedPrincipal, type RootDelegationEnvelopeOptions, rootDelegationEnvelope, } from './delegation.js';
 export { type ExecuteAsPrincipalOptions, executeAsPrincipal, type PrincipalAuditEntry, type PrincipalAuditSink, type PrincipalBinding, type PrincipalRun, PrincipalToolNotAllowedError, } from './execute-as-principal.js';
 export { instanceScopedSubscriber } from './identity.js';
 export type { AgentWithInterestsOptions, AsyncQualifierFn, InterestFilter, InterestHandlerFn, InterestOptions, InterestResult, ObjectFilter, ObjectInterestConfig, QueryFn, } from './interests.js';
 export { mergeFilters, normalizeSort } from './interests.js';
+export { AGENT_COMPLETED_SIGNAL, AGENT_INVOKE_SIGNAL, type AgentCompletion, agentInvokeSignalType, type CreateInvokeAgentToolOptions, createDispatchInvokeTransport, createInvokeAgentTool, emitAgentCompletion, executeDelegatedInvocation, INVOKE_AGENT_FUNCTION_NAME, INVOKE_AGENT_TOOL_SLUG, type InvokeAgentDelivery, type InvokeAgentResult, type InvokeAgentTransport, inlineInvokeAgentTransport, type PrincipalTool, type PrincipalToolContext, processAgentInvocations, surfaceAgentCompletions, type WorkerInvocation, type WorkerRunner, } from './invoke-agent.js';
 export { type AgentLearningConfig, type AgentLearningDeclaration, type ResolvedAgentLearning, resolveAgentLearning, } from './learning.js';
 export { AgentSchedule, AgentScheduleCollection, type ScheduleStatus, } from './schedule.js';
 export type { SummaryArticleImage, SummaryArticleOptions, SummaryArticleResult, } from './summary-article.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AAKH,OAAO,wBAAwB,CAAC;AAIhC,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,qBAAqB,GACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EACL,KAAK,yBAAyB,EAC9B,kBAAkB,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC;AAInC,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACzD,YAAY,EACV,yBAAyB,EACzB,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,YAAY,EACZ,oBAAoB,EACpB,OAAO,GACR,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAG7D,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,oBAAoB,GACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACb,uBAAuB,EACvB,KAAK,cAAc,GACpB,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,yBAAyB,EAC9B,WAAW,EACX,qBAAqB,EACrB,KAAK,iBAAiB,GACvB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAC7B,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,gBAAgB,GACjB,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}