@ixo/oracle-runtime 0.0.1

package/dist/registries/manifest-registry.js

@@ -0,0 +1,53 @@
+import { validateExamplesAgainstTools } from '../manifest/validator.js';
+/**
+ * Stores plugin manifests and wires the cross-tool-reference check that can
+ * only run once tool registration is complete.
+ *
+ * Manifest titles can collide (display only); the registry does not block on
+ * title duplication.
+ */
+export class ManifestRegistry {
+    entries = [];
+    /** Record a plugin's manifest. */
+    register(plugin) {
+        this.entries.push({ pluginName: plugin.name, manifest: plugin.manifest });
+    }
+    /**
+     * Plain-pass collect — returns the registered manifests in registration
+     * order. Manifests are eagerly available on the plugin, so this method
+     * accepts no context but matches the registry shape used elsewhere.
+     */
+    collect() {
+        return [...this.entries];
+    }
+    /**
+     * For each registered manifest, validate that every `examples[].tool`
+     * reference exists in the supplied registries. Sub-agents are first-class
+     * tools to the agent — they get wrapped as `call_<name>` StructuredTools —
+     * so the validator unions tool names with sub-agent wrapped names. Both
+     * registries MUST have been collected and asserted before calling this.
+     *
+     * Returns the union of all per-plugin error strings — each entry is
+     * prefixed with the plugin name and field path (delegated to
+     * `validateExamplesAgainstTools`).
+     */
+    validateAgainstTools(toolRegistry, subAgentRegistry) {
+        const errors = [];
+        for (const { pluginName, manifest } of this.entries) {
+            const toolNames = [
+                ...toolRegistry.toolNamesForPlugin(pluginName),
+                ...subAgentRegistry.subAgentNamesForPlugin(pluginName),
+            ];
+            const result = validateExamplesAgainstTools(manifest, toolNames, pluginName);
+            errors.push(...result.errors);
+        }
+        return { errors };
+    }
+    /**
+     * Manifest title collisions are display-only, so this is a no-op. Provided
+     * for a uniform registry surface.
+     */
+    assertNoCollisions() {
+        // Intentional no-op — title collisions warned at the loader level.
+    }
+}

package/dist/registries/middleware-registry.d.ts

@@ -0,0 +1,41 @@
+import type { OraclePlugin } from '../plugin-api/oracle-plugin.js';
+import type { AgentMiddleware, PluginContext } from '../plugin-api/types.js';
+/** A collected middleware tagged with the plugin that contributed it. */
+export interface RegisteredMiddleware {
+    pluginName: string;
+    middleware: AgentMiddleware;
+}
+/**
+ * Stores plugins that contribute middlewares and resolves them by invoking
+ * each plugin's `getMiddlewares(buildCtx)` at collection time.
+ *
+ * Order is preserved as registration order — the loader applies any
+ * dependency-driven topological reordering before registering plugins here,
+ * so the registry just preserves the order it gets.
+ *
+ * Middlewares are boot-time-only — there's no per-request hook. The
+ * registry caches the first `collect(buildCtx)` result so request-time
+ * agent builds don't re-run each plugin's `getMiddlewares`.
+ */
+export declare class MiddlewareRegistry {
+    private readonly plugins;
+    private bootCache;
+    /**
+     * Add a plugin whose `getMiddlewares` will be called at `collect()` time.
+     * Plugins are stored in the order they are registered.
+     */
+    register(plugin: OraclePlugin): void;
+    /**
+     * Invoke `getMiddlewares(buildCtx)` on every registered plugin in
+     * registration order and return the flattened list. Skips plugins that do
+     * not implement `getMiddlewares`. The result is cached after the first
+     * call.
+     */
+    collect(buildCtx: PluginContext): RegisteredMiddleware[];
+    /**
+     * Middlewares have no names, so no collision is possible. Method exists for
+     * a uniform registry surface.
+     */
+    assertNoCollisions(): void;
+}
+//# sourceMappingURL=middleware-registry.d.ts.map

