@jangts/agent-core 0.3.5 → 0.5.0

package/dist/esm/kits/answering/flow.js

@@ -7,6 +7,7 @@
  *
  * Exports: `defineAnswerFlow`, and the answer flow/item/result/check types.
  */
+import { nativeSubFlowAsync } from '../../diagnostics/native-sub-flow.js';
 import { booleanResult, synchronous } from '../../utils/synchronous.js';
 import { awaitWithSignal } from '../../utils/cancellation.js';
 import { AgentCoreEngine } from '../../execution/engine.js';
@@ -279,27 +280,29 @@ export function defineAnswerFlow(definition) {
          *   exhausted without a final result.
          */
         async run(request, context) {
-            context.signal.throwIfAborted();
-            validateAnswerBatch(request.inputIds, request.items, maxItems);
-            const cells = request.items.map((item) => ({
-                item: Object.freeze({
-                    id: item.id,
-                    data: item.data,
-                    sourceStatus: item.sourceStatus,
-                    inputIds: Object.freeze([...item.inputIds]),
-                }),
-                hasValue: false,
-                local: { status: 'not-run', issues: [] },
-                review: { status: 'not-run', issues: [] },
-                knownReviewFailure: false,
-            }));
-            return new AgentCoreEngine({
-                maxRounds: maxRepairs + 1,
-                errors: { exhausted: () => new TypeError('Answer flow exhausted') },
-                execution: { signal: context.signal, diagnostics: context.diagnostics },
-            })
-                .bindWorkflow(workflow, context.app)
-                .run({ cells, pending: [], repairBudget: new AttemptBudget(maxRepairs) });
+            return nativeSubFlowAsync(context, 'answer', 'answer-flow', async () => {
+                context.signal.throwIfAborted();
+                validateAnswerBatch(request.inputIds, request.items, maxItems);
+                const cells = request.items.map((item) => ({
+                    item: Object.freeze({
+                        id: item.id,
+                        data: item.data,
+                        sourceStatus: item.sourceStatus,
+                        inputIds: Object.freeze([...item.inputIds]),
+                    }),
+                    hasValue: false,
+                    local: { status: 'not-run', issues: [] },
+                    review: { status: 'not-run', issues: [] },
+                    knownReviewFailure: false,
+                }));
+                return new AgentCoreEngine({
+                    maxRounds: maxRepairs + 1,
+                    errors: { exhausted: () => new TypeError('Answer flow exhausted') },
+                    execution: { signal: context.signal, diagnostics: context.diagnostics },
+                })
+                    .bindWorkflow(workflow, context.app)
+                    .run({ cells, pending: [], repairBudget: new AttemptBudget(maxRepairs) });
+            });
         },
     });
 }

package/dist/esm/kits/answering/tasks.d.ts

@@ -36,7 +36,7 @@ export declare function defineAnswerTaskCatalog<Input, Evidence, App, Data = unk
         readerId: string;
         outputId: string;
         scopeId: string | undefined;
-        intentIds: readonly any[];
+        goalIds: readonly any[];
         checkIds: readonly any[];
         metadata: Data;
     }[];
@@ -64,7 +64,7 @@ export declare function defineAnswerTaskCatalog<Input, Evidence, App, Data = unk
         readerId: string;
         outputId: string;
         scopeId: string | undefined;
-        intentIds: readonly any[];
+        goalIds: readonly any[];
         checkIds: readonly any[];
         inputSchema: import("../../index.js").SchemaAdapter<Input>;
         metadata: Data;
@@ -76,7 +76,7 @@ export declare function defineAnswerTaskCatalog<Input, Evidence, App, Data = unk
         readerId: string;
         outputId: string;
         scopeId: string | undefined;
-        intentIds: readonly any[];
+        goalIds: readonly any[];
         checkIds: readonly any[];
         inputSchema: import("../../index.js").SchemaAdapter<Input>;
         metadata: Data;
