@try-works/dsh-tool-mode 0.0.0-stage → 0.5.45

package/lib/custom-tools/dispatch.js

@@ -0,0 +1,34 @@
+/**
+ * Kind dispatch for custom tools.
+ *
+ * @module @try-works/dsh-tool-mode/custom-tools/dispatch
+ */
+import { executeCompositeCustomTool } from "./composite-executor.js";
+import { executeHttpCustomTool } from "./http-executor.js";
+import { executePromptCustomTool } from "./prompt-executor.js";
+/**
+ * Execute a record according to its validated kind.
+ * @param record - validated record.
+ * @param args - model-supplied arguments.
+ * @param context - cancellation.
+ * @param deps - kind-specific seams.
+ * @returns the canonical result value.
+ */
+export async function executeCustomTool(record, args, context, deps = {}) {
+    switch (record.execution.kind) {
+        case 'http':
+            return executeHttpCustomTool(record, args, context, deps.http ?? {});
+        case 'prompt':
+            return executePromptCustomTool(record, args, context, deps.prompt ?? {});
+        case 'composite':
+            return executeCompositeCustomTool(record, args, context, {
+                ...deps.composite,
+                selfName: record.name,
+            });
+    }
+}
+/** Adapt dispatch deps into the registrar's executor signature. */
+export function customToolExecutor(deps) {
+    return (record, args, context) => executeCustomTool(record, args, context, deps);
+}
+//# sourceMappingURL=dispatch.js.map

package/lib/custom-tools/http-executor.d.ts

@@ -0,0 +1,48 @@
+/**
+ * HTTP executor for user-authored custom tools.
+ *
+ * Security properties, all enforced here rather than in the form:
+ * - HTTPS only, exact origin allowlist;
+ * - DNS is resolved for every call and every resolved address must be public;
+ * - redirects are refused;
+ * - response bytes and wall-clock time are bounded;
+ * - credential references resolve per call and values never enter errors.
+ *
+ * @module @try-works/dsh-tool-mode/custom-tools/http-executor
+ */
+import type { CustomToolExecContext } from './compile.ts';
+import type { CustomToolRecord } from './types.ts';
+/** A named refusal from the HTTP executor. */
+export declare class CustomToolHttpError extends Error {
+    readonly name = "CustomToolHttpError";
+    readonly code: 'custom-tool-http-url-invalid' | 'custom-tool-http-origin-denied' | 'custom-tool-http-private-address' | 'custom-tool-http-credential-unavailable' | 'custom-tool-http-fetch-failed' | 'custom-tool-http-response-too-large' | 'custom-tool-http-timeout';
+    constructor(code: CustomToolHttpError['code'], message: string, options?: ErrorOptions);
+}
+/** Dependency seams; production uses real DNS/fetch and `ctx.credentials`. */
+export interface HttpExecutorDeps {
+    readonly fetchImpl?: typeof fetch;
+    readonly lookup?: (hostname: string) => Promise<readonly {
+        readonly address: string;
+        readonly family: number;
+    }[]>;
+    /** Resolve a credential reference; undefined means unconfigured. */
+    readonly resolveCredential?: (name: string) => Promise<string | undefined>;
+    /** Response byte cap; default 1 MiB. */
+    readonly maxResponseBytes?: number;
+}
+/** Whether an IPv4/IPv6 literal is loopback, private, link-local or metadata. */
+export declare function isPrivateAddress(address: string): boolean;
+/** Extract a dot path from a JSON value; empty path returns the value itself. */
+export declare function extractPath(value: unknown, path: string): unknown;
+/**
+ * Execute one HTTP custom tool.
+ * @param record - validated record whose execution kind is `http`.
+ * @param args - tool arguments.
+ * @param context - cancellation signal.
+ * @param deps - injectable fetch/DNS/credential seams.
+ * @returns the parsed/extracted response value.
+ */
+export declare function executeHttpCustomTool(record: CustomToolRecord, args: Readonly<Record<string, unknown>>, context: CustomToolExecContext, deps?: HttpExecutorDeps): Promise<unknown>;
+/** Render a safe error message without credential values. */
+export declare function describeHttpError(error: unknown): string;
+//# sourceMappingURL=http-executor.d.ts.map