package/dist/registries/middleware-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-registry.d.ts","sourceRoot":"","sources":["../../src/registries/middleware-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE7E,yEAAyE;AACzE,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,eAAe,CAAC;CAC7B;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,SAAS,CAAuC;IAExD;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAKpC;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,EAAE,aAAa,GAAG,oBAAoB,EAAE;IAcxD;;;OAGG;IACH,kBAAkB,IAAI,IAAI;CAG3B"}

package/dist/registries/middleware-registry.js

@@ -0,0 +1,52 @@
+/**
+ * Stores plugins that contribute middlewares and resolves them by invoking
+ * each plugin's `getMiddlewares(buildCtx)` at collection time.
+ *
+ * Order is preserved as registration order — the loader applies any
+ * dependency-driven topological reordering before registering plugins here,
+ * so the registry just preserves the order it gets.
+ *
+ * Middlewares are boot-time-only — there's no per-request hook. The
+ * registry caches the first `collect(buildCtx)` result so request-time
+ * agent builds don't re-run each plugin's `getMiddlewares`.
+ */
+export class MiddlewareRegistry {
+    plugins = [];
+    bootCache = null;
+    /**
+     * Add a plugin whose `getMiddlewares` will be called at `collect()` time.
+     * Plugins are stored in the order they are registered.
+     */
+    register(plugin) {
+        this.plugins.push(plugin);
+        this.bootCache = null;
+    }
+    /**
+     * Invoke `getMiddlewares(buildCtx)` on every registered plugin in
+     * registration order and return the flattened list. Skips plugins that do
+     * not implement `getMiddlewares`. The result is cached after the first
+     * call.
+     */
+    collect(buildCtx) {
+        if (this.bootCache !== null)
+            return this.bootCache;
+        const out = [];
+        for (const plugin of this.plugins) {
+            if (!plugin.getMiddlewares)
+                continue;
+            const middlewares = plugin.getMiddlewares(buildCtx);
+            for (const middleware of middlewares) {
+                out.push({ pluginName: plugin.name, middleware });
+            }
+        }
+        this.bootCache = out;
+        return out;
+    }
+    /**
+     * Middlewares have no names, so no collision is possible. Method exists for
+     * a uniform registry surface.
+     */
+    assertNoCollisions() {
+        // Intentional no-op — middleware order is established by the loader.
+    }
+}

package/dist/registries/shared-state-registry.d.ts

@@ -0,0 +1,41 @@
+import type { OraclePlugin } from '../plugin-api/oracle-plugin.js';
+import type { RuntimeContext, SharedAccessors } from '../plugin-api/types.js';
+/** A single read accessor, contributed by a plugin under a unique key. */
+type SharedAccessorFn = (state: any, runCtx: RuntimeContext) => unknown;
+/** A collected accessor tagged with the plugin that contributed it. */
+export interface RegisteredSharedAccessor {
+    pluginName: string;
+    key: string;
+    accessor: SharedAccessorFn;
+}
+/**
+ * Stores read-only accessors that plugins expose to other plugins via
+ * `runCtx.shared`. Each accessor is keyed by a string and computes a value
+ * from graph state plus the live RuntimeContext.
+ *
+ * Key collisions across plugins are a boot error — the spec forbids two
+ * plugins from owning the same `ctx.shared.<key>`.
+ */
+export declare class SharedStateRegistry {
+    private readonly entries;
+    /** Record a plugin's shared accessors. Plugins without any are skipped. */
+    register(plugin: OraclePlugin): void;
+    /** Return the registered accessors in registration order. */
+    collect(): RegisteredSharedAccessor[];
+    /**
+     * Build a `SharedAccessors` snapshot from the supplied state and runtime
+     * context by invoking each registered accessor lazily as keys are read.
+     *
+     * Accessors run on demand (via `Object.defineProperty` getters) so that an
+     * accessor that throws does not break unrelated `ctx.shared.<otherKey>`
+     * reads.
+     */
+    build(state: any, runCtx: RuntimeContext): SharedAccessors;
+    /**
+     * Throw if two plugins contribute accessors under the same key. The error
+     * message names both plugins.
+     */
+    assertNoCollisions(): void;
+}
+export {};
+//# sourceMappingURL=shared-state-registry.d.ts.map