@@ -87,7 +87,7 @@ export declare function defineAnswerTaskCatalog<Input, Evidence, App, Data = unk
         readerId: string;
         outputId: string;
         scopeId: string | undefined;
-        intentIds: readonly any[];
+        goalIds: readonly any[];
         checkIds: readonly any[];
         inputSchema: import("../../index.js").SchemaAdapter<Input>;
         metadata: Data;
@@ -99,7 +99,7 @@ export declare function defineAnswerTaskCatalog<Input, Evidence, App, Data = unk
         readerId: string;
         outputId: string;
         scopeId: string | undefined;
-        intentIds: readonly any[];
+        goalIds: readonly any[];
         checkIds: readonly any[];
         inputSchema: import("../../index.js").SchemaAdapter<Input>;
         metadata: Data;
@@ -110,7 +110,7 @@ export declare function defineAnswerTaskCatalog<Input, Evidence, App, Data = unk
         readerId: string;
         outputId: string;
         scopeId: string | undefined;
-        intentIds: readonly any[];
+        goalIds: readonly any[];
         checkIds: readonly any[];
         inputSchema: import("../../index.js").SchemaAdapter<Input>;
         metadata: Data;

package/dist/esm/kits/answering/tasks.js

@@ -7,6 +7,7 @@
  *
  * Exports: `defineAnswerReaderCatalog`, `defineAnswerTaskCatalog`, and the task/reader types.
  */
+import { nativeSubFlowSync, nativeSubFlowAsync } from '../../diagnostics/native-sub-flow.js';
 import { readonlyCatalog } from '../../utils/catalog.js';
 import { assertion, synchronous } from '../../utils/synchronous.js';
 import { freezeSchema } from '../../utils/object.js';
@@ -50,10 +51,10 @@ export function defineAnswerTaskCatalog(definitions, ports) {
             !definition.description?.trim() ||
             !readers.has(definition.readerId) ||
             !outputs.has(definition.outputId) ||
-            !Array.isArray(definition.intentIds) ||
-            !definition.intentIds.length ||
-            definition.intentIds.some((id) => typeof id !== 'string' || !id.trim()) ||
-            new Set(definition.intentIds).size !== definition.intentIds.length ||
+            !Array.isArray(definition.goalIds) ||
+            !definition.goalIds.length ||
+            definition.goalIds.some((id) => typeof id !== 'string' || !id.trim()) ||
+            new Set(definition.goalIds).size !== definition.goalIds.length ||
             !Array.isArray(definition.checkIds) ||
             new Set(definition.checkIds).size !== definition.checkIds.length ||
             definition.checkIds.some((id) => !checkIds.includes(id)))
@@ -67,7 +68,7 @@ export function defineAnswerTaskCatalog(definitions, ports) {
             readerId: definition.readerId,
             outputId: definition.outputId,
             scopeId: definition.scopeId,
-            intentIds: Object.freeze([...definition.intentIds]),
+            goalIds: Object.freeze([...definition.goalIds]),
             checkIds: Object.freeze([...definition.checkIds]),
             inputSchema: snapshotSchemaAdapter(definition.inputSchema),
             metadata,
@@ -96,16 +97,18 @@ export function defineAnswerTaskCatalog(definitions, ports) {
          * @throws TypeError For an unknown task, a parse failure, or a reader returning a Promise.
          */
         read(request, context) {
-            const { input, task, reader } = prepare(request, context);
-            const value = synchronous(reader.read(input, {
-                ...context,
-                app: context.app,
-                signal: context.signal,
-                diagnostics: context.diagnostics,
-                task,
-            }), 'Synchronous answer readers must not return a Promise');
-            context.signal.throwIfAborted();
-            return value;
+            return nativeSubFlowSync(context, 'task', request.taskId, () => {
+                const { input, task, reader } = prepare(request, context);
+                const value = synchronous(reader.read(input, {
+                    ...context,
+                    app: context.app,
+                    signal: context.signal,
+                    diagnostics: context.diagnostics,
+                    task,
+                }), 'Synchronous answer readers must not return a Promise');
+                context.signal.throwIfAborted();
+                return value;
+            });
         },
         /**
          * Read evidence through a task's registered reader, awaiting an async reader.
@@ -113,16 +116,18 @@ export function defineAnswerTaskCatalog(definitions, ports) {
          * @throws TypeError For an unknown task or a parse failure; aborts with the caller's signal.
          */
         async readAsync(request, context) {
-            const { input, task, reader } = prepare(request, context);
-            const value = await awaitWithSignal(reader.read(input, {
-                ...context,
-                app: context.app,
-                signal: context.signal,
-                diagnostics: context.diagnostics,
-                task,
-            }), context.signal);
-            context.signal.throwIfAborted();
-            return value;
+            return nativeSubFlowAsync(context, 'task', request.taskId, async () => {
+                const { input, task, reader } = prepare(request, context);
+                const value = await awaitWithSignal(reader.read(input, {
+                    ...context,
+                    app: context.app,
+                    signal: context.signal,
+                    diagnostics: context.diagnostics,
+                    task,
+                }), context.signal);
+                context.signal.throwIfAborted();
+                return value;
+            });
         },
     });
 }

