@try-works/dsh-model-as-tool 0.0.0-stage → 0.1.1

package/lib/index.js

@@ -0,0 +1,391 @@
+/**
+ * dsh-model-as-tool — install on-device models as DSH tools and skills.
+ *
+ * The plugin composes five layers: a JSON catalog describing every model, a
+ * capability resolver that decides which of them can run in this process, an
+ * adapter per runnable model, a registrar that turns each one into a DSH tool,
+ * and a skill per tool that teaches the agent when to reach for it.
+ *
+ * Nothing is imported from a model package at plugin load, so a deployment that
+ * installs none of them still starts cleanly and reports exactly what is
+ * missing. A model only becomes a tool when its adapter can really invoke it.
+ *
+ * @module @try-works/dsh-model-as-tool
+ */
+import z from '@deepseek-ai/schemastery';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { loadCatalog } from "./catalog.js";
+import { resolveCapability } from "./capability.js";
+import { createAdapter } from "./adapters/index.js";
+import { registerModelTool } from "./registrar.js";
+import { renderSkillBody } from "./skills.js";
+import { loadPlaybooks } from "./playbook.js";
+import { commandExists, DEFAULT_CLI_COMMAND } from "./transport.js";
+import { createFileStateStore, createMemoryStateStore, defaultStateFile, resolveSelection, withChoice, } from "./state.js";
+export const name = 'model-tools';
+export const inject = ['tools'];
+/** Validate and default the plugin configuration. */
+export const Config = z.object({
+    catalogFile: z.string(),
+    playbookFile: z.string(),
+    stateFile: z.string(),
+    persist: z.boolean().default(true),
+    models: z.array(z.string()).default([]),
+    exclude: z.array(z.string()).default([]),
+    exposeUnavailable: z.boolean().default(false),
+    registerSkills: z.boolean().default(true),
+    registerControlTool: z.boolean().default(true),
+    cli: z.object({
+        enabled: z.boolean().default(true),
+        command: z.string().default(DEFAULT_CLI_COMMAND),
+    }),
+    remote: z.object({
+        endpoint: z.string(),
+        token: z.string(),
+    }),
+    allowNpm: z.boolean().default(true),
+});
+/** Render the model list the control tool returns, and the plugin logs. */
+function describeModels(resolved) {
+    return resolved.map(({ entry, verdict }) => ({
+        id: entry.id,
+        name: entry.name,
+        summary: entry.summary,
+        capability: entry.capability,
+        input: entry.input,
+        tool: entry.tool.name,
+        skill: entry.skill.name,
+        runnable: verdict.runnable,
+        route: verdict.route,
+        reason: verdict.reason,
+        languages: entry.languages,
+        license: entry.license,
+        docs: entry.docsUrl,
+    }));
+}
+/**
+ * Register the Desert Ant model tools and skills.
+ * @param ctx - the plugin context whose tool registry receives the definitions.
+ * @param config - deployment configuration for which models to expose.
+ */
+export function apply(ctx, config = {}) {
+    const entries = loadCatalog(config.catalogFile);
+    const playbooks = loadPlaybooks(config.playbookFile);
+    const installed = new Map();
+    // An empty allowlist means "no explicit selection" rather than "select
+    // nothing": the config schema materializes a declared array to `[]`.
+    const wanted = config.models !== undefined && config.models.length > 0
+        ? new Set(config.models)
+        : undefined;
+    const excluded = new Set(config.exclude ?? []);
+    const exposeUnavailable = config.exposeUnavailable ?? false;
+    const registerSkills = config.registerSkills ?? true;
+    // Persistence: the config states the deployment default, the store records the
+    // user's choices on top of it, so enable/disable outlives the session.
+    const persist = config.persist ?? true;
+    const stateStore = persist
+        ? createFileStateStore(config.stateFile ?? defaultStateFile())
+        : createMemoryStateStore();
+    let persisted = stateStore.read();
+    const cliCommand = config.cli?.command ?? DEFAULT_CLI_COMMAND;
+    const cliEnabled = config.cli?.enabled ?? true;
+    // Established once: probing PATH per model would repeat identical work and
+    // make the reported reasons depend on when they were read.
+    const cliAvailable = cliEnabled && commandExists(cliCommand);
+    const remoteEndpoint = config.remote?.endpoint;
+    const transportOptions = {
+        cliCommand,
+        ...remoteEndpoint !== undefined ? { endpoint: remoteEndpoint } : {},
+        ...config.remote?.token !== undefined ? { token: config.remote.token } : {},
+    };
+    const resolved = entries.map(entry => ({
+        entry,
+        verdict: resolveCapability(entry, {
+            cliAvailable,
+            remoteEndpoint,
+            ...config.allowNpm !== undefined ? { allowNpm: config.allowNpm } : {},
+        }),
+    }));
+    const byId = new Map(resolved.map(item => [item.entry.id, item]));
+    /**
+     * Register one model's tool and skill.
+     *
+     * Idempotent: registering an already-installed model is a no-op, so the
+     * control tool can call it without first checking.
+     * @param item - the resolved model to install.
+     * @returns whether the model is installed after the call.
+     */
+    const install = (item) => {
+        const { entry, verdict } = item;
+        if (installed.has(entry.id))
+            return true;
+        if (!verdict.runnable && !exposeUnavailable)
+            return false;
+        const adapter = createAdapter(entry, { route: verdict.route, ...transportOptions });
+        if (adapter === undefined) {
+            // Runnable but no adapter yet: report rather than register a dead tool.
+            ctx.logger.info(`model-tools: ${entry.name} can run here (${verdict.route}) but no adapter ships yet; skipping ${entry.tool.name}`);
+            return false;
+        }
+        const registration = registerModelTool(ctx, entry, adapter);
+        const record = { ...registration, entry };
+        if (registerSkills) {
+            const skills = ctx.get('skills');
+            if (skills !== undefined) {
+                const body = renderSkillBody(entry, playbooks.get(entry.id));
+                record.disposeSkill = skills.register({
+                    name: entry.skill.name,
+                    description: entry.skill.description,
+                    ...entry.skill.whenToUse !== undefined ? { whenToUse: entry.skill.whenToUse } : {},
+                    content: body,
+                    source: 'bundled',
+                });
+            }
+        }
+        installed.set(entry.id, record);
+        ctx.logger.info(`model-tools: registered ${entry.tool.name} for ${entry.name} (${verdict.route})`);
+        return true;
+    };
+    /**
+     * Unregister one model's tool and skill.
+     * @param modelId - the catalog id to remove.
+     * @returns whether the model was installed.
+     */
+    const uninstall = (modelId) => {
+        const record = installed.get(modelId);
+        if (record === undefined)
+            return false;
+        record.disposeSkill?.();
+        record.dispose();
+        installed.delete(modelId);
+        ctx.logger.info(`model-tools: unregistered ${record.toolName}`);
+        return true;
+    };
+    /**
+     * Record one user choice durably.
+     *
+     * A failed write is reported rather than swallowed: the caller asked for a
+     * change that is supposed to survive a restart, and quietly keeping it
+     * in-memory would make the next session silently disagree.
+     * @param modelId - the model the user acted on.
+     * @param enabled - true to turn on, false to turn off.
+     * @returns whether the choice was written to the durable store.
+     */
+    const remember = (modelId, enabled) => {
+        persisted = withChoice(persisted, modelId, enabled);
+        if (!persist)
+            return false;
+        stateStore.write(persisted);
+        return true;
+    };
+    /** The configuration's own selection, before the user's choices are layered on. */
+    const configuredIds = resolved
+        .filter(item => (wanted === undefined || wanted.has(item.entry.id)) && !excluded.has(item.entry.id))
+        .map(item => item.entry.id);
+    for (const item of resolved) {
+        const { install: selection, disabled } = resolveSelection(configuredIds, persisted);
+        if (!selection.has(item.entry.id)) {
+            if (disabled.has(item.entry.id) && item.verdict.runnable) {
+                ctx.logger.info(`model-tools: ${item.entry.name} stays uninstalled (disabled by the user)`);
+            }
+            continue;
+        }
+        // A model the user enabled that cannot run here is reported, not installed:
+        // the persisted choice is kept so it takes effect once a route appears.
+        install(item);
+    }
+    if (config.registerControlTool ?? true) {
+        ctx.tools.register(defineTool({
+            name: 'model_tools',
+            description: 'Inspect and control the on-device models available to this agent: list what each one does and whether it '
+                + 'can run on this machine, install a model\'s tool, or remove one. Installs and removals are remembered '
+                + 'across restarts. Use it before calling a model tool when unsure which one fits, to install a model the '
+                + 'user asked for, or to explain why a model is unavailable here. Models that cannot run in this process '
+                + 'report the exact reason.',
+            parameters: {
+                action: {
+                    type: 'string',
+                    required: true,
+                    enum: ['list', 'installed', 'describe', 'enable', 'disable', 'reset'],
+                    description: 'list: every catalogued model and whether it runs here. installed: only the models whose tools are '
+                        + 'registered. describe: full detail for one model. enable: install a model\'s tool and remember it. '
+                        + 'disable: remove a model\'s tool and remember it. reset: forget the remembered choice for one model, '
+                        + 'or for every model when no id is given.',
+                },
+                model: {
+                    type: 'string',
+                    description: 'Model id, required for describe, enable and disable, and optional for reset (for example "tongue" or "title").',
+                },
+            },
+            output: {
+                schema: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        models: {
+                            type: 'array',
+                            required: true,
+                            items: {
+                                type: 'object',
+                                additionalProperties: false,
+                                properties: {
+                                    id: { type: 'string', required: true },
+                                    name: { type: 'string', required: true },
+                                    summary: { type: 'string', required: true },
+                                    capability: { type: 'string', required: true },
+                                    input: { type: 'string', required: true },
+                                    tool: { type: 'string', required: true },
+                                    skill: { type: 'string', required: true },
+                                    runnable: { type: 'boolean', required: true },
+                                    installed: { type: 'boolean', required: true },
+                                    /** The user's remembered choice for this model. */
+                                    choice: { type: 'string', required: true, enum: ['none', 'enabled', 'disabled'] },
+                                    route: { type: 'string', required: true },
+                                    reason: { type: 'string', required: true },
+                                    languages: {
+                                        required: true,
+                                        oneOf: [
+                                            { type: 'integer' },
+                                            { type: 'null' },
+                                        ],
+                                    },
+                                    license: { type: 'string', required: true },
+                                    docs: { type: 'string', required: true },
+                                },
+                            },
+                        },
+                        installed: { type: 'integer', required: true },
+                        runnable: { type: 'integer', required: true },
+                        /** Set by enable/disable/reset: whether the requested change took effect. */
+                        changed: { type: 'boolean' },
+                        /** Set by enable/disable/reset: what the call did to the tool surface. */
+                        action: { type: 'string' },
+                        /** Set by enable/disable/reset: whether the choice was written to the durable store. */
+                        persisted: { type: 'boolean' },
+                        /** Where choices are stored, so a caller can tell the user what to edit. */
+                        stateFile: { type: 'string' },
+                    },
+                },
+                render: (_args, value) => {
+                    const headline = value.action !== undefined
+                        ? `${value.action}: ${value.changed === true ? 'done' : 'no change'}`
+                            + `${value.persisted === true ? ', remembered across restarts' : ''}. `
+                        : '';
+                    const lines = value.models.map(model => `- [${model.installed ? 'installed' : model.runnable ? 'ready' : 'unavailable'}] `
+                        + `${model.id} (\`${model.tool}\`)${model.choice === 'none' ? '' : ` (${model.choice} by you)`}: `
+                        + `${model.summary}`
+                        + (model.runnable || model.installed ? '' : `\n  why not: ${model.reason}`));
+                    return [{
+                            type: 'text',
+                            text: `${headline}${value.installed} of ${value.models.length} catalogued models are installed as tools; `
+                                + `${value.runnable} can run on this machine.\n\n${lines.join('\n')}`,
+                        }];
+                },
+            },
+            execute(args, exec) {
+                void exec;
+                const action = args.action;
+                const modelId = args.model;
+                /** The user's remembered choice for one model. */
+                const choiceOf = (id) => persisted.enabled.includes(id) ? 'enabled' : persisted.disabled.includes(id) ? 'disabled' : 'none';
+                /** The current snapshot, with per-model installed and remembered state. */
+                const snapshot = (items) => items.map(item => ({
+                    ...describeModels([item])[0],
+                    installed: installed.has(item.entry.id),
+                    choice: choiceOf(item.entry.id),
+                }));
+                const counts = () => ({
+                    installed: installed.size,
+                    runnable: resolved.filter(item => item.verdict.runnable).length,
+                    ...persist ? { stateFile: config.stateFile ?? defaultStateFile() } : {},
+                });
+                if (action === 'reset') {
+                    // Forgetting a choice is what makes the config authoritative again.
+                    if (modelId !== undefined) {
+                        if (!byId.has(modelId))
+                            throw new Error(`unknown model "${modelId}"`);
+                        persisted = {
+                            enabled: persisted.enabled.filter(id => id !== modelId),
+                            disabled: persisted.disabled.filter(id => id !== modelId),
+                        };
+                    }
+                    else {
+                        persisted = { enabled: [], disabled: [] };
+                    }
+                    if (persist)
+                        stateStore.write(persisted);
+                    // Re-apply the config's own selection, so a reset takes effect now
+                    // rather than only at the next start.
+                    for (const item of resolved) {
+                        if (configuredIds.includes(item.entry.id))
+                            install(item);
+                        else
+                            uninstall(item.entry.id);
+                    }
+                    const models = modelId === undefined ? resolved : [byId.get(modelId)];
+                    return Promise.resolve({
+                        models: snapshot(models),
+                        ...counts(),
+                        changed: true,
+                        action,
+                        persisted: persist,
+                    });
+                }
+                if (action === 'describe' || action === 'enable' || action === 'disable') {
+                    if (modelId === undefined)
+                        throw new Error(`${action} requires a "model" id`);
+                    const item = byId.get(modelId);
+                    if (item === undefined)
+                        throw new Error(`unknown model "${modelId}"`);
+                    if (action === 'describe') {
+                        return Promise.resolve({ models: snapshot([item]), ...counts() });
+                    }
+                    const changed = action === 'enable' ? install(item) : uninstall(modelId);
+                    if (action === 'enable' && !changed) {
+                        // Say why rather than reporting a silent no-op: the caller asked for
+                        // a tool and did not get one.
+                        throw new Error(`${item.entry.name} cannot be installed here. ${item.verdict.reason}`);
+                    }
+                    // Only remember a choice that actually took effect: persisting a
+                    // failed enable would install it silently on the next start.
+                    const remembered = remember(modelId, action === 'enable');
+                    return Promise.resolve({
+                        models: snapshot([item]),
+                        ...counts(),
+                        changed,
+                        action,
+                        persisted: remembered,
+                    });
+                }
+                const models = action === 'installed'
+                    ? snapshot(resolved.filter(item => installed.has(item.entry.id)))
+                    : snapshot(resolved);
+                return Promise.resolve({ models, ...counts() });
+            },
+            presentCall(args) {
+                return { card: 'generic', title: `Model tools: ${args.action}`, kind: 'read', rawInput: args.model ?? args.action };
+            },
+        }));
+    }
+    // The registry disposes each registration with the plugin fiber, but doing it
+    // explicitly keeps model resources (a loaded ONNX session, a cached weight
+    // file) bounded by the plugin's own lifetime rather than the process's.
+    ctx.effect(() => () => {
+        for (const record of installed.values()) {
+            record.disposeSkill?.();
+            record.dispose();
+        }
+        installed.clear();
+    }, 'model-tools teardown');
+    const runnable = resolved.filter(item => item.verdict.runnable).length;
+    ctx.logger.info(`model-tools: ${installed.size} model tool(s) registered from ${entries.length} catalogued models `
+        + `(${runnable} runnable in this process)`);
+}
+export { loadCatalog, CatalogError, DEFAULT_CATALOG_FILE } from "./catalog.js";
+export { resolveCapability, resolveCatalog, canResolve, packageSpecifier } from "./capability.js";
+export { createAdapter, ADAPTER_FACTORIES } from "./adapters/index.js";
+export { buildArgv, commandExists, createCliTransport, createRemoteTransport, parseBridgeResponse, parseCliOutcome, splitArguments, BRIDGE_PATH, DEFAULT_CLI_COMMAND, } from "./transport.js";
+export { renderSkillBody } from "./skills.js";
+export { loadPlaybooks, DEFAULT_PLAYBOOK_FILE } from "./playbook.js";
+export { createFileStateStore, createMemoryStateStore, defaultStateFile, parseState, resolveSelection, withChoice, EMPTY_STATE, StateError, } from "./state.js";
+//# sourceMappingURL=index.js.map

