@try-works/dsh-tool-mode 0.5.44 → 0.5.46

package/lib/index.js

@@ -44,6 +44,8 @@ import { captureToolSchemaSnapshot, describePlanningRejections, filterPlanningLi
 import { discoverExtension, loadExtensionModule, resolveDeclarativeImplementations, resolveExtensionEntry } from '@try-works/tool-mode-extension-sdk';
 import { ExtensionStore, ExtensionLifecycle } from '@try-works/tool-mode-extension-sdk';
 import { authorizeTool, createGrant } from "./authority.js";
+import { isModelRuntimeRecipe, parseModelRuntimeRecipe } from "./model-runtime-recipe.js";
+import { createModelRuntimeTool } from "./model-runtime-lane.js";
 import { ProviderBridge } from "./provider-bridge.js";
 import { createUpdateHostSurface } from "./update-surface.js";
 import { SubscriptionRegistry, deliverCatalogChange, MemoryDeliverySink } from "./mcp/subscriptions.js";
@@ -4518,16 +4520,93 @@ export async function apply(ctx, config = {}) {
                         // catalogue binds it, and there is nothing to register.
                         return () => { };
                     }
-                    if (harnessProvider === undefined && config.harnessProfiles === undefined) {
-                        throw new Error(`${contribution.extensionId} is declarative and its recipes resolved, but they cannot be served: `
-                            + 'this deployment composes no harness LlmProvider, so a declarative package\'s recipes '
-                            + 'cannot be executed. Set config.harnessModel (or supply harnessProvider/harnessProfiles) to serve them.');
-                    }
+                    /**
+                     * THE RECIPES ARE RESOLVED BEFORE ANY PROVIDER DECISION, because their `kind`
+                     * decides which lane serves them (docs/runtime/PHASE2.md).
+                     *
+                     * The harness lane needs a composed `LlmProvider`; the model-runtime lane must NOT
+                     * (its engine is a factory the package ships and the recipe names). Checking for a
+                     * harness provider first — which is what this function did before the lane existed —
+                     * would refuse a model-runtime package for lacking something it never needs.
+                     */
                     const resolved = resolveDeclarativeImplementations(record.installPath, manifest.implementations ?? []);
                     if (!resolved.ok) {
                         throw new Error(`${contribution.extensionId} is declarative but its recipe could not be resolved: `
                             + `${resolved.id} — ${resolved.detail}`);
                     }
+                    const rawEntry = resolved.resolved.find(entry => entry.id === contribution.name);
+                    if (rawEntry === undefined)
+                        return () => { };
+                    /**
+                     * THE MODEL-RUNTIME LANE (AT-25, ARCH-02).
+                     *
+                     * A `kind: "model-runtime"` recipe is served WITHOUT a harness model: the host
+                     * parses the recipe, resolves the provider factory FROM THE EXTENSION'S OWN PACKAGE
+                     * (never from the host's module graph, which is why the host can declare no engine),
+                     * and registers the tool the recipe names with the recipe's schema files.
+                     *
+                     * Every failure here is a NAMED refusal thrown from registration, so a package that
+                     * cannot run is quarantined rather than published as a tool that fails at call time.
+                     */
+                    if (isModelRuntimeRecipe(rawEntry.recipe)) {
+                        const parsedRecipe = parseModelRuntimeRecipe(rawEntry.recipe);
+                        if (!parsedRecipe.ok) {
+                            throw new Error(`${contribution.extensionId} declares a model-runtime recipe for ${contribution.name} that did not validate: `
+                                + `${parsedRecipe.code} — ${parsedRecipe.detail}`);
+                        }
+                        /**
+                         * The authority is the SAME one the extension-tool path uses, so a model-runtime
+                         * provider resolves caller paths through the host's grants rather than opening
+                         * whatever it is handed (SEC-06).
+                         */
+                        const authority = createInvocationAuthority(grant, 'interactive');
+                        const lane = createModelRuntimeTool({
+                            extensionId: contribution.extensionId,
+                            implementationId: contribution.name,
+                            installPath: record.installPath,
+                            recipe: parsedRecipe.recipe,
+                            assets: () => prepareAssetsSurface?.assetMapFor(contribution.extensionId) ?? { assetIds: [], get: () => undefined },
+                            invocationContext: exec => ({
+                                invocationId: `inv_${Date.now().toString(36)}_${Math.floor(Math.random() * 1e6).toString(36)}`,
+                                signal: exec?.signal ?? new AbortController().signal,
+                                limits: authority.limits,
+                                resolvePath: candidate => authority.resolvePath(candidate),
+                            }),
+                            onError: message => ctx.logger.warn(`model-tools: ${message}`),
+                        });
+                        if (!lane.ok) {
+                            throw new Error(`${contribution.extensionId} declares a model-runtime recipe for ${contribution.name} that cannot be served: `
+                                + `${lane.code} — ${lane.detail}`);
+                        }
+                        const disposeTool = ctx.tools.register(defineTool({
+                            name: lane.tool.name,
+                            description: lane.tool.description,
+                            parameters: lane.tool.parameters,
+                            output: {
+                                schema: { type: 'json' },
+                                render: (_args, value) => [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+                            },
+                            async execute(args, exec) {
+                                return await lane.tool.execute(args, exec);
+                            },
+                        }));
+                        exposeExtensionToolToMcp(lane.tool.name, {
+                            description: lane.tool.description,
+                            inputSchema: lane.tool.inputSchema,
+                            outputSchema: lane.tool.outputSchema,
+                        });
+                        return () => {
+                            // Withdraw first so no new call can start, then release the provider.
+                            withdrawExtensionToolFromMcp(lane.tool.name);
+                            disposeTool();
+                            void lane.tool.dispose();
+                        };
+                    }
+                    if (harnessProvider === undefined && config.harnessProfiles === undefined) {
+                        throw new Error(`${contribution.extensionId} is declarative and its recipes resolved, but they cannot be served: `
+                            + 'this deployment composes no harness LlmProvider, so a declarative package\'s recipes '
+                            + 'cannot be executed. Set config.harnessModel (or supply harnessProvider/harnessProfiles) to serve them.');
+                    }
                     const served = prepareDeclarative({
                         ...harnessProvider === undefined ? {} : { provider: harnessProvider },
                         ...config.harnessProfiles === undefined ? {} : { profiles: config.harnessProfiles },
@@ -4537,9 +4616,6 @@ export async function apply(ctx, config = {}) {
                         throw new Error(`${contribution.extensionId} is declarative and its ${resolved.resolved.length} recipe(s) resolved, `
                             + `but they cannot be served: ${served.detail}`);
                     }
-                    const rawEntry = resolved.resolved.find(entry => entry.id === contribution.name);
-                    if (rawEntry === undefined)
-                        return () => { };
                     const parsed = parseRecipe(rawEntry.recipe);
                     if (!parsed.ok) {
                         throw new Error(`${contribution.extensionId} declares a recipe that did not validate: ${JSON.stringify(parsed).slice(0, 300)}`);

package/lib/model-runtime-lane.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The host lane that turns a parsed `model-runtime` recipe into a callable tool
+ * (docs/runtime/PHASE2.md § Host lane).
+ *
+ * WHAT THIS MODULE OWNS, and what it deliberately does not:
+ *
+ * - It owns the CONTRACT between the recipe and DSH: the tool's name and description, the
+ *   projection of the recipe's JSON-Schema input into what DSH can advertise, the FULL
+ *   schema enforced at call time (the projection is intentionally looser), and the output
+ *   check that stops a malformed payload from being published as a result.
+ * - It does NOT own the engine. The provider is a `ModelProviderV1` created by the factory
+ *   the recipe names, which was resolved from the extension's own package (AT-25).
+ *
+ * TIMING IS PART OF THE DESIGN. Creating a tool resolves the provider module but does not
+ * import or run it; the import and the provider's `load` happen on the FIRST CALL. That keeps
+ * activation lightweight (EXT-19) while still refusing — at registration — a package whose
+ * engine is not installed, because resolution is synchronous.
+ *
+ * @module @try-works/dsh-tool-mode/model-runtime-lane
+ */
+import type { InvocationContextV1, PreparedAssetMapV1 } from '@try-works/tool-mode-extension-sdk';
+import { type ModelRuntimeRecipe, type ModelRuntimeRefusal } from './model-runtime-recipe.ts';
+/** What the host hands the lane when it registers one implementation's tool. */
+export interface ModelRuntimeToolDeps {
+    /** The extension that owns the tool, for diagnostics. */
+    readonly extensionId: string;
+    /** The implementation id the recipe belongs to (the manifest's, not the tool name). */
+    readonly implementationId: string;
+    /** The installed package directory. */
+    readonly installPath: string;
+    /** The parsed recipe. */
+    readonly recipe: ModelRuntimeRecipe;
+    /** The host-verified prepared assets for this extension; empty until prepared. */
+    readonly assets: () => Readonly<PreparedAssetMapV1>;
+    /** Build the call-scoped context the SDK contract requires. */
+    readonly invocationContext: (exec: {
+        readonly signal?: AbortSignal;
+    } | undefined) => InvocationContextV1;
+    /** Record a teardown failure without throwing out of a disposer. */
+    readonly onError?: (message: string) => void;
+}
+/** A registered tool's host-side half: what DSH advertises and what it runs. */
+export interface ModelRuntimeToolHandle {
+    readonly name: string;
+    readonly description: string;
+    /** The DSH-advertisable parameters projected from the recipe's input schema. */
+    readonly parameters: Readonly<Record<string, unknown>>;
+    /** The recipe's own input schema, for the MCP advertisement (enforced in full above). */
+    readonly inputSchema: Readonly<Record<string, unknown>>;
+    /** The recipe's own output schema, for the MCP advertisement. */
+    readonly outputSchema: Readonly<Record<string, unknown>>;
+    readonly execute: (args: unknown, exec?: {
+        readonly signal?: AbortSignal;
+    }) => Promise<unknown>;
+    readonly dispose: () => Promise<void>;
+}
+/** The lane's outcome: a tool, or a named refusal the host turns into a refusal at registration. */
+export type ModelRuntimeToolResult = {
+    readonly ok: true;
+    readonly tool: ModelRuntimeToolHandle;
+} | ModelRuntimeRefusal;
+/**
+ * Build the tool for one model-runtime implementation.
+ *
+ * @param deps - the installed package, the parsed recipe and the host's context/asset hooks.
+ * @returns the tool handle or a named refusal.
+ */
+export declare function createModelRuntimeTool(deps: ModelRuntimeToolDeps): ModelRuntimeToolResult;
+//# sourceMappingURL=model-runtime-lane.d.ts.map

package/lib/model-runtime-lane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-runtime-lane.d.ts","sourceRoot":"","sources":["../src/model-runtime-lane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAA+B,kBAAkB,EAAE,MAAM,oCAAoC,CAAA;AAE9H,OAAO,EAIL,KAAK,kBAAkB,EAEvB,KAAK,mBAAmB,EACzB,MAAM,2BAA2B,CAAA;AAElC,gFAAgF;AAChF,MAAM,WAAW,oBAAoB;IACnC,yDAAyD;IACzD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,uFAAuF;IACvF,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,uCAAuC;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,yBAAyB;IACzB,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAA;IACnC,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,MAAM,QAAQ,CAAC,kBAAkB,CAAC,CAAA;IACnD,+DAA+D;IAC/D,QAAQ,CAAC,iBAAiB,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,SAAS,KAAK,mBAAmB,CAAA;IACxG,oEAAoE;IACpE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAC7C;AAED,gFAAgF;AAChF,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACtD,yFAAyF;IACzF,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACvD,iEAAiE;IACjE,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACxD,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC/F,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACtC;AAED,oGAAoG;AACpG,MAAM,MAAM,sBAAsB,GAC9B;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAA;CAAE,GAC5D,mBAAmB,CAAA;AASvB;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,oBAAoB,GAAG,sBAAsB,CAkFzF"}

package/lib/model-runtime-lane.js

@@ -0,0 +1,122 @@
+/**
+ * The host lane that turns a parsed `model-runtime` recipe into a callable tool
+ * (docs/runtime/PHASE2.md § Host lane).
+ *
+ * WHAT THIS MODULE OWNS, and what it deliberately does not:
+ *
+ * - It owns the CONTRACT between the recipe and DSH: the tool's name and description, the
+ *   projection of the recipe's JSON-Schema input into what DSH can advertise, the FULL
+ *   schema enforced at call time (the projection is intentionally looser), and the output
+ *   check that stops a malformed payload from being published as a result.
+ * - It does NOT own the engine. The provider is a `ModelProviderV1` created by the factory
+ *   the recipe names, which was resolved from the extension's own package (AT-25).
+ *
+ * TIMING IS PART OF THE DESIGN. Creating a tool resolves the provider module but does not
+ * import or run it; the import and the provider's `load` happen on the FIRST CALL. That keeps
+ * activation lightweight (EXT-19) while still refusing — at registration — a package whose
+ * engine is not installed, because resolution is synchronous.
+ *
+ * @module @try-works/dsh-tool-mode/model-runtime-lane
+ */
+import { assertAgainstSchema, compileSchema, projectSchemaToDsh } from '@try-works/tool-mode-contracts';
+import { importProviderFactory, readModelRuntimeSchema, resolveProviderModule, } from "./model-runtime-recipe.js";
+/** DSH tool arguments are JSON; this only satisfies the index-signature boundary type. */
+function asJsonObject(value) {
+    // SAFETY: the arguments arrived from the DSH registry (JSON by construction) and were just
+    // validated against the recipe's schema, so a JSON round-trip is lossless.
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * Build the tool for one model-runtime implementation.
+ *
+ * @param deps - the installed package, the parsed recipe and the host's context/asset hooks.
+ * @returns the tool handle or a named refusal.
+ */
+export function createModelRuntimeTool(deps) {
+    const inputSchema = readModelRuntimeSchema(deps.installPath, deps.recipe.tool.inputSchema);
+    if (!inputSchema.ok)
+        return inputSchema;
+    const outputSchema = readModelRuntimeSchema(deps.installPath, deps.recipe.tool.outputSchema);
+    if (!outputSchema.ok)
+        return outputSchema;
+    // Resolve (not import) the engine now: a package whose factory is missing is refused at
+    // registration rather than at the first caller's expense.
+    const providerModule = resolveProviderModule({ installPath: deps.installPath, recipe: deps.recipe });
+    if (!providerModule.ok)
+        return providerModule;
+    const name = deps.recipe.tool.name;
+    const inputValidator = compileSchema(inputSchema.schema);
+    const outputValidator = compileSchema(outputSchema.schema);
+    const parameters = projectSchemaToDsh(inputSchema.schema).parameters;
+    let factoryPromise;
+    let providerPromise;
+    let disposed = false;
+    /** Import the factory once; a failure is retried on the next call rather than cached forever. */
+    const ensureFactory = async () => {
+        factoryPromise ??= (async () => {
+            const imported = await importProviderFactory({ installPath: deps.installPath, recipe: deps.recipe });
+            if (!imported.ok)
+                throw new Error(`${imported.code}: ${imported.detail}`);
+            return imported.factory;
+        })();
+        return factoryPromise;
+    };
+    /** Create and LOAD the provider once; a failed load is retried rather than reported as ready. */
+    const ensureProvider = async (signal) => {
+        providerPromise ??= (async () => {
+            const factory = await ensureFactory();
+            const assets = deps.assets();
+            const provider = factory(deps.recipe, assets);
+            await provider.load({ assets, signal: signal ?? new AbortController().signal });
+            return provider;
+        })();
+        const pending = providerPromise;
+        pending.catch(() => {
+            if (providerPromise === pending)
+                providerPromise = undefined;
+        });
+        return pending;
+    };
+    return {
+        ok: true,
+        tool: {
+            name,
+            description: deps.recipe.tool.description,
+            parameters,
+            inputSchema: inputSchema.schema,
+            outputSchema: outputSchema.schema,
+            async execute(args, exec) {
+                if (disposed)
+                    throw new Error(`${name}: the owning extension was disposed`);
+                // The FULL schema, before any engine work: the DSH advertisement is a projection.
+                assertAgainstSchema(`${name} input`, inputValidator, args ?? {});
+                const provider = await ensureProvider(exec?.signal);
+                const payload = await provider.invoke({
+                    implementationId: deps.implementationId,
+                    input: asJsonObject(args ?? {}),
+                    context: deps.invocationContext(exec),
+                });
+                assertAgainstSchema(`${name} output`, outputValidator, payload);
+                return payload;
+            },
+            async dispose() {
+                if (disposed)
+                    return;
+                disposed = true;
+                const pending = providerPromise;
+                providerPromise = undefined;
+                if (pending === undefined)
+                    return;
+                try {
+                    const provider = await pending;
+                    await provider.dispose();
+                }
+                catch (error) {
+                    // A disposer must not throw: deactivation continues, and the reason is recorded.
+                    deps.onError?.(`${deps.extensionId}: ${name} teardown failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
+        },
+    };
+}
+//# sourceMappingURL=model-runtime-lane.js.map

package/lib/model-runtime-recipe.d.ts

@@ -0,0 +1,132 @@
+/**
+ * The `model-runtime` recipe: parsing, schema files and the provider factory binding
+ * (docs/runtime/PHASE2.md).
+ *
+ * WHY THE HOST OWNS THE PARSER. The recipe decides what the host will register and which
+ * module it will import, so it is a TRUST BOUNDARY. Validating it with code imported from
+ * the extension would let the extension define what counts as valid; importing a dedicated
+ * runtime-recipes package would put a Phase-2 runtime package in the host's dependency
+ * graph, which AT-25 and ARCH-02 exist to prevent. The rules are therefore structural and
+ * live here: data only, no engine, no model, no vendor SDK.
+ *
+ * WHAT THE HOST DOES DELEGATE — and the whole point of the recipe — is the ENGINE. The
+ * factory is resolved with `createRequire` anchored at the EXTENSION's own package.json, so
+ * a provider package that the extension installed is found, and one that only the host
+ * happens to have is not treated as available. The host declares no runtime; the package
+ * ships one and names it.
+ *
+ * @module @try-works/dsh-tool-mode/model-runtime-recipe
+ */
+import type { ModelProviderV1, PreparedAssetMapV1 } from '@try-works/tool-mode-extension-sdk';
+/** The accelerators a recipe may request; the host decides which are actually available. */
+export type ModelRuntimeAccelerator = 'cpu' | 'dml' | 'webgpu';
+/** The artifact formats the lane knows how to name. */
+export type ModelRuntimeFormat = 'onnx' | 'tflite' | 'gguf';
+/** A parsed, validated `model-runtime` recipe. */
+export interface ModelRuntimeRecipe {
+    readonly kind: 'model-runtime';
+    readonly schemaVersion: 1;
+    readonly provider: {
+        readonly package: string;
+        readonly export: string;
+        readonly accelerators?: readonly ModelRuntimeAccelerator[];
+    };
+    readonly model: {
+        readonly assetSet: string;
+        readonly fileName: string;
+        readonly format: ModelRuntimeFormat;
+    };
+    readonly processor: {
+        readonly id: string;
+    };
+    readonly limits: {
+        readonly maxInputBytes: number;
+        readonly timeoutMs: number;
+    };
+    readonly tool: {
+        readonly name: string;
+        readonly description: string;
+        readonly inputSchema: string;
+        readonly outputSchema: string;
+    };
+}
+/** Why a recipe or its binding was refused. Each is a NAMED refusal, never a silent no-op. */
+export type ModelRuntimeRefusalCode = 'not-model-runtime' | 'unknown-key' | 'bad-schema-version' | 'bad-provider' | 'bad-model' | 'bad-processor' | 'bad-limits' | 'bad-tool' | 'schema-unreadable' | 'factory-unresolved' | 'factory-import-failed' | 'factory-not-function';
+/** A refusal with the exact reason the operator needs. */
+export interface ModelRuntimeRefusal {
+    readonly ok: false;
+    readonly code: ModelRuntimeRefusalCode;
+    readonly detail: string;
+}
+/** A parsed recipe, or a refusal. */
+export type ModelRuntimeRecipeResult = {
+    readonly ok: true;
+    readonly recipe: ModelRuntimeRecipe;
+} | ModelRuntimeRefusal;
+/** The engine binding a recipe names. */
+export type ModelRuntimeProviderFactory = (recipe: ModelRuntimeRecipe, assets: Readonly<PreparedAssetMapV1>) => ModelProviderV1;
+/**
+ * Whether an unvalidated recipe claims to be a `model-runtime` recipe.
+ *
+ * The host branches on this BEFORE any harness behaviour: a harness recipe (or one with no
+ * `kind`) keeps the existing path untouched.
+ * @param raw - the recipe as read from disk.
+ * @returns whether this is the model-runtime lane's business.
+ */
+export declare function isModelRuntimeRecipe(raw: unknown): boolean;
+/**
+ * Parse and validate a `model-runtime` recipe (PHASE2 rules).
+ * @param raw - the recipe as read from disk.
+ * @returns the typed recipe or a named refusal.
+ */
+export declare function parseModelRuntimeRecipe(raw: unknown): ModelRuntimeRecipeResult;
+/** The result of reading one schema file. */
+export type ModelRuntimeSchemaResult = {
+    readonly ok: true;
+    readonly schema: Readonly<Record<string, unknown>>;
+} | ModelRuntimeRefusal;
+/**
+ * Read one package-relative schema file, refusing anything that could leave the package.
+ * @param installPath - the installed package directory.
+ * @param relative - the recipe's `./...` path.
+ * @returns the parsed schema or a named refusal.
+ */
+export declare function readModelRuntimeSchema(installPath: string, relative: string): ModelRuntimeSchemaResult;
+/** The result of resolving the recipe's provider module (a path, not an import). */
+export type ProviderModuleResult = {
+    readonly ok: true;
+    readonly resolved: string;
+} | ModelRuntimeRefusal;
+/**
+ * Resolve the recipe's provider module from the EXTENSION's own package, without importing it.
+ *
+ * Resolution is synchronous, which is what lets `registerDeclarative` — a synchronous host
+ * hook — refuse a package that cannot be resolved AT REGISTRATION, instead of registering a
+ * tool that cannot run. The import itself stays deferred to first call, so activation remains
+ * lightweight (EXT-19).
+ * @param options - the install directory and the parsed recipe.
+ * @returns the resolved module path or a named refusal.
+ */
+export declare function resolveProviderModule(options: {
+    readonly installPath: string;
+    readonly recipe: ModelRuntimeRecipe;
+}): ProviderModuleResult;
+/** The result of importing the recipe's provider factory. */
+export type ProviderFactoryResult = {
+    readonly ok: true;
+    readonly factory: ModelRuntimeProviderFactory;
+} | ModelRuntimeRefusal;
+/**
+ * Import the provider factory the recipe names, resolving from the EXTENSION's own package.
+ *
+ * The anchor is the extension's `package.json`, not the host's module graph: a package that
+ * declares an engine dependency resolves it from its own install, and the host never
+ * carries one (AT-25, ARCH-02).
+ * @param options - the install directory and the parsed recipe.
+ * @returns the factory or a named refusal.
+ */
+export declare function importProviderFactory(options: {
+    readonly installPath: string;
+    readonly recipe: ModelRuntimeRecipe;
+}): Promise<ProviderFactoryResult>;
+//# sourceMappingURL=model-runtime-recipe.d.ts.map

package/lib/model-runtime-recipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-runtime-recipe.d.ts","sourceRoot":"","sources":["../src/model-runtime-recipe.ts"],"names":[],"mappings":"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"}