package/lib/custom-tools/http-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-executor.d.ts","sourceRoot":"","sources":["../../src/custom-tools/http-executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAEzD,OAAO,KAAK,EAAE,gBAAgB,EAAkC,MAAM,YAAY,CAAA;AAElF,8CAA8C;AAC9C,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,SAAkB,IAAI,yBAAwB;IAC9C,QAAQ,CAAC,IAAI,EACT,8BAA8B,GAC9B,gCAAgC,GAChC,kCAAkC,GAClC,yCAAyC,GACzC,+BAA+B,GAC/B,qCAAqC,GACrC,0BAA0B,CAAA;gBAElB,IAAI,EAAE,mBAAmB,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIvF;AAED,8EAA8E;AAC9E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAA;IACjC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAA;IACjH,oEAAoE;IACpE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;IAC1E,wCAAwC;IACxC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CACnC;AAKD,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAuBzD;AAqBD,iFAAiF;AACjF,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAQjE;AAkFD;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,gBAAgB,EACxB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACvC,OAAO,EAAE,qBAAqB,EAC9B,IAAI,GAAE,gBAAqB,GAC1B,OAAO,CAAC,OAAO,CAAC,CAqElB;AAED,6DAA6D;AAC7D,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAIxD"}

package/lib/custom-tools/http-executor.js