package/dist/esm/kits/delivery.d.ts

@@ -1,12 +1,3 @@
-/**
- * Delivery Kit: run an ordered, synchronous stage pipeline that ends with one result.
- *
- * Place in the package: an optional App-side delivery pipeline (for example formatting and
- * sending one reply). The Kit owns ordering, cancellation checks and outcome validation; the
- * stages, their state and the actual side effects belong to the App.
- *
- * Exports: `defineDelivery`, `Delivery`, and the delivery option/outcome types.
- */
 import type { DeliveryOptions } from '../structs/kits/delivery.js';
 import type { ExecutionContext } from '../structs/common.js';
 /**

package/dist/esm/kits/delivery.js

@@ -1,3 +1,13 @@
+/**
+ * Delivery Kit: run an ordered, synchronous stage pipeline that ends with one result.
+ *
+ * Place in the package: an optional App-side delivery pipeline (for example formatting and
+ * sending one reply). The Kit owns ordering, cancellation checks and outcome validation; the
+ * stages, their state and the actual side effects belong to the App.
+ *
+ * Exports: `defineDelivery`, `Delivery`, and the delivery option/outcome types.
+ */
+import { nativeSubFlowSync } from '../diagnostics/native-sub-flow.js';
 import { synchronous } from '../utils/synchronous.js';
 /**
  * Compile a delivery pipeline from its declared stages.
@@ -38,33 +48,35 @@ export function defineDelivery(options) {
          *   handler results.
          */
         deliver(input, execution) {
-            execution.signal.throwIfAborted();
-            const state = synchronous(createState(input, execution), 'Delivery state creation must be synchronous');
-            const context = {
-                ...execution,
-                signal: execution.signal,
-                diagnostics: execution.diagnostics,
-                app: input,
-            };
-            for (const stage of stages) {
+            return nativeSubFlowSync(execution, 'delivery', 'delivery', () => {
                 execution.signal.throwIfAborted();
-                synchronous(beforeStage?.({ stageId: stage.id, state }, context), 'Delivery hooks must be synchronous');
-                execution.signal.throwIfAborted();
-                if (!stage.handle)
-                    continue;
-                const outcome = synchronous(stage.handle(state, context), 'Delivery handlers must be synchronous');
-                execution.signal.throwIfAborted();
-                if (!outcome ||
-                    !['continue', 'complete'].includes(outcome.type) ||
-                    (outcome.type === 'complete' && !('value' in outcome)))
-                    throw new TypeError('Delivery handlers require explicit continue/complete');
-                if (outcome.type === 'complete') {
-                    const value = outcome.value;
+                const state = synchronous(createState(input, execution), 'Delivery state creation must be synchronous');
+                const context = {
+                    ...execution,
+                    signal: execution.signal,
+                    diagnostics: execution.diagnostics,
+                    app: input,
+                };
+                for (const stage of stages) {
+                    execution.signal.throwIfAborted();
+                    synchronous(beforeStage?.({ stageId: stage.id, state }, context), 'Delivery hooks must be synchronous');
+                    execution.signal.throwIfAborted();
+                    if (!stage.handle)
+                        continue;
+                    const outcome = synchronous(stage.handle(state, context), 'Delivery handlers must be synchronous');
                     execution.signal.throwIfAborted();
-                    return value;
+                    if (!outcome ||
+                        !['continue', 'complete'].includes(outcome.type) ||
+                        (outcome.type === 'complete' && !('value' in outcome)))
+                        throw new TypeError('Delivery handlers require explicit continue/complete');
+                    if (outcome.type === 'complete') {
+                        const value = outcome.value;
+                        execution.signal.throwIfAborted();
+                        return value;
+                    }
                 }
-            }
-            throw synchronous(missingResult(), 'Delivery errors must be synchronous');
+                throw synchronous(missingResult(), 'Delivery errors must be synchronous');
+            });
         },
     });
 }