package/dist/registries/shared-state-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-state-registry.d.ts","sourceRoot":"","sources":["../../src/registries/shared-state-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9E,0EAA0E;AAC1E,KAAK,gBAAgB,GAAG,CAEtB,KAAK,EAAE,GAAG,EACV,MAAM,EAAE,cAAc,KACnB,OAAO,CAAC;AAEb,uEAAuE;AACvE,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAE1D,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAQpC,6DAA6D;IAC7D,OAAO,IAAI,wBAAwB,EAAE;IAIrC;;;;;;;OAOG;IACH,KAAK,CAEH,KAAK,EAAE,GAAG,EACV,MAAM,EAAE,cAAc,GACrB,eAAe;IAYlB;;;OAGG;IACH,kBAAkB,IAAI,IAAI;CAmB3B"}

package/dist/registries/shared-state-registry.js

@@ -0,0 +1,65 @@
+/**
+ * Stores read-only accessors that plugins expose to other plugins via
+ * `runCtx.shared`. Each accessor is keyed by a string and computes a value
+ * from graph state plus the live RuntimeContext.
+ *
+ * Key collisions across plugins are a boot error — the spec forbids two
+ * plugins from owning the same `ctx.shared.<key>`.
+ */
+export class SharedStateRegistry {
+    entries = [];
+    /** Record a plugin's shared accessors. Plugins without any are skipped. */
+    register(plugin) {
+        if (!plugin.getSharedState)
+            return;
+        const map = plugin.getSharedState();
+        for (const [key, accessor] of Object.entries(map)) {
+            this.entries.push({ pluginName: plugin.name, key, accessor });
+        }
+    }
+    /** Return the registered accessors in registration order. */
+    collect() {
+        return [...this.entries];
+    }
+    /**
+     * Build a `SharedAccessors` snapshot from the supplied state and runtime
+     * context by invoking each registered accessor lazily as keys are read.
+     *
+     * Accessors run on demand (via `Object.defineProperty` getters) so that an
+     * accessor that throws does not break unrelated `ctx.shared.<otherKey>`
+     * reads.
+     */
+    build(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    state, runCtx) {
+        const target = {};
+        for (const { key, accessor } of this.entries) {
+            Object.defineProperty(target, key, {
+                enumerable: true,
+                configurable: false,
+                get: () => accessor(state, runCtx),
+            });
+        }
+        return target;
+    }
+    /**
+     * Throw if two plugins contribute accessors under the same key. The error
+     * message names both plugins.
+     */
+    assertNoCollisions() {
+        const seen = new Map();
+        const collisions = [];
+        for (const { pluginName, key } of this.entries) {
+            const prev = seen.get(key);
+            if (prev !== undefined && prev !== pluginName) {
+                collisions.push(`Shared-state key "${key}" registered by both "${prev}" and "${pluginName}"`);
+            }
+            else if (prev === undefined) {
+                seen.set(key, pluginName);
+            }
+        }
+        if (collisions.length > 0) {
+            throw new Error(`SharedStateRegistry: shared-state key collisions detected:\n  - ${collisions.join('\n  - ')}`);
+        }
+    }
+}

package/dist/registries/subagent-registry.d.ts

