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

package/lib/custom-tools/registry.js

@@ -0,0 +1,130 @@
+/**
+ * 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 { compileCustomTool } from "./compile.js";
+import { CustomToolStoreError } from "./store.js";
+/** Owns the live definitions for one profile. */
+export class CustomToolRegistrar {
+    store;
+    tools;
+    execute;
+    active = new Map();
+    constructor(options) {
+        this.store = options.store;
+        this.tools = options.tools;
+        this.execute = options.execute;
+    }
+    /** The live registration for one id, if any. */
+    get(id) {
+        return this.active.get(id);
+    }
+    /** Live registrations, sorted by id. */
+    list() {
+        return [...this.active.values()].sort((a, b) => a.id.localeCompare(b.id));
+    }
+    /**
+     * 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) {
+        if (!record.enabled)
+            throw new Error(`${record.id} is disabled`);
+        if (!record.policy.agentExpose)
+            throw new Error(`${record.id} is not exposed to agents`);
+        const existing = this.active.get(record.id);
+        if (existing !== undefined) {
+            existing.dispose();
+            this.active.delete(record.id);
+        }
+        const occupant = this.tools.get(record.name);
+        if (occupant !== undefined) {
+            throw new Error(`custom-tool-name-conflict: ${record.name} is already registered`);
+        }
+        const definition = compileCustomTool(record, this.execute);
+        const dispose = this.tools.register(definition);
+        const registration = {
+            id: record.id,
+            name: record.name,
+            version: record.version,
+            dispose,
+        };
+        this.active.set(record.id, registration);
+        return registration;
+    }
+    /** Dispose one id; false when it was not live. */
+    dispose(id) {
+        const active = this.active.get(id);
+        if (active === undefined)
+            return false;
+        active.dispose();
+        this.active.delete(id);
+        return true;
+    }
+    /** Dispose everything (plugin teardown). */
+    disposeAll() {
+        for (const registration of this.active.values())
+            registration.dispose();
+        this.active.clear();
+    }
+    /**
+     * 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() {
+        const registered = [];
+        const skipped = [];
+        const errors = [];
+        const wanted = new Set();
+        for (const id of this.store.listIds()) {
+            let record;
+            try {
+                record = this.store.read(id);
+            }
+            catch (error) {
+                errors.push({
+                    id,
+                    version: null,
+                    reason: error instanceof CustomToolStoreError ? error.message : String(error),
+                });
+                continue;
+            }
+            if (record === undefined)
+                continue;
+            if (!record.enabled) {
+                this.dispose(id);
+                skipped.push({ id, version: record.version, reason: 'disabled' });
+                continue;
+            }
+            if (!record.policy.agentExpose) {
+                this.dispose(id);
+                skipped.push({ id, version: record.version, reason: 'not-agent-exposed' });
+                continue;
+            }
+            wanted.add(id);
+            const live = this.active.get(id);
+            if (live?.version === record.version) {
+                registered.push({ id, version: record.version, reason: 'already registered' });
+                continue;
+            }
+            try {
+                const next = this.register(record);
+                registered.push({ id, version: next.version, reason: 'registered' });
+            }
+            catch (error) {
+                errors.push({ id, version: record.version, reason: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        for (const id of [...this.active.keys()]) {
+            if (!wanted.has(id))
+                this.dispose(id);
+        }
+        return { registered, skipped, errors };
+    }
+}
+//# sourceMappingURL=registry.js.map

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

@@ -0,0 +1,26 @@
+/**
+ * Custom-tool draft validation.
+ *
+ * Validation is deliberately split from compilation: a draft may be incomplete
+ * and is returned as a list of field issues, while only a validated draft can be
+ * compiled or persisted. No network, filesystem or model work happens here.
+ *
+ * @module @try-works/dsh-tool-mode/custom-tools/schema
+ */
+import type { CustomToolDraft, CustomToolIssue, CustomToolValidation } from './types.ts';
+/** A validated record failure carrying every issue, not just the first. */
+export declare class CustomToolSchemaError extends Error {
+    readonly name = "CustomToolSchemaError";
+    readonly issues: readonly CustomToolIssue[];
+    constructor(issues: readonly CustomToolIssue[]);
+}
+/** Validate and normalize one draft. */
+export declare function validateCustomToolDraft(raw: unknown): CustomToolValidation;
+/**
+ * Validate and normalize a draft, throwing one named error with every issue.
+ * @param raw - unknown decoded JSON.
+ * @returns the normalized draft.
+ * @throws CustomToolSchemaError when any field is invalid.
+ */
+export declare function normalizeCustomToolDraft(raw: unknown): CustomToolDraft;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/custom-tools/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAGV,eAAe,EAGf,eAAe,EAEf,oBAAoB,EAIrB,MAAM,YAAY,CAAA;AAMnB,2EAA2E;AAC3E,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,SAAkB,IAAI,2BAA0B;IAChD,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAA;gBAE/B,MAAM,EAAE,SAAS,eAAe,EAAE;CAI/C;AAgND,wCAAwC;AACxC,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,GAAG,oBAAoB,CAuE1E;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,OAAO,GAAG,eAAe,CAqCtE"}

package/lib/custom-tools/schema.js

@@ -0,0 +1,375 @@
+/**
+ * Custom-tool draft validation.
+ *
+ * Validation is deliberately split from compilation: a draft may be incomplete
+ * and is returned as a list of field issues, while only a validated draft can be
+ * compiled or persisted. No network, filesystem or model work happens here.
+ *
+ * @module @try-works/dsh-tool-mode/custom-tools/schema
+ */
+const ID_PATTERN = /^custom\.[a-z0-9][a-z0-9-]*$/;
+const NAME_PATTERN = /^custom_[a-z0-9][a-z0-9_]*$/;
+const TOOL_NAME_PATTERN = /^[a-z][a-z0-9_]*$/;
+/** A validated record failure carrying every issue, not just the first. */
+export class CustomToolSchemaError extends Error {
+    name = 'CustomToolSchemaError';
+    issues;
+    constructor(issues) {
+        super(issues.map(issue => `${issue.path}: ${issue.message}`).join('; '));
+        this.issues = issues;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+/** Validate an object-shaped JSON Schema used for tool arguments. */
+function schemaIssues(value, path, issues) {
+    if (!isRecord(value)) {
+        issues.push({ path, message: 'must be a JSON Schema object' });
+        return;
+    }
+    if (value['type'] !== 'object') {
+        issues.push({ path: `${path}.type`, message: 'must be "object" for tool arguments' });
+    }
+    const properties = value['properties'];
+    if (properties !== undefined && !isRecord(properties)) {
+        issues.push({ path: `${path}.properties`, message: 'must be an object' });
+    }
+    const required = value['required'];
+    if (required !== undefined) {
+        if (!Array.isArray(required) || required.some(item => typeof item !== 'string')) {
+            issues.push({ path: `${path}.required`, message: 'must be an array of property names' });
+        }
+        else if (isRecord(properties)) {
+            for (const name of required) {
+                if (!(name in properties))
+                    issues.push({ path: `${path}.required`, message: `unknown property ${JSON.stringify(name)}` });
+            }
+        }
+    }
+}
+function validateHttp(value, issues) {
+    if (!isRecord(value)) {
+        issues.push({ path: 'execution.http', message: 'must be an object' });
+        return undefined;
+    }
+    const method = value['method'];
+    if (!['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].includes(String(method))) {
+        issues.push({ path: 'execution.http.method', message: 'must be GET, POST, PUT, PATCH or DELETE' });
+    }
+    const url = value['url'];
+    if (!nonEmptyString(url)) {
+        issues.push({ path: 'execution.http.url', message: 'must be a non-empty URL template' });
+    }
+    else {
+        const literal = url.replace(/\{\{[A-Za-z_][A-Za-z0-9_]*\}\}/g, 'x');
+        try {
+            const parsed = new URL(literal);
+            if (parsed.protocol !== 'https:')
+                issues.push({ path: 'execution.http.url', message: 'must use https' });
+            if (parsed.username !== '' || parsed.password !== '')
+                issues.push({ path: 'execution.http.url', message: 'must not embed credentials' });
+        }
+        catch {
+            issues.push({ path: 'execution.http.url', message: 'must be a valid absolute https URL' });
+        }
+    }
+    const headers = {};
+    if (value['headers'] !== undefined) {
+        if (!isRecord(value['headers'])) {
+            issues.push({ path: 'execution.http.headers', message: 'must be an object' });
+        }
+        else {
+            for (const [name, header] of Object.entries(value['headers'])) {
+                if (typeof header === 'string')
+                    headers[name] = header;
+                else if (isRecord(header) && nonEmptyString(header['secret']))
+                    headers[name] = { secret: header['secret'] };
+                else
+                    issues.push({ path: `execution.http.headers.${name}`, message: 'must be a string or { secret: "NAME" }' });
+            }
+        }
+    }
+    let bodyTemplate;
+    if (value['bodyTemplate'] !== undefined) {
+        if (typeof value['bodyTemplate'] !== 'string')
+            issues.push({ path: 'execution.http.bodyTemplate', message: 'must be a string' });
+        else
+            bodyTemplate = value['bodyTemplate'];
+    }
+    let extract;
+    if (value['extract'] !== undefined) {
+        if (typeof value['extract'] !== 'string')
+            issues.push({ path: 'execution.http.extract', message: 'must be a dot path string' });
+        else
+            extract = value['extract'];
+    }
+    return {
+        method: method,
+        url: typeof url === 'string' ? url.trim() : '',
+        headers,
+        ...bodyTemplate === undefined ? {} : { bodyTemplate },
+        ...extract === undefined ? {} : { extract },
+    };
+}
+function validatePrompt(value, issues) {
+    if (!isRecord(value)) {
+        issues.push({ path: 'execution.prompt', message: 'must be an object' });
+        return undefined;
+    }
+    if (!nonEmptyString(value['template']))
+        issues.push({ path: 'execution.prompt.template', message: 'must be a non-empty template' });
+    let model;
+    if (value['model'] !== undefined) {
+        if (!nonEmptyString(value['model']))
+            issues.push({ path: 'execution.prompt.model', message: 'must be a non-empty model id' });
+        else
+            model = value['model'];
+    }
+    let maxOutputTokens;
+    if (value['maxOutputTokens'] !== undefined) {
+        if (typeof value['maxOutputTokens'] !== 'number' || !Number.isInteger(value['maxOutputTokens'])
+            || value['maxOutputTokens'] < 1 || value['maxOutputTokens'] > 8192) {
+            issues.push({ path: 'execution.prompt.maxOutputTokens', message: 'must be an integer between 1 and 8192' });
+        }
+        else
+            maxOutputTokens = value['maxOutputTokens'];
+    }
+    return {
+        template: typeof value['template'] === 'string' ? value['template'] : '',
+        ...model === undefined ? {} : { model },
+        ...maxOutputTokens === undefined ? {} : { maxOutputTokens },
+    };
+}
+function validateComposite(value, issues) {
+    if (!isRecord(value) || !Array.isArray(value['steps'])) {
+        issues.push({ path: 'execution.composite.steps', message: 'must be an array of steps' });
+        return undefined;
+    }
+    if (value['steps'].length === 0)
+        issues.push({ path: 'execution.composite.steps', message: 'must contain at least one step' });
+    if (value['steps'].length > 10)
+        issues.push({ path: 'execution.composite.steps', message: 'may contain at most 10 steps' });
+    const steps = [];
+    value['steps'].forEach((raw, index) => {
+        if (!isRecord(raw)) {
+            issues.push({ path: `execution.composite.steps.${index}`, message: 'must be an object' });
+            return;
+        }
+        const tool = raw['tool'];
+        if (!nonEmptyString(tool) || !TOOL_NAME_PATTERN.test(tool)) {
+            issues.push({ path: `execution.composite.steps.${index}.tool`, message: 'must be a valid tool name' });
+        }
+        const args = {};
+        if (raw['args'] !== undefined) {
+            if (!isRecord(raw['args']))
+                issues.push({ path: `execution.composite.steps.${index}.args`, message: 'must be an object of string templates' });
+            else {
+                for (const [key, arg] of Object.entries(raw['args'])) {
+                    if (typeof arg !== 'string')
+                        issues.push({ path: `execution.composite.steps.${index}.args.${key}`, message: 'must be a string template' });
+                    else
+                        args[key] = arg;
+                }
+            }
+        }
+        const requiresApproval = raw['requiresApproval'];
+        if (requiresApproval !== undefined && typeof requiresApproval !== 'boolean') {
+            issues.push({ path: `execution.composite.steps.${index}.requiresApproval`, message: 'must be boolean' });
+        }
+        if (typeof tool === 'string') {
+            steps.push({
+                tool,
+                args,
+                ...requiresApproval === true ? { requiresApproval: true } : {},
+            });
+        }
+    });
+    let output;
+    if (value['output'] !== undefined) {
+        if (typeof value['output'] !== 'string')
+            issues.push({ path: 'execution.composite.output', message: 'must be a string template' });
+        else
+            output = value['output'];
+    }
+    return { steps, ...output === undefined ? {} : { output } };
+}
+function validateExecution(value, issues) {
+    if (!isRecord(value)) {
+        issues.push({ path: 'execution', message: 'must be an object' });
+        return undefined;
+    }
+    switch (value['kind']) {
+        case 'http': {
+            const http = validateHttp(value['http'], issues);
+            return http === undefined ? undefined : { kind: 'http', http };
+        }
+        case 'prompt': {
+            const prompt = validatePrompt(value['prompt'], issues);
+            return prompt === undefined ? undefined : { kind: 'prompt', prompt };
+        }
+        case 'composite': {
+            const composite = validateComposite(value['composite'], issues);
+            return composite === undefined ? undefined : { kind: 'composite', composite };
+        }
+        default:
+            issues.push({ path: 'execution.kind', message: 'must be http, prompt or composite' });
+            return undefined;
+    }
+}
+function normalizeOrigins(value, issues) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value)) {
+        issues.push({ path: 'policy.networkOrigins', message: 'must be an array of origins' });
+        return [];
+    }
+    const origins = [];
+    for (const raw of value) {
+        if (typeof raw !== 'string') {
+            issues.push({ path: 'policy.networkOrigins', message: 'every origin must be a string' });
+            continue;
+        }
+        try {
+            const parsed = new URL(raw);
+            if (parsed.protocol !== 'https:' || parsed.origin !== raw.replace(/\/$/, '')) {
+                issues.push({ path: 'policy.networkOrigins', message: `${JSON.stringify(raw)} must be an exact https origin` });
+            }
+            else
+                origins.push(parsed.origin);
+        }
+        catch {
+            issues.push({ path: 'policy.networkOrigins', message: `${JSON.stringify(raw)} is not an absolute origin` });
+        }
+    }
+    return [...new Set(origins)];
+}
+/** Validate and normalize one draft. */
+export function validateCustomToolDraft(raw) {
+    const issues = [];
+    if (!isRecord(raw))
+        return { ok: false, issues: [{ path: '', message: 'draft must be an object' }] };
+    const id = raw['id'];
+    if (!nonEmptyString(id) || !ID_PATTERN.test(id)) {
+        issues.push({ path: 'id', message: 'must look like custom.<lowercase-slug>' });
+    }
+    const name = raw['name'];
+    if (!nonEmptyString(name) || !NAME_PATTERN.test(name)) {
+        issues.push({ path: 'name', message: 'must look like custom_<lowercase_slug>' });
+    }
+    if (typeof id === 'string' && typeof name === 'string') {
+        const expected = `custom_${id.slice('custom.'.length).replaceAll('-', '_')}`;
+        if (name !== expected)
+            issues.push({ path: 'name', message: `must be ${expected}` });
+    }
+    if (!nonEmptyString(raw['title']))
+        issues.push({ path: 'title', message: 'must be a non-empty title' });
+    if (!nonEmptyString(raw['description']))
+        issues.push({ path: 'description', message: 'must explain when the agent should use the tool' });
+    schemaIssues(raw['parameters'], 'parameters', issues);
+    if (raw['outputSchema'] !== undefined)
+        schemaIssues(raw['outputSchema'], 'outputSchema', issues);
+    const execution = validateExecution(raw['execution'], issues);
+    if (execution?.kind === 'http' && execution.http.url !== '') {
+        // The runtime executor enforces the origin allowlist and DNS checks; the
+        // draft only states that the allowlist is present.
+        if (!Array.isArray(raw['policy']?.['networkOrigins'])
+            || raw['policy']['networkOrigins'].length === 0) {
+            issues.push({ path: 'policy.networkOrigins', message: 'HTTP tools require at least one exact https origin' });
+        }
+    }
+    if (!isRecord(raw['policy'])) {
+        issues.push({ path: 'policy', message: 'must be an object' });
+    }
+    const timeout = isRecord(raw['policy']) ? raw['policy']['timeoutMs'] : undefined;
+    if (timeout !== undefined && (typeof timeout !== 'number' || !Number.isInteger(timeout) || timeout < 1000 || timeout > 120_000)) {
+        issues.push({ path: 'policy.timeoutMs', message: 'must be an integer between 1000 and 120000' });
+    }
+    if (isRecord(raw['policy'])) {
+        for (const key of ['readOnly', 'agentExpose', 'mcpExpose']) {
+            const value = raw['policy'][key];
+            if (value !== undefined && typeof value !== 'boolean') {
+                issues.push({ path: `policy.${key}`, message: 'must be boolean' });
+            }
+        }
+        normalizeOrigins(raw['policy']['networkOrigins'], issues);
+    }
+    const examples = [];
+    if (raw['examples'] !== undefined) {
+        if (!Array.isArray(raw['examples']))
+            issues.push({ path: 'examples', message: 'must be an array' });
+        else {
+            raw['examples'].slice(0, 10).forEach((entry, index) => {
+                if (!isRecord(entry)) {
+                    issues.push({ path: `examples.${index}`, message: 'must be an object' });
+                    return;
+                }
+                const title = entry['title'];
+                const args = entry['arguments'];
+                if (!nonEmptyString(title))
+                    issues.push({ path: `examples.${index}.title`, message: 'must be a non-empty title' });
+                if (!isRecord(args))
+                    issues.push({ path: `examples.${index}.arguments`, message: 'must be an object' });
+                else
+                    examples.push({ title: typeof title === 'string' ? title : '', arguments: args });
+            });
+        }
+    }
+    if (issues.length > 0 || execution === undefined)
+        return { ok: false, issues };
+    return {
+        ok: true,
+        issues: [],
+    };
+}
+/**
+ * Validate and normalize a draft, throwing one named error with every issue.
+ * @param raw - unknown decoded JSON.
+ * @returns the normalized draft.
+ * @throws CustomToolSchemaError when any field is invalid.
+ */
+export function normalizeCustomToolDraft(raw) {
+    const verdict = validateCustomToolDraft(raw);
+    if (!verdict.ok)
+        throw new CustomToolSchemaError(verdict.issues);
+    // SAFETY: validateCustomToolDraft checked every field this rebuild reads.
+    const record = raw;
+    const execution = validateExecution(record['execution'], []);
+    if (execution === undefined)
+        throw new CustomToolSchemaError([{ path: 'execution', message: 'invalid execution' }]);
+    const policyRaw = isRecord(record['policy']) ? record['policy'] : {};
+    const policy = {
+        timeoutMs: typeof policyRaw['timeoutMs'] === 'number' ? policyRaw['timeoutMs'] : 15_000,
+        readOnly: policyRaw['readOnly'] === true,
+        networkOrigins: normalizeOrigins(policyRaw['networkOrigins'], []),
+        agentExpose: policyRaw['agentExpose'] !== false,
+        mcpExpose: policyRaw['mcpExpose'] === true,
+    };
+    const examplesRaw = Array.isArray(record['examples']) ? record['examples'] : [];
+    const examples = [];
+    for (const entry of examplesRaw.slice(0, 10)) {
+        if (!isRecord(entry) || !isRecord(entry['arguments']))
+            continue;
+        examples.push({
+            title: typeof entry['title'] === 'string' ? entry['title'] : '',
+            arguments: entry['arguments'],
+        });
+    }
+    return {
+        id: String(record['id']),
+        name: String(record['name']),
+        title: String(record['title']),
+        description: String(record['description']),
+        parameters: record['parameters'],
+        ...record['outputSchema'] === undefined
+            ? {}
+            : { outputSchema: record['outputSchema'] },
+        execution,
+        policy,
+        examples,
+    };
+}
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,90 @@
+/**
+ * Host service for authoring, testing and registering custom tools.
+ *
+ * This is the single seam behind the Remote methods and the plugin's startup
+ * restore. It owns no UI and no transport; every external dependency (model,
+ * credential store, tool dispatcher, fetch) is injected.
+ *
+ * @module @try-works/dsh-tool-mode/custom-tools/service
+ */
+import { type CustomToolDispatchDeps } from './dispatch.ts';
+import { CustomToolRegistrar } from './registry.ts';
+import { CustomToolStore } from './store.ts';
+import type { CustomToolDraft, CustomToolRecord, CustomToolValidation } from './types.ts';
+/** One row safe for the Create-tool list. */
+export interface CustomToolSummary {
+    readonly id: string;
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    readonly kind: CustomToolRecord['execution']['kind'];
+    readonly version: number;
+    readonly enabled: boolean;
+    readonly agentExpose: boolean;
+    readonly mcpExpose: boolean;
+    readonly updatedAt: string;
+}
+/** The Create-tool tab's read model. */
+export interface CustomToolsSnapshot {
+    readonly store: string;
+    readonly writable: boolean;
+    readonly tools: readonly CustomToolSummary[];
+}
+/** The result of a test invocation. */
+export interface CustomToolTestResult {
+    readonly ok: boolean;
+    readonly value?: unknown;
+    readonly error?: {
+        readonly code: string;
+        readonly message: string;
+    };
+}
+/** A model-authored draft, never saved by the draft call itself. */
+export interface CustomToolDraftResult {
+    readonly ok: boolean;
+    readonly draft?: CustomToolDraft;
+    readonly error?: {
+        readonly code: string;
+        readonly message: string;
+    };
+}
+/** Host-level seams. */
+export interface CustomToolsServiceOptions {
+    readonly store: CustomToolStore;
+    readonly registrar: CustomToolRegistrar;
+    readonly dispatch?: CustomToolDispatchDeps;
+    /** Resolve a credential reference; used by HTTP tools. */
+    readonly resolveCredential?: (name: string) => Promise<string | undefined>;
+    /** One host-model call for agent drafts; absent disables drafting. */
+    readonly draftModel?: (prompt: string, signal: AbortSignal) => Promise<string>;
+}
+/** The service used by Remote and startup restore. */
+export declare class CustomToolsService {
+    readonly store: CustomToolStore;
+    readonly registrar: CustomToolRegistrar;
+    private readonly dispatch;
+    private readonly draftModel;
+    constructor(options: CustomToolsServiceOptions);
+    /** Read the list model without exposing definitions or secrets. */
+    describe(): CustomToolsSnapshot;
+    /** Read one full record for editing; header secret values are references only. */
+    get(id: string): CustomToolRecord | undefined;
+    /** Restore every enabled, agent-exposed tool at startup. */
+    sync(): import("./registry.ts").CustomToolSyncResult;
+    /** Validate a draft without persisting it. */
+    validate(raw: unknown): CustomToolValidation;
+    /** Execute a draft once; never persists or registers it. */
+    test(raw: unknown, args: Readonly<Record<string, unknown>>): Promise<CustomToolTestResult>;
+    /**
+     * Ask the host model for a draft from a natural-language description. The
+     * result is validated but never saved, registered or executed.
+     */
+    draft(description: string): Promise<CustomToolDraftResult>;
+    /** Validate, persist a new immutable version and register it when exposed. */
+    save(raw: unknown): CustomToolRecord;
+    /** Enable/disable one tool and reconcile the live registration. */
+    setEnabled(id: string, enabled: boolean): CustomToolRecord;
+    /** Delete the active pointer and remove the live tool. */
+    delete(id: string): boolean;
+}
+//# sourceMappingURL=service.d.ts.map

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

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