package/dist/esm/kits/domains/catalog.d.ts

@@ -0,0 +1,42 @@
+import type { ModelTool } from '../../structs/capabilities/model.js';
+import type { AgentCatalogPorts, CatalogGoal, CatalogScope } from '../../structs/kits/domains/catalog.js';
+/**
+ * Compile a catalog projection over the App's live registries.
+ *
+ * The actual registries determine availability and relationships. No parallel capability list
+ * exists: `goalIds` filters by tool support, `modelCatalog` narrows to the currently accepted
+ * task when `restrictToTask` is enabled, and scope tool ids are filtered to tools that exist.
+ *
+ * @param ports - Sources for Tool ids, goals, scopes, the current task, the tool registry
+ *   and the `restrictToTask` switch.
+ * @returns A frozen projection with `goalIds`, `goalDelegates`, `goalCatalog`,
+ *   `scopeCatalog` and `modelCatalog`.
+ * @throws TypeError When a supplied predicate does not return a boolean synchronously.
+ */
+export declare function defineAgentCatalog<App, Id extends string, Goal extends CatalogGoal<Id>, Scope extends CatalogScope>(ports: AgentCatalogPorts<App, Id, Goal, Scope>): Readonly<{
+    goalIds: (app: App) => Id[];
+    goalDelegates: (app?: App) => Map<Id, string[]>;
+    goalCatalog: (app: App) => (Omit<Goal & Partial<ModelTool<unknown, unknown, App>>, "resolve" | "inputSchema" | "active" | "asIntent"> & {
+        delegates: string[];
+        scopeIds: string[];
+        toolIds: string[];
+        description?: string | undefined;
+    })[];
+    scopeCatalog: (app: App) => (Scope & {
+        toolIds: string[];
+    })[];
+    modelCatalog(app: App): {
+        availableGoalIds: (Goal & Partial<ModelTool<unknown, unknown, App>>)["id"][];
+        availableGoals: (Omit<Goal & Partial<ModelTool<unknown, unknown, App>>, "resolve" | "inputSchema" | "active" | "asIntent"> & {
+            delegates: string[];
+            scopeIds: string[];
+            toolIds: string[];
+            description?: string | undefined;
+        })[];
+        availableScopes: (Scope & {
+            toolIds: string[];
+        })[];
+        availableTools: import("./catalog.js").DescribedTool[];
+    };
+}>;
+export type * from '../../structs/kits/domains/catalog.js';

package/dist/esm/kits/domains/catalog.js