@@ -0,0 +1,55 @@
+import type { OraclePlugin } from '../plugin-api/oracle-plugin.js';
+import type { PluginContext, PluginSubAgent, RuntimeContext } from '../plugin-api/types.js';
+/** A collected sub-agent tagged with the plugin that contributed it. */
+export interface RegisteredSubAgent {
+    pluginName: string;
+    subAgent: PluginSubAgent;
+}
+/**
+ * Stores plugins that contribute sub-agents and resolves them by invoking
+ * each plugin's `getSubAgents(buildCtx)` at collection time.
+ *
+ * Sub-agents are wrapped as tools by the runtime, so their names share the
+ * tool namespace. Duplicate sub-agent names across plugins are a boot error.
+ *
+ * Like `ToolRegistry`, boot-time outputs are cached on the first
+ * `collectBoot(buildCtx)` call so per-request builds only re-run the
+ * request-time hook.
+ */
+export declare class SubAgentRegistry {
+    private readonly plugins;
+    private bootCache;
+    private collected;
+    /** Add a plugin whose `getSubAgents` will be called at `collect()` time. */
+    register(plugin: OraclePlugin): void;
+    /**
+     * Run every plugin's `getSubAgents(buildCtx)` once and cache the result.
+     */
+    collectBoot(buildCtx: PluginContext): RegisteredSubAgent[];
+    /**
+     * Run every plugin's `getRequestSubAgents(rtCtx)`. Does NOT touch the boot
+     * cache.
+     */
+    collectRequest(rtCtx: RuntimeContext): Promise<RegisteredSubAgent[]>;
+    /**
+     * Combined boot + request collection used by the main agent build.
+     */
+    collect(buildCtx: PluginContext, rtCtx?: RuntimeContext): Promise<RegisteredSubAgent[]>;
+    /**
+     * The *wrapped* tool names contributed by a given plugin in the most recent
+     * collection (boot-only if a full request collection has not yet happened).
+     * Mirrors `ToolRegistry.toolNamesForPlugin` so the manifest validator can
+     * treat sub-agents as the tools they become to the agent.
+     *
+     * Each entry passes through `computeSubAgentToolName` — the same transform
+     * `createSubagentAsTool` applies when building the StructuredTool — so the
+     * names returned here match what the agent will actually see.
+     */
+    subAgentNamesForPlugin(pluginName: string): string[];
+    /**
+     * Throw if two plugins contribute sub-agents with the same name. The error
+     * message names both plugin names so the boot log points at the conflict.
+     */
+    assertNoCollisions(): void;
+}
+//# sourceMappingURL=subagent-registry.d.ts.map

package/dist/registries/subagent-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-registry.d.ts","sourceRoot":"","sources":["../../src/registries/subagent-registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,cAAc,EACf,MAAM,wBAAwB,CAAC;AAEhC,wEAAwE;AACxE,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,SAAS,CAAqC;IACtD,OAAO,CAAC,SAAS,CAAqC;IAEtD,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAMpC;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,aAAa,GAAG,kBAAkB,EAAE;IAc1D;;;OAGG;IACG,cAAc,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAY1E;;OAEG;IACG,OAAO,CACX,QAAQ,EAAE,aAAa,EACvB,KAAK,CAAC,EAAE,cAAc,GACrB,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAQhC;;;;;;;;;OASG;IACH,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE;IAMpD;;;OAGG;IACH,kBAAkB,IAAI,IAAI;CAyB3B"}

package/dist/registries/subagent-registry.js

