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

package/lib/capability.js

@@ -0,0 +1,175 @@
+/**
+ * Capability resolution: decide whether a catalog model can actually run in
+ * this DSH process, and by which route.
+ *
+ * The rule this module enforces is that a model becomes a tool only when an
+ * adapter can really invoke it. Every other model stays catalogued and
+ * reportable, so `model_tools` can explain what is missing instead of the agent
+ * discovering a broken tool at call time.
+ *
+ * @module @try-works/dsh-model-as-tool/capability
+ */
+import { createRequire } from 'node:module';
+import { DEFAULT_CLI_COMMAND } from "./transport.js";
+/**
+ * Node resolution context for this plugin.
+ *
+ * The plugin must resolve model packages from the DSH installation that is
+ * hosting it, not from its own nested `node_modules`, so that an operator who
+ * installs `@desert-ant-labs/tongue` into the profile gets a working tool.
+ */
+const requireFromHere = createRequire(import.meta.url);
+/**
+ * Whether a package specifier resolves from this plugin's installation.
+ *
+ * Resolution deliberately does not load the module: importing a model package
+ * pulls in a WASM or native runtime, and capability probing must stay cheap
+ * enough to run at plugin load.
+ * @param specifier - package name, optionally with a subpath.
+ * @returns whether Node can resolve the specifier.
+ */
+export function canResolve(specifier) {
+    try {
+        requireFromHere.resolve(specifier);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Join a package and its documented subpath into one specifier. */
+export function packageSpecifier(pkg, subpath) {
+    return subpath === null ? pkg : `${pkg}${subpath}`;
+}
+/** Reason text for a model that has no runnable route on any platform. */
+function unavailableReason(entry) {
+    if (entry.closedBeta) {
+        return `${entry.name} is in closed beta: the weights are published at ${entry.hfRepo} but no SDK ships them yet, so it cannot be installed as a tool.`;
+    }
+    if (entry.appleOnly) {
+        return `${entry.name} is Apple-only (Core ML/MLX through the Swift package); there is no JavaScript SDK, so it cannot run in a Node process. Point \`remote.endpoint\` at a bridge on an Apple machine to reach it.`;
+    }
+    if (entry.npmPackage === null && entry.cliVerb === null) {
+        return `${entry.name} has no npm package and no CLI verb, so no transport can reach it.`;
+    }
+    if (entry.npmPackage === null) {
+        return `${entry.name} has no npm package; run it through the Desert Ant CLI (macOS/Linux) with \`cli.enabled\`, or through a bridge with \`remote.endpoint\`.`;
+    }
+    return `${entry.name} has no runtime available to this process.`;
+}
+/** Whether the CLI can carry this model at all. */
+function cliCapable(entry) {
+    return entry.cliVerb !== null && !entry.closedBeta;
+}
+/**
+ * Resolve how (and whether) one model can run here.
+ *
+ * Transport preference is deliberate: an in-process package is fastest and
+ * needs no external service, so it wins; the CLI is local but out-of-process;
+ * the bridge is last because it depends on another machine. A user who would
+ * rather route everything through a bridge can disable the other two.
+ * @param entry - the catalog entry to resolve.
+ * @param options - overrides for testing; `resolve`, `platform` and the transport switches replace the process facts.
+ * @returns the verdict, including the reason for every negative one.
+ */
+export function resolveCapability(entry, options = {}) {
+    const resolve = options.resolve ?? canResolve;
+    const platform = options.platform ?? process.platform;
+    const allowNpm = options.allowNpm ?? true;
+    const remoteEndpoint = options.remoteEndpoint;
+    // A bridge is checked first among the fallbacks because it is the only route
+    // for Apple-only models, which have neither a package nor (for some) a verb.
+    const bridgeUsable = remoteEndpoint !== undefined && remoteEndpoint.length > 0 && !entry.closedBeta;
+    const pkg = entry.npmPackage;
+    // Why the in-process route did not pan out. Kept so the final verdict can name
+    // the exact missing piece ("install onnxruntime-node") instead of falling back
+    // to a generic sentence once the CLI and bridge have also been ruled out.
+    let npmMiss;
+    if (pkg !== null && allowNpm) {
+        const missingRuntimes = entry.requiresRuntime.filter(name => !resolve(name));
+        if (missingRuntimes.length > 0) {
+            npmMiss = {
+                reason: `${entry.name} needs ${missingRuntimes.join(', ')} to run here; install it beside the plugin (npm i ${missingRuntimes.join(' ')}).`,
+                missing: missingRuntimes,
+            };
+        }
+        else {
+            const native = packageSpecifier(pkg, entry.npmSubpath);
+            const onnx = entry.requiresRuntime.length > 0;
+            // A declared ONNX runtime wins over the package's own default entry: for
+            // these packages the default import is the browser build, which refuses
+            // to initialize in Node.
+            if (onnx) {
+                if (resolve(pkg)) {
+                    return {
+                        runnable: true,
+                        route: 'npm-onnxruntime',
+                        reason: `${entry.name} runs through ${entry.requiresRuntime.join(', ')}.`,
+                        resolved: [...entry.requiresRuntime, pkg],
+                    };
+                }
+                npmMiss = {
+                    reason: `${entry.name} requires the ${pkg} package, which is not installed.`,
+                    missing: [pkg],
+                };
+            }
+            else if (platform === 'win32' && entry.windowsSupport === 'browser-only') {
+                npmMiss = {
+                    reason: `${entry.name} has no prebuilt native build for win32-${process.arch}: ${native} supports linux-x64, linux-arm64 and darwin-arm64 only.`,
+                    missing: [native],
+                };
+            }
+            else if (resolve(native)) {
+                return {
+                    runnable: true,
+                    route: 'npm-native',
+                    reason: `${entry.name} resolves ${native} for this platform.`,
+                    resolved: [native],
+                };
+            }
+            else {
+                npmMiss = {
+                    reason: `${entry.name} requires the ${native} package, which is not installed.`,
+                    missing: [native],
+                };
+            }
+        }
+    }
+    // The CLI runs every shipping model on macOS and Linux, so it is checked
+    // before giving up — including for models whose npm prebuild is missing here.
+    if (cliCapable(entry) && (options.cliAvailable ?? false)) {
+        return {
+            runnable: true,
+            route: 'cli',
+            reason: `${entry.name} runs through the Desert Ant CLI (\`${DEFAULT_CLI_COMMAND} ${entry.cliVerb}\`).`,
+            resolved: [DEFAULT_CLI_COMMAND],
+        };
+    }
+    if (bridgeUsable) {
+        return {
+            runnable: true,
+            route: 'remote',
+            reason: `${entry.name} is reached through the bridge at ${remoteEndpoint}.`,
+            resolved: [remoteEndpoint],
+        };
+    }
+    if (npmMiss !== undefined && !entry.closedBeta && !entry.appleOnly) {
+        return {
+            runnable: false,
+            route: 'unavailable',
+            reason: npmMiss.reason,
+            missing: npmMiss.missing,
+        };
+    }
+    return { runnable: false, route: 'unavailable', reason: unavailableReason(entry) };
+}
+/**
+ * Resolve every catalog entry.
+ * @param entries - validated catalog entries.
+ * @param options - resolution overrides, forwarded to {@link resolveCapability}.
+ * @returns one record per entry, in catalog order.
+ */
+export function resolveCatalog(entries, options = {}) {
+    return entries.map(entry => ({ entry, verdict: resolveCapability(entry, options) }));
+}
+//# sourceMappingURL=capability.js.map

package/lib/catalog.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Loads and validates the Desert Ant Labs model catalog.
+ *
+ * The catalog is plain JSON shipped beside the plugin so that a deployment can
+ * inspect or override it without rebuilding: `catalogFile` points at another
+ * document with the same shape.
+ *
+ * @module @try-works/dsh-model-as-tool/catalog
+ */
+import type { ModelCatalogEntry } from './types.ts';
+/** Absolute path of the catalog document shipped with this package. */
+export declare const DEFAULT_CATALOG_FILE: string;
+/** Raised when the catalog document is missing, unparseable, or malformed. */
+export declare class CatalogError extends Error {
+    readonly name = "CatalogError";
+}
+/**
+ * Parse and validate one catalog entry. Validation is strict on purpose: every
+ * downstream decision (which tool to register, whether it can run, what the
+ * model sees) reads these fields, so a malformed entry must fail at load rather
+ * than become a silently missing tool.
+ * @param raw - one decoded JSON object.
+ * @param source - description of where the document came from, for messages.
+ * @param index - position in the array, for entries with no usable id.
+ * @returns the validated entry.
+ */
+export declare function parseCatalogEntry(raw: unknown, source: string, index: number): ModelCatalogEntry;
+/**
+ * Load the catalog from a JSON document.
+ * @param file - absolute path of the catalog document.
+ * @returns every validated entry, in document order.
+ * @throws CatalogError when the file cannot be read, is not valid JSON, is not an array, or holds a malformed entry.
+ */
+export declare function loadCatalog(file?: string): ModelCatalogEntry[];
+/** Index a catalog by model id. */
+export declare function indexCatalog(entries: readonly ModelCatalogEntry[]): Map<string, ModelCatalogEntry>;
+//# sourceMappingURL=catalog.d.ts.map

package/lib/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAA0D,MAAM,YAAY,CAAA;AAE3G,uEAAuE;AACvE,eAAO,MAAM,oBAAoB,QAEhC,CAAA;AAWD,8EAA8E;AAC9E,qBAAa,YAAa,SAAQ,KAAK;IACrC,SAAkB,IAAI,kBAAiB;CACxC;AA8CD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAqGhG;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,GAAE,MAA6B,GAAG,iBAAiB,EAAE,CA6BpF;AAED,mCAAmC;AACnC,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,iBAAiB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAElG"}

package/lib/catalog.js

@@ -0,0 +1,217 @@
+/**
+ * Loads and validates the Desert Ant Labs model catalog.
+ *
+ * The catalog is plain JSON shipped beside the plugin so that a deployment can
+ * inspect or override it without rebuilding: `catalogFile` points at another
+ * document with the same shape.
+ *
+ * @module @try-works/dsh-model-as-tool/catalog
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+/** Absolute path of the catalog document shipped with this package. */
+export const DEFAULT_CATALOG_FILE = fileURLToPath(new URL('../catalog/desert-ant-models.json', import.meta.url));
+const INPUTS = ['text', 'audio', 'image', 'video', 'stroke', 'transcript'];
+const WINDOWS_SUPPORT = [
+    'native-node',
+    'onnxruntime-node',
+    'apple-only',
+    'browser-only',
+    'no-sdk',
+];
+/** Raised when the catalog document is missing, unparseable, or malformed. */
+export class CatalogError extends Error {
+    name = 'CatalogError';
+}
+function fail(source, message) {
+    throw new CatalogError(`${source}: ${message}`);
+}
+function requireString(entry, key, source) {
+    const value = entry[key];
+    if (typeof value !== 'string' || value.length === 0) {
+        fail(source, `entry "${String(entry.id ?? '?')}" field "${key}" must be a non-empty string`);
+    }
+    return value;
+}
+const PARAM_TYPES = ['string', 'number', 'integer', 'boolean', 'string[]'];
+/**
+ * Normalize one parameter declaration.
+ *
+ * The string shorthand exists because most parameters are prose descriptions of
+ * a string argument; accepting it here keeps the catalog readable while the
+ * registrar still receives one resolved shape.
+ * @param raw - the declaration as written in the document.
+ * @param scope - entry description for error messages.
+ * @param key - parameter name.
+ * @returns the normalized parameter.
+ */
+function parseParam(raw, scope, key) {
+    if (typeof raw === 'string' && raw.length > 0)
+        return { description: raw, type: 'string' };
+    if (typeof raw === 'object' && raw !== null && !Array.isArray(raw)) {
+        const spec = raw;
+        const description = spec.description;
+        if (typeof description !== 'string' || description.length === 0) {
+            throw new CatalogError(`${scope} tool.params.${key}.description must be a non-empty string`);
+        }
+        const type = spec.type;
+        if (type !== undefined && !PARAM_TYPES.includes(type)) {
+            throw new CatalogError(`${scope} tool.params.${key}.type must be one of ${PARAM_TYPES.join(', ')}`);
+        }
+        return { description, type: type ?? 'string' };
+    }
+    throw new CatalogError(`${scope} tool.params.${key} must be a description string or a parameter object`);
+}
+/**
+ * Parse and validate one catalog entry. Validation is strict on purpose: every
+ * downstream decision (which tool to register, whether it can run, what the
+ * model sees) reads these fields, so a malformed entry must fail at load rather
+ * than become a silently missing tool.
+ * @param raw - one decoded JSON object.
+ * @param source - description of where the document came from, for messages.
+ * @param index - position in the array, for entries with no usable id.
+ * @returns the validated entry.
+ */
+export function parseCatalogEntry(raw, source, index) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        fail(source, `entry ${String(index)} must be an object`);
+    }
+    const entry = raw;
+    const id = requireString(entry, 'id', source);
+    const scope = `entry "${id}"`;
+    const input = requireString(entry, 'input', source);
+    if (!INPUTS.includes(input)) {
+        fail(source, `${scope} has unsupported input ${JSON.stringify(input)} (expected one of ${INPUTS.join(', ')})`);
+    }
+    const windowsSupport = requireString(entry, 'windowsSupport', source);
+    if (!WINDOWS_SUPPORT.includes(windowsSupport)) {
+        fail(source, `${scope} has unsupported windowsSupport ${JSON.stringify(windowsSupport)} (expected one of ${WINDOWS_SUPPORT.join(', ')})`);
+    }
+    const tool = entry.tool;
+    if (typeof tool !== 'object' || tool === null)
+        fail(source, `${scope} is missing its "tool" object`);
+    const skill = entry.skill;
+    if (typeof skill !== 'object' || skill === null)
+        fail(source, `${scope} is missing its "skill" object`);
+    const toolSpec = tool;
+    const skillSpec = skill;
+    const params = toolSpec.params;
+    if (typeof params !== 'object' || params === null || Array.isArray(params)) {
+        fail(source, `${scope} tool.params must be an object`);
+    }
+    const bool = (key) => {
+        const value = entry[key];
+        if (typeof value !== 'boolean')
+            fail(source, `${scope} field "${key}" must be a boolean`);
+        return value;
+    };
+    const nullableNumber = (key) => {
+        const value = entry[key];
+        if (value !== null && (typeof value !== 'number' || !Number.isFinite(value))) {
+            fail(source, `${scope} field "${key}" must be a finite number or null`);
+        }
+        return value;
+    };
+    const nullableString = (key) => {
+        const value = entry[key];
+        if (value !== null && typeof value !== 'string') {
+            fail(source, `${scope} field "${key}" must be a string or null`);
+        }
+        return value;
+    };
+    const strings = (key) => {
+        const value = entry[key];
+        if (!Array.isArray(value) || value.some(item => typeof item !== 'string')) {
+            fail(source, `${scope} field "${key}" must be an array of strings`);
+        }
+        return value;
+    };
+    const toolName = requireString(toolSpec, 'name', source);
+    if (!/^[a-z][a-z0-9_]*$/.test(toolName)) {
+        fail(source, `${scope} tool.name ${JSON.stringify(toolName)} must be lower snake_case starting with a letter`);
+    }
+    const skillName = requireString(skillSpec, 'name', source);
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(skillName)) {
+        fail(source, `${scope} skill.name ${JSON.stringify(skillName)} must be kebab-case`);
+    }
+    return {
+        id,
+        name: requireString(entry, 'name', source),
+        summary: requireString(entry, 'summary', source),
+        capability: requireString(entry, 'capability', source),
+        input: input,
+        output: requireString(entry, 'output', source),
+        languages: nullableNumber('languages'),
+        modelSizeMB: nullableNumber('modelSizeMB'),
+        appleOnly: bool('appleOnly'),
+        closedBeta: bool('closedBeta'),
+        verifiedRunnableOnWindows: bool('verifiedRunnableOnWindows'),
+        windowsSupport: windowsSupport,
+        npmPackage: nullableString('npmPackage'),
+        npmSubpath: nullableString('npmSubpath'),
+        requiresRuntime: strings('requiresRuntime'),
+        cliVerb: nullableString('cliVerb'),
+        license: requireString(entry, 'license', source),
+        docsUrl: requireString(entry, 'docsUrl', source),
+        hfRepo: requireString(entry, 'hfRepo', source),
+        tool: {
+            name: toolName,
+            description: requireString(toolSpec, 'description', source),
+            params: Object.fromEntries(Object.entries(params).map(([key, value]) => [
+                key,
+                parseParam(value, scope, key),
+            ])),
+            returns: requireString(toolSpec, 'returns', source),
+        },
+        skill: {
+            name: skillName,
+            description: requireString(skillSpec, 'description', source),
+            ...typeof skillSpec.whenToUse === 'string' ? { whenToUse: skillSpec.whenToUse } : {},
+        },
+    };
+}
+/**
+ * Load the catalog from a JSON document.
+ * @param file - absolute path of the catalog document.
+ * @returns every validated entry, in document order.
+ * @throws CatalogError when the file cannot be read, is not valid JSON, is not an array, or holds a malformed entry.
+ */
+export function loadCatalog(file = DEFAULT_CATALOG_FILE) {
+    let text;
+    try {
+        text = readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        // Node errors are not stable enough to switch on; the message is the point.
+        throw new CatalogError(`cannot read model catalog ${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        throw new CatalogError(`${file} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!Array.isArray(parsed))
+        throw new CatalogError(`${file} must contain a JSON array of model entries`);
+    const entries = parsed.map((raw, index) => parseCatalogEntry(raw, file, index));
+    const seen = new Set();
+    for (const entry of entries) {
+        if (seen.has(entry.id))
+            throw new CatalogError(`${file} declares model id "${entry.id}" more than once`);
+        seen.add(entry.id);
+    }
+    const toolNames = new Set();
+    for (const entry of entries) {
+        if (toolNames.has(entry.tool.name)) {
+            throw new CatalogError(`${file} maps tool name "${entry.tool.name}" to more than one model`);
+        }
+        toolNames.add(entry.tool.name);
+    }
+    return entries;
+}
+/** Index a catalog by model id. */
+export function indexCatalog(entries) {
+    return new Map(entries.map(entry => [entry.id, entry]));
+}
+//# sourceMappingURL=catalog.js.map

package/lib/index.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 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 type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export declare const name = "model-tools";
+export declare const inject: string[];
+/** Plugin configuration. */
+export interface Config {
+    /** Catalog document to load; defaults to the bundled Desert Ant catalog. */
+    catalogFile?: string;
+    /** Playbook document to load; defaults to the bundled playbooks. */
+    playbookFile?: string;
+    /**
+     * Model ids to expose. An empty list (the default) means every model that can
+     * run here; a non-empty list is intersected with what can run, so naming an
+     * unsupported model never registers a tool that would fail at call time.
+     *
+     * The field is an empty array rather than `undefined` when unset: the config
+     * schema materializes a declared array, so the code treats empty as "no
+     * explicit allowlist" instead of "expose nothing".
+     */
+    models?: string[];
+    /** Model ids to exclude, applied after `models`. */
+    exclude?: string[];
+    /**
+     * Register a tool for a model whose runtime is missing, so the failure is
+     * reported at call time instead of the tool being absent. Off by default:
+     * exposing a tool that cannot work wastes a model turn.
+     */
+    exposeUnavailable?: boolean;
+    /** Publish one skill per registered tool. Default true. */
+    registerSkills?: boolean;
+    /** Register the `model_tools` inspection tool. Default true. */
+    registerControlTool?: boolean;
+    /**
+     * The Desert Ant CLI transport, which runs on macOS and Linux and can reach
+     * every shipping model — including the Apple-only ones that have no npm
+     * package.
+     */
+    cli?: {
+        /** Whether the CLI may be used when it is found on PATH. Default true. */
+        enabled?: boolean;
+        /** Command name or absolute path. Default `desertant`. */
+        command?: string;
+    };
+    /**
+     * A user-hosted bridge, reached over HTTP, for models this machine cannot run
+     * itself — most importantly the Apple-only models.
+     *
+     * The plugin does not run this service; the user does, on a machine that can
+     * execute the model. The licence forbids re-hosting the models as a service,
+     * so point this at your own machine.
+     */
+    remote?: {
+        /** Bridge base URL, for example `http://mac-studio.local:8787`. */
+        endpoint?: string;
+        /** Optional bearer token sent to the bridge. */
+        token?: string;
+    };
+    /**
+     * Whether in-process npm packages may be used. Set false to force every call
+     * through the CLI or the bridge. Default true.
+     */
+    allowNpm?: boolean;
+    /**
+     * Where the user's enable/disable choices are persisted. Defaults to
+     * `<DSH_HOME>/model-as-tool/state.json`.
+     */
+    stateFile?: string;
+    /**
+     * Whether `enable`/`disable` persist across restarts. Default true; false
+     * restores the earlier session-scoped behaviour.
+     */
+    persist?: boolean;
+}
+/** Validate and default the plugin configuration. */
+export declare const Config: z<Config>;
+/** One model as the `model_tools` control tool reports it. */
+export interface ModelDescriptor {
+    readonly id: string;
+    readonly name: string;
+    readonly summary: string;
+    readonly capability: string;
+    readonly input: string;
+    readonly tool: string;
+    readonly skill: string;
+    readonly runnable: boolean;
+    readonly route: string;
+    readonly reason: string;
+    readonly languages: number | null;
+    readonly license: string;
+    readonly docs: string;
+}
+/**
+ * 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 declare function apply(ctx: Context, config?: Config): void;
+export { loadCatalog, CatalogError, DEFAULT_CATALOG_FILE } from './catalog.ts';
+export { resolveCapability, resolveCatalog, canResolve, packageSpecifier, type ResolvedModel } from './capability.ts';
+export { createAdapter, ADAPTER_FACTORIES } from './adapters/index.ts';
+export { buildArgv, commandExists, createCliTransport, createRemoteTransport, parseBridgeResponse, parseCliOutcome, splitArguments, BRIDGE_PATH, DEFAULT_CLI_COMMAND, type CommandRunner, type CommandTransport, type HttpPost, type TransportOptions, } from './transport.ts';
+export { renderSkillBody } from './skills.ts';
+export { loadPlaybooks, DEFAULT_PLAYBOOK_FILE, type ModelPlaybook } from './playbook.ts';
+export { createFileStateStore, createMemoryStateStore, defaultStateFile, parseState, resolveSelection, withChoice, EMPTY_STATE, StateError, type PersistedState, type StateStore, } from './state.ts';
+export type { CapabilityVerdict, ModelCatalogEntry, ModelInput, ModelParam, ModelParamType, ModelRoute, ModelToolSpec, ModelSkillSpec, WindowsSupport, } from './types.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,CAAC,MAAM,0BAA0B,CAAA;AAuBxC,eAAO,MAAM,IAAI,gBAAgB,CAAA;AACjC,eAAO,MAAM,MAAM,UAAY,CAAA;AAE/B,4BAA4B;AAC5B,MAAM,WAAW,MAAM;IACrB,4EAA4E;IAC5E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,oEAAoE;IACpE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,oDAAoD;IACpD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,2DAA2D;IAC3D,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,gEAAgE;IAChE,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B;;;;OAIG;IACH,GAAG,CAAC,EAAE;QACJ,0EAA0E;QAC1E,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,0DAA0D;QAC1D,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB,CAAA;IACD;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE;QACP,mEAAmE;QACnE,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,gDAAgD;QAChD,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,CAAA;IACD;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,qDAAqD;AACrD,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,MAAM,CAmB3B,CAAA;AAUF,8DAA8D;AAC9D,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAqBD;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,GAAE,MAAW,GAAG,IAAI,CAoV7D;AAED,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAC9E,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,EAAE,gBAAgB,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AACrH,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AACtE,OAAO,EACL,SAAS,EACT,aAAa,EACb,kBAAkB,EAClB,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,EACf,cAAc,EACd,WAAW,EACX,mBAAmB,EACnB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,QAAQ,EACb,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAA;AACxF,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,gBAAgB,EAChB,UAAU,EACV,gBAAgB,EAChB,UAAU,EACV,WAAW,EACX,UAAU,EACV,KAAK,cAAc,EACnB,KAAK,UAAU,GAChB,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,iBAAiB,EACjB,iBAAiB,EACjB,UAAU,EACV,UAAU,EACV,cAAc,EACd,UAAU,EACV,aAAa,EACb,cAAc,EACd,cAAc,GACf,MAAM,YAAY,CAAA"}