@@ -0,0 +1,110 @@
+/**
+ * Domain Tools Kit: project registered goals, scopes and tools into one task-facing catalog.
+ *
+ * Place in the package: part of the domain Tool Kit. It reads the actual registries supplied by
+ * the App instead of maintaining a parallel capability list, so an intent is only advertised
+ * when its tools, scopes and availability agree.
+ *
+ * Exports: `defineAgentCatalog`, and the catalog intent/scope/port types.
+ */
+import { booleanResult } from '../../utils/synchronous.js';
+import { toolActive } from '../../capabilities/tool-conditions.js';
+/**
+ * Compile a catalog projection over the App's live registries.
+ *
+ * The actual registries determine availability and relationships. No parallel capability list
+ * exists: `goalIds` filters by tool support, `modelCatalog` narrows to the currently accepted
+ * task when `restrictToTask` is enabled, and scope tool ids are filtered to tools that exist.
+ *
+ * @param ports - Sources for Tool ids, goals, scopes, the current task, the tool registry
+ *   and the `restrictToTask` switch.
+ * @returns A frozen projection with `goalIds`, `goalDelegates`, `goalCatalog`,
+ *   `scopeCatalog` and `modelCatalog`.
+ * @throws TypeError When a supplied predicate does not return a boolean synchronously.
+ */
+export function defineAgentCatalog(ports) {
+    const ids = ports.goalIds.bind(ports), goals = ports.goals.bind(ports), scopes = ports.scopes.bind(ports), task = ports.currentTask.bind(ports);
+    const tools = {
+        values: ports.tools.values.bind(ports.tools),
+        has: ports.tools.has.bind(ports.tools),
+        supports: ports.tools.supportsGoal.bind(ports.tools),
+        describe: ports.tools.describe.bind(ports.tools),
+    };
+    const restrict = ports.restrictToTask !== false;
+    const boolean = (value) => booleanResult(value, 'Catalog predicates must be synchronous', 'Catalog predicates must return boolean');
+    /** Whether one goal is active and its demand metadata currently participates. */
+    const goalAvailable = (goal, app) => {
+        const tool = goal;
+        if (!toolActive(tool.active, app))
+            return false;
+        const metadata = tool.asIntent;
+        if (metadata === undefined || metadata === true || typeof metadata === 'string')
+            return true;
+        if (typeof metadata === 'function')
+            return toolActive(metadata, app);
+        return toolActive(metadata.when, app);
+    };
+    const goalIds = (app) => ids(app).filter((id) => boolean(tools.supports(id, app)));
+    const goalDelegates = (app) => new Map(goals().map((goal) => {
+        const metadata = goal.asIntent;
+        const explicit = typeof metadata === 'object' ? metadata.delegates : undefined;
+        return [
+            goal.id,
+            explicit
+                ? [...explicit]
+                : [
+                    ...new Set([
+                        ...goal.delegates,
+                        ...[...tools.values()]
+                            .filter((tool) => tool.lifecycle?.id &&
+                            (app === undefined || toolActive(tool.active, app)) &&
+                            (tool.goalIds === 'all' || tool.goalIds.includes(goal.id)))
+                            .map((tool) => tool.lifecycle.id),
+                    ]),
+                ],
+        ];
+    }));
+    const goalCatalog = (app) => {
+        const selected = goalIds(app), described = tools.describe('model', app), delegates = goalDelegates(app);
+        return goals(selected)
+            .filter((goal) => goalAvailable(goal, app))
+            .map((goal) => {
+            const { inputSchema: _schema, resolve: _resolve, active: _active, asIntent: _asIntent, ...metadata } = goal;
+            const demandDescription = typeof _asIntent === 'string'
+                ? _asIntent
+                : typeof _asIntent === 'object' && _asIntent !== null
+                    ? _asIntent.description
+                    : undefined;
+            return {
+                ...metadata,
+                ...(demandDescription ? { description: demandDescription } : {}),
+                delegates: delegates.get(goal.id) ?? [...goal.delegates],
+                scopeIds: scopes([goal.id]).map((scope) => scope.id),
+                toolIds: described
+                    .filter((tool) => tool.goalIds.includes(goal.id))
+                    .map((tool) => tool.id),
+            };
+        });
+    };
+    const scopeCatalog = (app) => scopes(goalCatalog(app).map((goal) => goal.id)).map((scope) => ({
+        ...scope,
+        toolIds: scope.toolIds.filter(tools.has),
+    }));
+    return Object.freeze({
+        goalIds,
+        goalDelegates,
+        goalCatalog,
+        scopeCatalog,
+        modelCatalog(app) {
+            const accepted = restrict ? task(app) : undefined, selected = goalIds(app).filter((id) => !accepted || id === accepted.goalId), available = goalCatalog(app).filter((intent) => selected.includes(intent.id));
+            return {
+                availableGoalIds: available.map((intent) => intent.id),
+                availableGoals: available.map((intent) => accepted ? { ...intent, scopeIds: accepted.scopeId ? [accepted.scopeId] : [] } : intent),
+                availableScopes: scopeCatalog(app).filter((scope) => !accepted || scope.id === accepted.scopeId),
+                availableTools: tools
+                    .describe('model', app)
+                    .filter((tool) => !accepted || tool.goalIds.includes(accepted.goalId)),
+            };
+        },
+    });
+}