package/lib/playbook.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Playbooks: the per-model knowledge that turns a tool into a usable capability.
+ *
+ * A catalog entry says what a model *is*; a playbook says what it is *for* — the
+ * concrete jobs an agent should reach for it on, the jobs it should not, and how
+ * the model composes with its neighbours. Playbooks live in their own document
+ * so they can be revised without touching the catalog or the code.
+ *
+ * @module @try-works/dsh-model-as-tool/playbook
+ */
+/** The authored playbook for one model. */
+export interface ModelPlaybook {
+    /** Concrete jobs this model is the right tool for. */
+    readonly useCases: readonly string[];
+    /** Trigger conditions: when the agent should reach for this tool. */
+    readonly whenToUse: readonly string[];
+    /** Anti-triggers: when this tool is the wrong move. */
+    readonly whenNotToUse: readonly string[];
+    /** Ordered steps describing how to drive the model well. */
+    readonly workflow: readonly string[];
+    /** How this model composes with the others, by model id or tool name. */
+    readonly pairsWith: readonly string[];
+    /** Limits, cost and failure modes worth knowing before calling. */
+    readonly caveats: readonly string[];
+}
+/** Absolute path of the playbook document shipped with this package. */
+export declare const DEFAULT_PLAYBOOK_FILE: string;
+/** Raised when the playbook document is present but malformed. */
+export declare class PlaybookError extends Error {
+    readonly name = "PlaybookError";
+}
+/**
+ * Parse a playbook document into a per-model map.
+ *
+ * An absent document is not an error: playbooks are editorial content, and the
+ * skill renderer falls back to the catalog's own routing description.
+ * @param file - absolute path of the playbook document.
+ * @returns the playbooks by model id, empty when the document does not exist.
+ * @throws PlaybookError when the document exists but is not a valid playbook map.
+ */
+export declare function loadPlaybooks(file?: string): Map<string, ModelPlaybook>;
+//# sourceMappingURL=playbook.d.ts.map