@@ -0,0 +1,106 @@
+import { computeSubAgentToolName } from '../graph/subagent-as-tool.js';
+/**
+ * Stores plugins that contribute sub-agents and resolves them by invoking
+ * each plugin's `getSubAgents(buildCtx)` at collection time.
+ *
+ * Sub-agents are wrapped as tools by the runtime, so their names share the
+ * tool namespace. Duplicate sub-agent names across plugins are a boot error.
+ *
+ * Like `ToolRegistry`, boot-time outputs are cached on the first
+ * `collectBoot(buildCtx)` call so per-request builds only re-run the
+ * request-time hook.
+ */
+export class SubAgentRegistry {
+    plugins = [];
+    bootCache = null;
+    collected = null;
+    /** Add a plugin whose `getSubAgents` will be called at `collect()` time. */
+    register(plugin) {
+        this.plugins.push(plugin);
+        this.bootCache = null;
+        this.collected = null;
+    }
+    /**
+     * Run every plugin's `getSubAgents(buildCtx)` once and cache the result.
+     */
+    collectBoot(buildCtx) {
+        if (this.bootCache !== null)
+            return this.bootCache;
+        const out = [];
+        for (const plugin of this.plugins) {
+            if (!plugin.getSubAgents)
+                continue;
+            const subAgents = plugin.getSubAgents(buildCtx);
+            for (const subAgent of subAgents) {
+                out.push({ pluginName: plugin.name, subAgent });
+            }
+        }
+        this.bootCache = out;
+        return out;
+    }
+    /**
+     * Run every plugin's `getRequestSubAgents(rtCtx)`. Does NOT touch the boot
+     * cache.
+     */
+    async collectRequest(rtCtx) {
+        const out = [];
+        for (const plugin of this.plugins) {
+            if (!plugin.getRequestSubAgents)
+                continue;
+            const requestSubAgents = await plugin.getRequestSubAgents(rtCtx);
+            for (const subAgent of requestSubAgents) {
+                out.push({ pluginName: plugin.name, subAgent });
+            }
+        }
+        return out;
+    }
+    /**
+     * Combined boot + request collection used by the main agent build.
+     */
+    async collect(buildCtx, rtCtx) {
+        const boot = this.collectBoot(buildCtx);
+        const request = rtCtx ? await this.collectRequest(rtCtx) : [];
+        const out = [...boot, ...request];
+        this.collected = out;
+        return out;
+    }
+    /**
+     * The *wrapped* tool names contributed by a given plugin in the most recent
+     * collection (boot-only if a full request collection has not yet happened).
+     * Mirrors `ToolRegistry.toolNamesForPlugin` so the manifest validator can
+     * treat sub-agents as the tools they become to the agent.
+     *
+     * Each entry passes through `computeSubAgentToolName` — the same transform
+     * `createSubagentAsTool` applies when building the StructuredTool — so the
+     * names returned here match what the agent will actually see.
+     */
+    subAgentNamesForPlugin(pluginName) {
+        return (this.collected ?? this.bootCache ?? [])
+            .filter((entry) => entry.pluginName === pluginName)
+            .map((entry) => computeSubAgentToolName(entry.subAgent.name));
+    }
+    /**
+     * Throw if two plugins contribute sub-agents with the same name. The error
+     * message names both plugin names so the boot log points at the conflict.
+     */
+    assertNoCollisions() {
+        const source = this.collected ?? this.bootCache;
+        if (source === null) {
+            throw new Error('SubAgentRegistry.assertNoCollisions called before collect');
+        }
+        const seen = new Map();
+        const collisions = [];
+        for (const { pluginName, subAgent } of source) {
+            const prev = seen.get(subAgent.name);
+            if (prev !== undefined && prev !== pluginName) {
+                collisions.push(`Sub-agent "${subAgent.name}" registered by both "${prev}" and "${pluginName}"`);
+            }
+            else if (prev === undefined) {
+                seen.set(subAgent.name, pluginName);
+            }
+        }
+        if (collisions.length > 0) {
+            throw new Error(`SubAgentRegistry: sub-agent name collisions detected:\n  - ${collisions.join('\n  - ')}`);
+        }
+    }
+}

package/dist/registries/test-fixtures.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { OraclePlugin } from '../plugin-api/oracle-plugin.js';
+import type { AgentMiddleware, PluginContext, PluginManifest, PluginSubAgent, PluginTool, RuntimeContext } from '../plugin-api/types.js';
+/** Build a minimal PluginContext sufficient for registry collection. */
+export declare function makeBuildCtx(overrides?: Partial<PluginContext>): PluginContext;
+/** Build a minimal PluginManifest for tests. */
+export declare function makeManifest(overrides?: Partial<PluginManifest>): PluginManifest;
+/** Build a PluginTool fixture with a no-op handler. */
+export declare function makeTool(name: string, overrides?: Partial<PluginTool>): PluginTool;
+/** Build a PluginSubAgent fixture. */
+export declare function makeSubAgent(name: string, overrides?: Partial<PluginSubAgent>): PluginSubAgent;
+/**
+ * Build a minimally-typed AgentMiddleware fixture for registry tests.
+ * Registries only store and forward middlewares — they never invoke them —
+ * so a name-only object satisfies the structural type without pulling
+ * langchain into the test module graph.
+ */
+export declare function makeMiddleware(label: string): AgentMiddleware;
+/**
+ * Build a plain `OraclePlugin`-conforming object. Avoids subclassing the
+ * abstract class so tests stay shape-driven and tolerate API additions.
+ */
+export interface TestPluginInit {
+    name: string;
+    version?: string;
+    manifest?: PluginManifest;
+    dependsOn?: string[];
+    softDependsOn?: string[];
+    configSchema?: z.ZodObject<any>;
+    autoDetect?: (env: NodeJS.ProcessEnv) => boolean;
+    autoDetectHint?: string;
+    getTools?: (ctx: PluginContext) => PluginTool[] | Promise<PluginTool[]>;
+    getSubAgents?: (ctx: PluginContext) => PluginSubAgent[];
+    getMiddlewares?: (ctx: PluginContext) => AgentMiddleware[];
+    getRequestTools?: (rtCtx: RuntimeContext) => PluginTool[] | Promise<PluginTool[]>;
+    getRequestSubAgents?: (rtCtx: RuntimeContext) => PluginSubAgent[] | Promise<PluginSubAgent[]>;
+    getSharedState?: () => Record<string, (state: any, runCtx: RuntimeContext) => unknown>;
+}
+/**
+ * Minimal `RuntimeContext` stub used by `SharedStateRegistry.build` tests.
+ * Mirrors the pattern in `plugin-api.test.ts` — `satisfies RuntimeContext`
+ * keeps the shape honest with one narrow assertion on the unrelated LLM
+ * adapter return.
+ */
+export declare function makeRuntimeContext(overrides?: Partial<RuntimeContext>): RuntimeContext;
+export declare function makePlugin(init: TestPluginInit): OraclePlugin;
+//# sourceMappingURL=test-fixtures.d.ts.map