package/dist/esm/kits/domains/index.d.ts

@@ -0,0 +1,4 @@
+/** Optional domain Tool constraints, scope registries and task-facing projections. */
+export * from './registry.js';
+export * from './scopes.js';
+export * from './catalog.js';

package/dist/esm/kits/domains/index.js

@@ -0,0 +1,4 @@
+/** Optional domain Tool constraints, scope registries and task-facing projections. */
+export * from './registry.js';
+export * from './scopes.js';
+export * from './catalog.js';

package/dist/esm/kits/domains/registry.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Domain Tools Kit: an ordered, sealable registry of domain Tool declarations.
+ *
+ * Place in the package: part of the domain Tool Kit. Goal semantics and the allowed vocabulary
+ * (scope modes, target modes, context tiers, delegates, actions) are App configuration; this class
+ * owns the common lifecycle — validation, ordering, duplicate detection and sealing.
+ *
+ * Exports: `IntentRegistry`, `createIntentRegistry`, and the domain Tool registry types.
+ */
+import type { IntentTool, IntentToolRegistration, IntentDescription, IntentPolicy, IntentId, RegisteredIntent } from '../../structs/kits/domains/registry.js';
+import { ModelToolRegistry } from '../../capabilities/model.js';
+/**
+ * Goal semantics and allowed values are configuration; the registry owns their common lifecycle.
+ *
+ * Registration order is preserved by `ids`, `definitions`, `values` and `entries`; once
+ * `seal()` is called the set is final and further registration is rejected.
+ */
+export declare class IntentRegistry<Definition extends IntentToolRegistration = IntentToolRegistration> {
+    /** Create and seal a complete catalog in one call. */
+    static readonly create: typeof createIntentRegistry;
+    private readonly byId;
+    private sealed;
+    private modelView?;
+    private readonly policy;
+    /**
+     * @param policy - Optional id pattern, vocabulary lists, error wording and assertion hook.
+     *   Lists and the pattern are copied so later mutation of the input cannot weaken checks.
+     */
+    constructor(policy?: IntentPolicy<Definition>);
+    /**
+     * Validate, freeze and add one domain Tool.
+     *
+     * Checks run in a fixed order — sealed, identity, context contract, auxiliary actions,
+     * handoff, plan, delegates — so the reported violation is stable when several rules fail.
+     *
+     * @param input - Goal declaration; the App's own assertion receives this original object,
+     *   not the compiled copy, so helpers and prototype methods keep working.
+     * @returns This registry, for chaining.
+     * @throws A configured error for a sealed registry, invalid identity or vocabulary values,
+     *   empty/duplicate delegates, or a duplicate Tool id.
+     */
+    register(input: Definition): this;
+    /** Register every domain Tool in iteration order. */
+    registerAll(definitions: Iterable<Definition>): this;
+    /** Registered domain Tool for `id`, or `undefined` when it is absent. */
+    get(goal: string): RegisteredIntent<Definition> | undefined;
+    /** Whether a Tool id is registered. */
+    has(goal: string): boolean;
+    /** Registered Tool ids in registration order. */
+    ids(): readonly IntentId<Definition>[];
+    /** Registered goals in registration order. */
+    get definitions(): readonly RegisteredIntent<Definition>[];
+    /** Iterate the registered goals. */
+    values(): MapIterator<Readonly<Omit<Readonly<IntentTool & import("../../utils/registration.js").RegistrationData<Definition> & Pick<Definition, Extract<keyof Definition, keyof IntentTool>>>, "resolve" | "inputSchema" | "delegates" | "auxiliaryActions"> & import("../../index.js").ModelTool<any, any, any> & { readonly [Key in keyof Pick<Definition, Extract<keyof Definition, "delegates" | "auxiliaryActions">>]: Readonly<Definition[Key]>; } & {
+        id: Definition["id"];
+        delegates: Readonly<NonNullable<Definition["delegates"]>>;
+    }>>;
+    /** Demand discovery uses tool metadata; domain fields remain attached to these same IDs. */
+    withIntent(context: unknown): ModelToolRegistry;
+    /** Resolve a grouped transport's selected Tool through that Tool's own parser and resolver. */
+    resolve(selection: import('../../structs/capabilities/model.js').ModelSelection, context: Readonly<{
+        stageId: string;
+    }>): unknown;
+    /** Explicit node selection uses the same immutable model projection. */
+    select(ids: readonly string[], ...context: [] | [unknown]): ModelToolRegistry;
+    /** Cache only immutable declarations; request activation is evaluated by each projection. */
+    private models;
+    /** Iterate `[id, tool]` pairs. */
+    entries(): MapIterator<[string, Readonly<Omit<Readonly<IntentTool & import("../../utils/registration.js").RegistrationData<Definition> & Pick<Definition, Extract<keyof Definition, keyof IntentTool>>>, "resolve" | "inputSchema" | "delegates" | "auxiliaryActions"> & import("../../index.js").ModelTool<any, any, any> & { readonly [Key in keyof Pick<Definition, Extract<keyof Definition, "delegates" | "auxiliaryActions">>]: Readonly<Definition[Key]>; } & {
+        id: Definition["id"];
+        delegates: Readonly<NonNullable<Definition["delegates"]>>;
+    }>]>;
+    /**
+     * Registered domain Tool for `id`.
+     *
+     * @throws TypeError When the id is not registered.
+     */
+    require(id: string): RegisteredIntent<Definition>;
+    /** Whether the Tool declares this delegate; unknown goals allow nothing. */
+    allows(goal: string, delegate: string): boolean;
+    /**
+     * Copy the selected goals out of the registry.
+     *
+     * @param goals - Ids to include; the default is every registered id, in registry order.
+     * @returns Descriptions whose arrays are copied so callers cannot mutate registry state.
+     */
+    describe(goals?: readonly string[]): IntentDescription<Definition>[];
+    /** Finalize the registry; no registration is accepted afterwards. */
+    seal(): this;
+}
+/**
+ * Create and seal a complete catalog; use the constructor for incremental installation.
+ *
+ * @param definitions - Goal declarations registered in iteration order.
+ * @param policy - Optional registry policy forwarded to the constructor.
+ * @returns A sealed registry.
+ * @throws A configured error for the first invalid or duplicate declaration.
+ */
+export declare function createIntentRegistry<Definition extends IntentToolRegistration>(definitions: Iterable<Definition>, policy?: IntentPolicy<Definition>): IntentRegistry<Definition>;
+export type { IntentTool, IntentToolRegistration, IntentDescription, IntentPolicy, IntentId, RegisteredIntent, } from '../../structs/kits/domains/registry.js';