package/lib/playbook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playbook.d.ts","sourceRoot":"","sources":["../src/playbook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,2CAA2C;AAC3C,MAAM,WAAW,aAAa;IAC5B,sDAAsD;IACtD,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;IACrC,uDAAuD;IACvD,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAA;IACxC,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;IACrC,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CACpC;AAED,wEAAwE;AACxE,eAAO,MAAM,qBAAqB,QAEjC,CAAA;AAED,kEAAkE;AAClE,qBAAa,aAAc,SAAQ,KAAK;IACtC,SAAkB,IAAI,mBAAkB;CACzC;AAID;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,IAAI,GAAE,MAA8B,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAiC9F"}

package/lib/playbook.js

@@ -0,0 +1,65 @@
+/**
+ * Playbooks: the per-model knowledge that turns a tool into a usable capability.
+ *
+ * A catalog entry says what a model *is*; a playbook says what it is *for* — the
+ * concrete jobs an agent should reach for it on, the jobs it should not, and how
+ * the model composes with its neighbours. Playbooks live in their own document
+ * so they can be revised without touching the catalog or the code.
+ *
+ * @module @try-works/dsh-model-as-tool/playbook
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+/** Absolute path of the playbook document shipped with this package. */
+export const DEFAULT_PLAYBOOK_FILE = fileURLToPath(new URL('../catalog/playbooks.json', import.meta.url));
+/** Raised when the playbook document is present but malformed. */
+export class PlaybookError extends Error {
+    name = 'PlaybookError';
+}
+const STRING_ARRAY_FIELDS = ['useCases', 'whenToUse', 'whenNotToUse', 'workflow', 'pairsWith', 'caveats'];
+/**
+ * Parse a playbook document into a per-model map.
+ *
+ * An absent document is not an error: playbooks are editorial content, and the
+ * skill renderer falls back to the catalog's own routing description.
+ * @param file - absolute path of the playbook document.
+ * @returns the playbooks by model id, empty when the document does not exist.
+ * @throws PlaybookError when the document exists but is not a valid playbook map.
+ */
+export function loadPlaybooks(file = DEFAULT_PLAYBOOK_FILE) {
+    let text;
+    try {
+        text = readFileSync(file, 'utf8');
+    }
+    catch {
+        return new Map();
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        throw new PlaybookError(`${file} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new PlaybookError(`${file} must contain a JSON object keyed by model id`);
+    }
+    const playbooks = new Map();
+    for (const [modelId, raw] of Object.entries(parsed)) {
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+            throw new PlaybookError(`${file}: playbook for "${modelId}" must be an object`);
+        }
+        const record = raw;
+        const playbook = {};
+        for (const field of STRING_ARRAY_FIELDS) {
+            const value = record[field] ?? [];
+            if (!Array.isArray(value) || value.some(item => typeof item !== 'string')) {
+                throw new PlaybookError(`${file}: playbook "${modelId}" field "${field}" must be an array of strings`);
+            }
+            playbook[field] = value;
+        }
+        playbooks.set(modelId, playbook);
+    }
+    return playbooks;
+}
+//# sourceMappingURL=playbook.js.map

package/lib/registrar.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The registrar: turns each runnable catalog model into a DSH tool.
+ *
+ * The registrar owns the translation from the catalog's declarative tool spec
+ * into a `defineTool` definition, including the parameter schema, the canonical
+ * output contract and the model-facing rendering. Registration goes through
+ * `ctx.tools.register`, whose returned disposer is the only unregister API, so
+ * the plugin can add or drop a model's tool at runtime as capability changes.
+ *
+ * @module @try-works/dsh-model-as-tool/registrar
+ */
+import { type ParameterSchemaSpec } from '@deepseek-ai/dsh-tools';
+import type { ModelCatalogEntry } from './types.ts';
+import type { ModelAdapter } from './adapters/index.ts';
+/** The tool spec a catalog entry declares, resolved into a registration. */
+export interface RegisteredModelTool {
+    readonly modelId: string;
+    readonly toolName: string;
+    readonly dispose: () => void;
+}
+/**
+ * Build the parameter schema for one model's tool.
+ *
+ * Every catalog parameter is optional except the model's primary input, which
+ * the adapter validates as a required non-empty value. Types come from the
+ * catalog declaration, so a numeric or list parameter reaches the model as the
+ * type it actually is rather than as a string it has to re-parse.
+ * @param entry - the catalog entry.
+ * @returns the DSH parameter schema spec.
+ */
+export declare function buildParameters(entry: ModelCatalogEntry): ParameterSchemaSpec;
+/**
+ * Render the tool result for the model.
+ *
+ * The canonical value is the source of truth; this projection only chooses how
+ * to present it. Tongue's shaped result gets a sentence the model can act on
+ * directly, while everything else falls back to stable JSON so no information
+ * is lost to a lossy humanization.
+ * @param entry - the catalog entry.
+ * @param value - the canonical value the adapter returned.
+ * @returns the model-facing content blocks.
+ */
+export declare function renderResult(entry: ModelCatalogEntry, value: Record<string, unknown>): {
+    type: 'text';
+    text: string;
+}[];
+/**
+ * Register one model's tool on the calling context.
+ * @param ctx - the context whose tool registry receives the definition; its scope decides visibility.
+ * @param entry - the catalog entry to expose.
+ * @param adapter - the adapter that invokes the model.
+ * @returns the model id, the tool name, and the disposer returned by the registry.
+ */
+export declare function registerModelTool(ctx: {
+    tools: {
+        register(definition: unknown): () => void;
+    };
+}, entry: ModelCatalogEntry, adapter: ModelAdapter): RegisteredModelTool;
+//# sourceMappingURL=registrar.d.ts.map

package/lib/registrar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registrar.d.ts","sourceRoot":"","sources":["../src/registrar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAA0C,KAAK,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AACzG,OAAO,KAAK,EAAE,iBAAiB,EAAkB,MAAM,YAAY,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAEvD,4EAA4E;AAC5E,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAC7B;AAwBD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,iBAAiB,GAAG,mBAAmB,CAY7E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,iBAAiB,EACxB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,CA0BlC;AAcD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE;IAAE,KAAK,EAAE;QAAE,QAAQ,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,IAAI,CAAA;KAAE,CAAA;CAAE,EAC7D,KAAK,EAAE,iBAAiB,EACxB,OAAO,EAAE,YAAY,GACpB,mBAAmB,CA6BrB"}