package/dist/registries/test-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-fixtures.d.ts","sourceRoot":"","sources":["../../src/registries/test-fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,cAAc,EACd,cAAc,EACd,UAAU,EACV,cAAc,EACf,MAAM,wBAAwB,CAAC;AAEhC,wEAAwE;AACxE,wBAAgB,YAAY,CAC1B,SAAS,GAAE,OAAO,CAAC,aAAa,CAAM,GACrC,aAAa,CAkBf;AAED,gDAAgD;AAChD,wBAAgB,YAAY,CAC1B,SAAS,GAAE,OAAO,CAAC,cAAc,CAAM,GACtC,cAAc,CAQhB;AAED,uDAAuD;AACvD,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,OAAO,CAAC,UAAU,CAAM,GAClC,UAAU,CAQZ;AAED,sCAAsC;AACtC,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,OAAO,CAAC,cAAc,CAAM,GACtC,cAAc,CAQhB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAE7D;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB,YAAY,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAChC,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,KAAK,OAAO,CAAC;IACjD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,UAAU,EAAE,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IACxE,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,cAAc,EAAE,CAAC;IACxD,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,eAAe,EAAE,CAAC;IAC3D,eAAe,CAAC,EAAE,CAChB,KAAK,EAAE,cAAc,KAClB,UAAU,EAAE,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAC1C,mBAAmB,CAAC,EAAE,CACpB,KAAK,EAAE,cAAc,KAClB,cAAc,EAAE,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAClD,cAAc,CAAC,EAAE,MAAM,MAAM,CAC3B,MAAM,EAEN,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,cAAc,KAAK,OAAO,CAChD,CAAC;CACH;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,GAAE,OAAO,CAAC,cAAc,CAAM,GACtC,cAAc,CA6EhB;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,YAAY,CAyC7D"}