@@ -0,0 +1,241 @@
+/**
+ * HTTP executor for user-authored custom tools.
+ *
+ * Security properties, all enforced here rather than in the form:
+ * - HTTPS only, exact origin allowlist;
+ * - DNS is resolved for every call and every resolved address must be public;
+ * - redirects are refused;
+ * - response bytes and wall-clock time are bounded;
+ * - credential references resolve per call and values never enter errors.
+ *
+ * @module @try-works/dsh-tool-mode/custom-tools/http-executor
+ */
+import { lookup as dnsLookup } from 'node:dns/promises';
+import { isIP } from 'node:net';
+import { CustomToolSchemaError } from "./schema.js";
+/** A named refusal from the HTTP executor. */
+export class CustomToolHttpError extends Error {
+    name = 'CustomToolHttpError';
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+const DEFAULT_MAX_RESPONSE_BYTES = 1024 * 1024;
+const TEMPLATE = /\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}/g;
+/** Whether an IPv4/IPv6 literal is loopback, private, link-local or metadata. */
+export function isPrivateAddress(address) {
+    const version = isIP(address);
+    if (version === 4) {
+        const parts = address.split('.').map(Number);
+        if (parts.length !== 4 || parts.some(part => !Number.isInteger(part) || part < 0 || part > 255))
+            return true;
+        const [a = 0, b = 0] = parts;
+        return a === 0 || a === 10 || a === 127
+            || (a === 100 && b >= 64 && b <= 127)
+            || (a === 169 && b === 254)
+            || (a === 172 && b >= 16 && b <= 31)
+            || (a === 192 && b === 0)
+            || (a === 192 && b === 168)
+            || (a === 198 && (b === 18 || b === 19))
+            || a >= 224;
+    }
+    if (version === 6) {
+        const lower = address.toLowerCase();
+        if (lower === '::' || lower === '::1')
+            return true;
+        if (lower.startsWith('::ffff:'))
+            return isPrivateAddress(lower.slice('::ffff:'.length));
+        return lower.startsWith('fc') || lower.startsWith('fd') || lower.startsWith('fe8') || lower.startsWith('fe9')
+            || lower.startsWith('fea') || lower.startsWith('feb') || lower.startsWith('ff');
+    }
+    return true;
+}
+/** One resolved template argument, with a named failure for a missing key. */
+function argument(args, name) {
+    const value = args[name];
+    if (value === undefined) {
+        throw new CustomToolHttpError('custom-tool-http-url-invalid', `argument ${JSON.stringify(name)} is required by the template`);
+    }
+    return value;
+}
+/** Percent-encode scalar template values for a URL/query component. */
+function interpolateUrl(template, args) {
+    return template.replace(TEMPLATE, (_whole, name) => encodeURIComponent(String(argument(args, name))));
+}
+/** Substitute JSON-safe values into a JSON body template. */
+function interpolateBody(template, args) {
+    return template.replace(TEMPLATE, (_whole, name) => JSON.stringify(argument(args, name)));
+}
+/** Extract a dot path from a JSON value; empty path returns the value itself. */
+export function extractPath(value, path) {
+    if (path.length === 0)
+        return value;
+    let current = value;
+    for (const segment of path.split('.')) {
+        if (!Array.isArray(current) && (typeof current !== 'object' || current === null))
+            return undefined;
+        current = Array.isArray(current) ? current[Number(segment)] : current[segment];
+    }
+    return current;
+}
+function originOf(url) {
+    return url.origin;
+}
+async function assertPublicHost(hostname, deps) {
+    if (isIP(hostname) !== 0) {
+        if (isPrivateAddress(hostname)) {
+            throw new CustomToolHttpError('custom-tool-http-private-address', `the target ${hostname} is a private or loopback address`);
+        }
+        return;
+    }
+    const lookup = deps.lookup ?? (async (host) => dnsLookup(host, { all: true, verbatim: true }));
+    let addresses;
+    try {
+        addresses = await lookup(hostname);
+    }
+    catch (error) {
+        throw new CustomToolHttpError('custom-tool-http-fetch-failed', `the host ${hostname} could not be resolved`, { cause: error });
+    }
+    if (addresses.length === 0) {
+        throw new CustomToolHttpError('custom-tool-http-fetch-failed', `the host ${hostname} resolved to no address`);
+    }
+    for (const entry of addresses) {
+        if (isPrivateAddress(entry.address)) {
+            throw new CustomToolHttpError('custom-tool-http-private-address', `the host ${hostname} resolves to the private address ${entry.address}`);
+        }
+    }
+}
+async function resolveHeaders(headers, deps) {
+    const out = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (typeof value === 'string') {
+            out[name] = value;
+            continue;
+        }
+        const secret = await deps.resolveCredential?.(value.secret);
+        if (secret === undefined) {
+            throw new CustomToolHttpError('custom-tool-http-credential-unavailable', `the credential ${JSON.stringify(value.secret)} is not configured`);
+        }
+        out[name] = secret;
+    }
+    return out;
+}
+async function readBounded(response, maxBytes) {
+    const declared = Number(response.headers.get('content-length') ?? Number.NaN);
+    if (Number.isFinite(declared) && declared > maxBytes) {
+        await response.body?.cancel();
+        throw new CustomToolHttpError('custom-tool-http-response-too-large', `the response is over the ${maxBytes}-byte cap`);
+    }
+    if (response.body === null)
+        return new Uint8Array(await response.arrayBuffer());
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (value === undefined)
+            continue;
+        total += value.byteLength;
+        if (total > maxBytes) {
+            await reader.cancel();
+            throw new CustomToolHttpError('custom-tool-http-response-too-large', `the response is over the ${maxBytes}-byte cap`);
+        }
+        chunks.push(value);
+    }
+    const joined = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        joined.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return joined;
+}
+/**
+ * Execute one HTTP custom tool.
+ * @param record - validated record whose execution kind is `http`.
+ * @param args - tool arguments.
+ * @param context - cancellation signal.
+ * @param deps - injectable fetch/DNS/credential seams.
+ * @returns the parsed/extracted response value.
+ */
+export async function executeHttpCustomTool(record, args, context, deps = {}) {
+    if (record.execution.kind !== 'http') {
+        throw new CustomToolHttpError('custom-tool-http-url-invalid', `${record.id} is not an HTTP tool`);
+    }
+    const http = record.execution.http;
+    const target = interpolateUrl(http.url, args);
+    let url;
+    try {
+        url = new URL(target);
+    }
+    catch (error) {
+        throw new CustomToolHttpError('custom-tool-http-url-invalid', `the URL template did not produce an absolute URL`, { cause: error });
+    }
+    if (url.protocol !== 'https:')
+        throw new CustomToolHttpError('custom-tool-http-url-invalid', 'HTTP tools must use https');
+    if (url.username !== '' || url.password !== '')
+        throw new CustomToolHttpError('custom-tool-http-url-invalid', 'the URL must not embed credentials');
+    if (!record.policy.networkOrigins.includes(originOf(url))) {
+        throw new CustomToolHttpError('custom-tool-http-origin-denied', `${url.origin} is not in the tool's network allowlist`);
+    }
+    await assertPublicHost(url.hostname, deps);
+    const headers = await resolveHeaders(http.headers, deps);
+    const method = http.method;
+    const body = http.bodyTemplate === undefined || method === 'GET' ? undefined : interpolateBody(http.bodyTemplate, args);
+    if (body !== undefined && !Object.keys(headers).some(name => name.toLowerCase() === 'content-type')) {
+        headers['content-type'] = 'application/json';
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new Error('custom-tool-http-timeout')), record.policy.timeoutMs);
+    const signal = AbortSignal.any([context.signal, controller.signal]);
+    let response;
+    try {
+        response = await (deps.fetchImpl ?? fetch)(url, {
+            method,
+            headers,
+            ...body === undefined ? {} : { body },
+            redirect: 'error',
+            signal,
+        });
+    }
+    catch (error) {
+        if (signal.aborted) {
+            const timeout = controller.signal.aborted;
+            throw new CustomToolHttpError(timeout ? 'custom-tool-http-timeout' : 'custom-tool-http-fetch-failed', timeout ? `the request exceeded ${record.policy.timeoutMs} ms` : 'the request was cancelled', { cause: error });
+        }
+        throw new CustomToolHttpError('custom-tool-http-fetch-failed', `the request to ${url.host} failed`, { cause: error });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!response.ok) {
+        await response.body?.cancel();
+        throw new CustomToolHttpError('custom-tool-http-fetch-failed', `the request to ${url.host} answered HTTP ${response.status}`);
+    }
+    const bytes = await readBounded(response, deps.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES);
+    const text = new TextDecoder().decode(bytes);
+    const contentType = response.headers.get('content-type') ?? '';
+    let value = text;
+    if (contentType.includes('json')) {
+        try {
+            value = JSON.parse(text);
+        }
+        catch {
+            throw new CustomToolHttpError('custom-tool-http-fetch-failed', `the response from ${url.host} declared JSON but did not parse`);
+        }
+    }
+    return extractPath(value, http.extract ?? '');
+}
+/** Render a safe error message without credential values. */
+export function describeHttpError(error) {
+    if (error instanceof CustomToolSchemaError)
+        return error.message;
+    if (error instanceof CustomToolHttpError)
+        return error.message;
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=http-executor.js.map

package/lib/custom-tools/index.d.ts

@@ -0,0 +1,12 @@
+export * from './types.ts';
+export * from './schema.ts';
+export * from './store.ts';
+export * from './compile.ts';
+export * from './registry.ts';
+export * from './http-executor.ts';
+export * from './prompt-executor.ts';
+export * from './composite-executor.ts';
+export * from './dispatch.ts';
+export * from './service.ts';
+export * from './mcp-surface.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/custom-tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/custom-tools/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,oBAAoB,CAAA;AAClC,cAAc,sBAAsB,CAAA;AACpC,cAAc,yBAAyB,CAAA;AACvC,cAAc,eAAe,CAAA;AAC7B,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA"}

package/lib/custom-tools/index.js

@@ -0,0 +1,12 @@
+export * from "./types.js";
+export * from "./schema.js";
+export * from "./store.js";
+export * from "./compile.js";
+export * from "./registry.js";
+export * from "./http-executor.js";
+export * from "./prompt-executor.js";
+export * from "./composite-executor.js";
+export * from "./dispatch.js";
+export * from "./service.js";
+export * from "./mcp-surface.js";
+//# sourceMappingURL=index.js.map

package/lib/custom-tools/mcp-surface.d.ts

@@ -0,0 +1,14 @@
+/**
+ * MCP publication rows for custom tools.
+ *
+ * Custom tools are agent-visible by default, but MCP is a separate opt-in. A
+ * tool that is not opted in is still returned as a WITHHELD row so the status
+ * surface can explain the absence instead of silently omitting it.
+ *
+ * @module @try-works/dsh-tool-mode/custom-tools/mcp-surface
+ */
+import type { PublishedTool } from '../mcp/host-binding.ts';
+import type { CustomToolRecord } from './types.ts';
+/** Build the MCP surface rows for the active custom-tool records. */
+export declare function customToolPublishedTools(records: readonly CustomToolRecord[]): readonly PublishedTool[];
+//# sourceMappingURL=mcp-surface.d.ts.map

package/lib/custom-tools/mcp-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-surface.d.ts","sourceRoot":"","sources":["../../src/custom-tools/mcp-surface.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,qEAAqE;AACrE,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,GAAG,SAAS,aAAa,EAAE,CA6BvG"}

package/lib/custom-tools/mcp-surface.js

@@ -0,0 +1,41 @@
+/**
+ * MCP publication rows for custom tools.
+ *
+ * Custom tools are agent-visible by default, but MCP is a separate opt-in. A
+ * tool that is not opted in is still returned as a WITHHELD row so the status
+ * surface can explain the absence instead of silently omitting it.
+ *
+ * @module @try-works/dsh-tool-mode/custom-tools/mcp-surface
+ */
+/** Build the MCP surface rows for the active custom-tool records. */
+export function customToolPublishedTools(records) {
+    return records.map(record => {
+        const contract = {
+            contract: record.id,
+            version: String(record.version),
+            toolName: record.name,
+            description: record.description,
+            inputSchema: record.parameters,
+            outputSchema: (record.outputSchema ?? {}),
+            semantics: {},
+            limits: { timeoutMs: record.policy.timeoutMs },
+            unsupported: [],
+        };
+        if (!record.policy.mcpExpose) {
+            return {
+                toolName: record.name,
+                contract,
+                notExportableReason: 'MCP exposure is off for this custom tool',
+            };
+        }
+        if (record.outputSchema === undefined) {
+            return {
+                toolName: record.name,
+                contract,
+                notExportableReason: 'the custom tool declares no output schema, so MCP cannot advertise a result shape',
+            };
+        }
+        return { toolName: record.name, contract };
+    });
+}
+//# sourceMappingURL=mcp-surface.js.map

package/lib/custom-tools/prompt-executor.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Prompt custom-tool executor.
+ *
+ * A prompt tool is deliberately not a workflow or an agent: it performs exactly
+ * one model call with a template and returns text. The model provider is an
+ * injected seam; this module never resolves credentials, tools or files.
+ *
+ * @module @try-works/dsh-tool-mode/custom-tools/prompt-executor
+ */
+import type { CustomToolExecContext } from './compile.ts';
+import type { CustomToolRecord } from './types.ts';
+/** A named prompt-execution refusal. */
+export declare class CustomToolPromptError extends Error {
+    readonly name = "CustomToolPromptError";
+    readonly code: 'custom-tool-prompt-unavailable' | 'custom-tool-prompt-template-invalid' | 'custom-tool-prompt-failed';
+    constructor(code: CustomToolPromptError['code'], message: string, options?: ErrorOptions);
+}
+/** The one model call a prompt tool may make. */
+export interface PromptRunInput {
+    readonly prompt: string;
+    readonly model?: string;
+    readonly maxOutputTokens?: number;
+    readonly signal: AbortSignal;
+}
+/** Prompt executor seams. */
+export interface PromptExecutorDeps {
+    /** Absent means the deployment composes no model provider. */
+    readonly runPrompt?: (input: PromptRunInput) => Promise<string>;
+}
+/**
+ * Execute one prompt tool.
+ * @param record - validated prompt record.
+ * @param args - arguments.
+ * @param context - cancellation.
+ * @param deps - model seam.
+ * @returns the model text.
+ */
+export declare function executePromptCustomTool(record: CustomToolRecord, args: Readonly<Record<string, unknown>>, context: CustomToolExecContext, deps?: PromptExecutorDeps): Promise<string>;
+//# sourceMappingURL=prompt-executor.d.ts.map

package/lib/custom-tools/prompt-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-executor.d.ts","sourceRoot":"","sources":["../../src/custom-tools/prompt-executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,wCAAwC;AACxC,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,SAAkB,IAAI,2BAA0B;IAChD,QAAQ,CAAC,IAAI,EACT,gCAAgC,GAChC,qCAAqC,GACrC,2BAA2B,CAAA;gBAEnB,IAAI,EAAE,qBAAqB,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIzF;AAED,iDAAiD;AACjD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;CAC7B;AAED,6BAA6B;AAC7B,MAAM,WAAW,kBAAkB;IACjC,8DAA8D;IAC9D,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CAChE;AAcD;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,gBAAgB,EACxB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACvC,OAAO,EAAE,qBAAqB,EAC9B,IAAI,GAAE,kBAAuB,GAC5B,OAAO,CAAC,MAAM,CAAC,CAmBjB"}

package/lib/custom-tools/prompt-executor.js

@@ -0,0 +1,59 @@
+/**
+ * Prompt custom-tool executor.
+ *
+ * A prompt tool is deliberately not a workflow or an agent: it performs exactly
+ * one model call with a template and returns text. The model provider is an
+ * injected seam; this module never resolves credentials, tools or files.
+ *
+ * @module @try-works/dsh-tool-mode/custom-tools/prompt-executor
+ */
+/** A named prompt-execution refusal. */
+export class CustomToolPromptError extends Error {
+    name = 'CustomToolPromptError';
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+const TEMPLATE = /\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}/g;
+function interpolate(template, args) {
+    return template.replace(TEMPLATE, (_whole, name) => {
+        const value = args[name];
+        if (value === undefined) {
+            throw new CustomToolPromptError('custom-tool-prompt-template-invalid', `argument ${JSON.stringify(name)} is missing`);
+        }
+        return String(value);
+    });
+}
+/**
+ * Execute one prompt tool.
+ * @param record - validated prompt record.
+ * @param args - arguments.
+ * @param context - cancellation.
+ * @param deps - model seam.
+ * @returns the model text.
+ */
+export async function executePromptCustomTool(record, args, context, deps = {}) {
+    if (record.execution.kind !== 'prompt') {
+        throw new CustomToolPromptError('custom-tool-prompt-template-invalid', `${record.id} is not a prompt tool`);
+    }
+    if (deps.runPrompt === undefined) {
+        throw new CustomToolPromptError('custom-tool-prompt-unavailable', 'no model provider is composed for prompt tools');
+    }
+    const prompt = interpolate(record.execution.prompt.template, args);
+    try {
+        return await deps.runPrompt({
+            prompt,
+            ...record.execution.prompt.model === undefined ? {} : { model: record.execution.prompt.model },
+            ...record.execution.prompt.maxOutputTokens === undefined ? {} : { maxOutputTokens: record.execution.prompt.maxOutputTokens },
+            signal: context.signal,
+        });
+    }
+    catch (error) {
+        if (error instanceof CustomToolPromptError)
+            throw error;
+        throw new CustomToolPromptError('custom-tool-prompt-failed', `the prompt tool failed`, { cause: error });
+    }
+}
+//# sourceMappingURL=prompt-executor.js.map

package/lib/custom-tools/registry.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Runtime registration for custom tools.
+ *
+ * One active registration per custom id. Saving a new version disposes the old
+ * definition before registering the new one; disabling/deleting disposes without
+ * touching the immutable record. `sync()` is the restart path.
+ *
+ * @module @try-works/dsh-tool-mode/custom-tools/registry
+ */
+import { type CustomToolExecutor } from './compile.ts';
+import { CustomToolStore } from './store.ts';
+import type { CustomToolRecord } from './types.ts';
+/** The registry surface needed; structurally compatible with `ctx.tools`. */
+export interface CustomToolRegistryTools {
+    get(name: string): unknown;
+    register(definition: unknown): () => void;
+}
+/** One live registration. */
+export interface CustomToolRegistration {
+    readonly id: string;
+    readonly name: string;
+    readonly version: number;
+    readonly dispose: () => void;
+}
+/** One per-tool sync outcome. */
+export interface CustomToolSyncEntry {
+    readonly id: string;
+    readonly version: number | null;
+    readonly reason: string;
+}
+/** Full sync result, safe to report from a host service. */
+export interface CustomToolSyncResult {
+    readonly registered: readonly CustomToolSyncEntry[];
+    readonly skipped: readonly CustomToolSyncEntry[];
+    readonly errors: readonly CustomToolSyncEntry[];
+}
+/** Options for the registrar. */
+export interface CustomToolRegistrarOptions {
+    readonly store: CustomToolStore;
+    readonly tools: CustomToolRegistryTools;
+    readonly execute: CustomToolExecutor;
+}
+/** Owns the live definitions for one profile. */
+export declare class CustomToolRegistrar {
+    readonly store: CustomToolStore;
+    private readonly tools;
+    private readonly execute;
+    private readonly active;
+    constructor(options: CustomToolRegistrarOptions);
+    /** The live registration for one id, if any. */
+    get(id: string): CustomToolRegistration | undefined;
+    /** Live registrations, sorted by id. */
+    list(): readonly CustomToolRegistration[];
+    /**
+     * Register or refresh one record. The old definition for the same id is
+     * disposed first, so a new version is visible without a host restart.
+     */
+    register(record: CustomToolRecord): CustomToolRegistration;
+    /** Dispose one id; false when it was not live. */
+    dispose(id: string): boolean;
+    /** Dispose everything (plugin teardown). */
+    disposeAll(): void;
+    /**
+     * Reconcile the live set with the store. A bad record is reported and does not
+     * stop the others; a disabled or agent-hidden record is disposed.
+     */
+    sync(): CustomToolSyncResult;
+}
+//# sourceMappingURL=registry.d.ts.map

package/lib/custom-tools/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/custom-tools/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAqB,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAA;AACzE,OAAO,EAAE,eAAe,EAAwB,MAAM,YAAY,CAAA;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,6EAA6E;AAC7E,MAAM,WAAW,uBAAuB;IACtC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;IAC1B,QAAQ,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,IAAI,CAAA;CAC1C;AAED,6BAA6B;AAC7B,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAC7B;AAED,iCAAiC;AACjC,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,4DAA4D;AAC5D,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,UAAU,EAAE,SAAS,mBAAmB,EAAE,CAAA;IACnD,QAAQ,CAAC,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAA;IAChD,QAAQ,CAAC,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAA;CAChD;AAED,iCAAiC;AACjC,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,uBAAuB,CAAA;IACvC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAA;CACrC;AAED,iDAAiD;AACjD,qBAAa,mBAAmB;IAC9B,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;IAC/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyB;IAC/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4C;gBAEvD,OAAO,EAAE,0BAA0B;IAM/C,gDAAgD;IAChD,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS;IAInD,wCAAwC;IACxC,IAAI,IAAI,SAAS,sBAAsB,EAAE;IAIzC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,gBAAgB,GAAG,sBAAsB;IAwB1D,kDAAkD;IAClD,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAQ5B,4CAA4C;IAC5C,UAAU,IAAI,IAAI;IAKlB;;;OAGG;IACH,IAAI,IAAI,oBAAoB;CA8C7B"}