package/dist/registries/test-fixtures.js

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+import { OraclePlugin } from '../plugin-api/oracle-plugin.js';
+/** Build a minimal PluginContext sufficient for registry collection. */
+export function makeBuildCtx(overrides = {}) {
+    const noopLogger = {
+        log: () => undefined,
+        error: () => undefined,
+        warn: () => undefined,
+    };
+    return {
+        config: {},
+        identity: {
+            name: 'TestOracle',
+            org: 'Acme',
+            description: 'test oracle',
+            entityDid: 'did:ixo:test',
+        },
+        availablePlugins: new Set(),
+        logger: noopLogger,
+        ...overrides,
+    };
+}
+/** Build a minimal PluginManifest for tests. */
+export function makeManifest(overrides = {}) {
+    return {
+        title: 'Test Plugin',
+        summary: 'A plugin used in registry tests.',
+        whenToUse: ['always for testing'],
+        visibility: 'always',
+        ...overrides,
+    };
+}
+/** Build a PluginTool fixture with a no-op handler. */
+export function makeTool(name, overrides = {}) {
+    return {
+        name,
+        description: `tool ${name}`,
+        schema: z.object({}),
+        handler: async () => 'ok',
+        ...overrides,
+    };
+}
+/** Build a PluginSubAgent fixture. */
+export function makeSubAgent(name, overrides = {}) {
+    return {
+        name,
+        description: `subagent ${name}`,
+        systemPrompt: 'you are a test sub-agent',
+        tools: [],
+        ...overrides,
+    };
+}
+/**
+ * Build a minimally-typed AgentMiddleware fixture for registry tests.
+ * Registries only store and forward middlewares — they never invoke them —
+ * so a name-only object satisfies the structural type without pulling
+ * langchain into the test module graph.
+ */
+export function makeMiddleware(label) {
+    return { name: label };
+}
+/**
+ * Minimal `RuntimeContext` stub used by `SharedStateRegistry.build` tests.
+ * Mirrors the pattern in `plugin-api.test.ts` — `satisfies RuntimeContext`
+ * keeps the shape honest with one narrow assertion on the unrelated LLM
+ * adapter return.
+ */
+export function makeRuntimeContext(overrides = {}) {
+    const base = {
+        user: {
+            did: 'did:ixo:user1',
+            matrixUserId: '@did-ixo-user1:ixo.world',
+            ucanDelegation: { raw: 'test-ucan-delegation' },
+        },
+        session: {
+            id: 'session-1',
+            client: 'portal',
+            requestId: 'req-1',
+        },
+        history: {
+            messages: [],
+            recent: () => [],
+            userContext: {},
+            state: { messages: [] },
+        },
+        config: {},
+        availablePlugins: new Set(),
+        loadedPlugins: new Set(),
+        secrets: {
+            getIndex: async () => ({}),
+            getValues: async () => ({}),
+        },
+        blobStore: {
+            put: async () => 'blob_0000000000000000',
+            get: async () => null,
+            isValidBlobId: (value) => typeof value === 'string' && /^blob_[0-9a-f]{16}$/.test(value),
+        },
+        matrix: {
+            postToRoom: async () => 'event-id',
+            getRoomState: async (roomId) => ({ roomId, state: [] }),
+            getEventById: async (_roomId, eventId) => ({
+                eventId,
+                type: 'm.room.message',
+                content: {},
+            }),
+        },
+        ucan: {
+            requireCapability: () => undefined,
+            hasCapability: () => true,
+            mintInvocation: async () => 'invocation-cid',
+            resolveServiceDid: async () => 'did:web:example.com',
+            hasSigningKey: () => true,
+            createInvocationFromDelegation: async () => ({
+                invocation: 'invocation-car',
+            }),
+        },
+        llm: {
+            get: () => ({}),
+        },
+        emit: {
+            toolCall: () => undefined,
+            actionCall: () => undefined,
+            renderComponent: () => undefined,
+            reasoning: () => undefined,
+            browserToolCall: () => undefined,
+            router: () => undefined,
+            messageCacheInvalidation: () => undefined,
+        },
+        logger: {
+            log: () => undefined,
+            error: () => undefined,
+            warn: () => undefined,
+        },
+        abortSignal: new AbortController().signal,
+        shared: {},
+    };
+    return { ...base, ...overrides };
+}
+export function makePlugin(init) {
+    class TestPlugin extends OraclePlugin {
+        name = init.name;
+        version = init.version ?? '0.0.1';
+        manifest = init.manifest ?? makeManifest();
+        dependsOn = init.dependsOn;
+        softDependsOn = init.softDependsOn;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        configSchema = init.configSchema;
+        autoDetectHint = init.autoDetectHint;
+        autoDetect(env) {
+            return init.autoDetect ? init.autoDetect(env) : true;
+        }
+        getTools(ctx) {
+            return init.getTools ? init.getTools(ctx) : [];
+        }
+        getSubAgents(ctx) {
+            return init.getSubAgents ? init.getSubAgents(ctx) : [];
+        }
+        getMiddlewares(ctx) {
+            return init.getMiddlewares ? init.getMiddlewares(ctx) : [];
+        }
+        getRequestTools = init.getRequestTools;
+        getRequestSubAgents = init.getRequestSubAgents;
+        getSharedState() {
+            return init.getSharedState ? init.getSharedState() : {};
+        }
+    }
+    return new TestPlugin();
+}