@cjhyy/code-shell-core 0.8.13 → 0.9.0

package/dist/tool-system/builtin/configure-model-connection.js

@@ -0,0 +1,396 @@
+/**
+ * ConfigureModelConnection — safely materialize one catalog model into the
+ * unified settings.modelConnections store without exposing or copying API
+ * keys. The write is schema-validated, lock-protected, atomic, and updates the
+ * selected tag default in the same transaction when requested.
+ */
+import { SettingsManager } from "../../settings/manager.js";
+import { getMergedCatalog } from "../../model-catalog/index.js";
+import { modelEntriesFromConnections } from "../../engine/model-connections-pool.js";
+import { ModelPool } from "../../llm/model-pool.js";
+import { createLLMClient } from "../../llm/client-factory.js";
+import { isCredentialCompatible, } from "../../model-catalog/resolve.js";
+import { notifySettingsChanged } from "./settings-changed.js";
+function redactCredentialSecrets(message, credentials) {
+    let redacted = message;
+    for (const credential of credentials) {
+        if (credential.apiKey)
+            redacted = redacted.replaceAll(credential.apiKey, "[REDACTED]");
+    }
+    return redacted;
+}
+export async function probeTextModelConnection(connection, credentials, catalog, options = {}) {
+    const entry = modelEntriesFromConnections([connection], credentials, catalog)[0];
+    if (!entry)
+        return { ok: false, error: "the saved connection could not be resolved" };
+    const pool = new ModelPool([entry]);
+    const config = pool.toLLMConfig(entry);
+    try {
+        const client = await (options.createClient ?? createLLMClient)(config, {
+            temperature: 0,
+            timeout: 30_000,
+            retryMaxAttempts: 1,
+            ...(options.fetch ? { fetch: options.fetch } : {}),
+        });
+        const response = await client.createMessage({
+            systemPrompt: "You are a connection health check. Follow the user's reply instruction.",
+            messages: [{ role: "user", content: "Reply with READY only." }],
+            tools: [],
+            maxTokens: 32,
+            stream: false,
+            signal: AbortSignal.timeout(30_000),
+            requestVisible: false,
+        });
+        return {
+            ok: true,
+            response: response.text.slice(0, 200),
+            stopReason: response.stopReason,
+            ...(response.usage
+                ? {
+                    usage: {
+                        promptTokens: response.usage.promptTokens,
+                        completionTokens: response.usage.completionTokens,
+                        totalTokens: response.usage.totalTokens,
+                    },
+                }
+                : {}),
+        };
+    }
+    catch (error) {
+        const raw = error instanceof Error ? error.message : String(error);
+        const safeError = redactCredentialSecrets(raw, credentials);
+        return { ok: false, error: safeError.slice(0, 1000) };
+    }
+}
+const DEFAULT_DEPS = {
+    makeSettingsManager: (cwd, scope) => new SettingsManager(cwd, scope),
+    getCatalog: getMergedCatalog,
+    notifySettingsChanged,
+    testTextConnection: probeTextModelConnection,
+};
+export const configureModelConnectionToolDef = {
+    name: "ConfigureModelConnection",
+    description: "Create or update a configured model connection from an existing catalog model. " +
+        "Use this after EditModelCatalog when the user wants the model ready to use, not merely " +
+        "listed as a template. It validates the catalog model, reuses a compatible existing " +
+        "credential by id (never returns or copies its API key), seeds catalog parameter defaults, " +
+        "and atomically updates modelConnections plus defaults. User scope requires a full/trusted " +
+        "host context. If more than one compatible credential exists, pass credentialId explicitly. " +
+        "Set testConnection=true to make one small real request and report whether routing worked.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            catalogId: {
+                type: "string",
+                description: "Existing merged catalog provider id, e.g. 'openrouter'.",
+            },
+            model: {
+                type: "string",
+                description: "Exact model preset value in that provider, e.g. 'openai/gpt-5.6-luna'.",
+            },
+            connectionId: {
+                type: "string",
+                description: "Optional stable instance id. Omit to update an existing connection for the same " +
+                    "catalog model or generate a collision-free id.",
+            },
+            credentialId: {
+                type: "string",
+                description: "Existing compatible credential id. Omit to reuse the current connection credential " +
+                    "or auto-select when exactly one compatible credential exists.",
+            },
+            paramValues: {
+                type: "object",
+                description: "Optional model parameter overrides keyed by catalog ParamSpec name. Catalog defaults " +
+                    "are seeded first; unknown names or invalid enum/type/range values are rejected.",
+            },
+            setDefault: {
+                type: "boolean",
+                description: "Set this connection as the default for its catalog tag. The first configured " +
+                    "connection for a tag becomes default automatically.",
+            },
+            testConnection: {
+                type: "boolean",
+                description: "After saving a text connection, send one small real request through it. This may " +
+                    "incur a tiny provider charge. A failed test is reported without rolling back the " +
+                    "validated connection.",
+            },
+            scope: {
+                type: "string",
+                enum: ["user", "project"],
+                description: "Settings layer to update. Defaults to user in a full desktop host, otherwise project.",
+            },
+        },
+        required: ["catalogId", "model"],
+    },
+};
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function connectionIdIsSafe(value) {
+    return /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
+}
+function slugPart(value) {
+    return (value
+        .toLowerCase()
+        .split("/")
+        .filter(Boolean)
+        .pop()
+        ?.replace(/[^a-z0-9._-]+/gu, "-")
+        .replace(/^-+|-+$/gu, "") || "model");
+}
+function uniqueConnectionId(entry, model, taken) {
+    const base = !taken.has(entry.id) ? entry.id : `${entry.id}-${slugPart(model)}`;
+    if (!taken.has(base))
+        return base;
+    let suffix = 2;
+    while (taken.has(`${base}-${suffix}`))
+        suffix += 1;
+    return `${base}-${suffix}`;
+}
+function paramDefaults(preset) {
+    const values = {};
+    for (const spec of preset.params ?? []) {
+        if (spec.default !== undefined)
+            values[spec.name] = spec.default;
+    }
+    return values;
+}
+function validateParamValue(spec, value) {
+    if (spec.control === "enum") {
+        if (typeof value !== "string")
+            return "must be a string enum value";
+        if (spec.options?.length && !spec.options.includes(value)) {
+            return `must be one of [${spec.options.join(", ")}]`;
+        }
+        return undefined;
+    }
+    if (spec.control === "number") {
+        if (typeof value !== "number" || !Number.isFinite(value))
+            return "must be a finite number";
+        if (spec.min !== undefined && value < spec.min)
+            return `must be >= ${spec.min}`;
+        if (spec.max !== undefined && value > spec.max)
+            return `must be <= ${spec.max}`;
+        return undefined;
+    }
+    if (spec.control === "toggle") {
+        return typeof value === "boolean" ? undefined : "must be a boolean";
+    }
+    return typeof value === "string" ? undefined : "must be a string";
+}
+function validateParamValues(values, specs) {
+    if (Object.keys(values).length > 64)
+        return "paramValues exceeds 64 entries";
+    const byName = new Map(specs.map((spec) => [spec.name, spec]));
+    for (const [name, value] of Object.entries(values)) {
+        const spec = byName.get(name);
+        if (!spec)
+            return `unknown parameter "${name}" for this model`;
+        const issue = validateParamValue(spec, value);
+        if (issue)
+            return `parameter "${name}" ${issue}`;
+    }
+    return undefined;
+}
+function connectionsFrom(settings) {
+    return Array.isArray(settings.modelConnections)
+        ? settings.modelConnections
+        : [];
+}
+function credentialsFrom(settings) {
+    return Array.isArray(settings.credentials) ? settings.credentials : [];
+}
+function findTargetConnection(connections, entry, model, explicitId) {
+    if (explicitId)
+        return connections.find((connection) => connection.id === explicitId);
+    return connections.find((connection) => connection.catalogId === entry.id &&
+        connection.tag === entry.tag &&
+        connection.model === model);
+}
+function selectCredential(entry, catalog, credentials, requestedId, existingId) {
+    const compatible = credentials.filter((credential) => isCredentialCompatible(entry, credential, catalog) &&
+        (entry.needsKey === false || Boolean(credential.apiKey?.trim())));
+    const selectedId = requestedId ?? existingId;
+    if (selectedId) {
+        const selected = credentials.find((credential) => credential.id === selectedId);
+        if (!selected)
+            return { error: `credential "${selectedId}" does not exist in this scope` };
+        if (!isCredentialCompatible(entry, selected, catalog)) {
+            return { error: `credential "${selectedId}" is not compatible with catalog "${entry.id}"` };
+        }
+        if (entry.needsKey !== false && !selected.apiKey?.trim()) {
+            return { error: `credential "${selectedId}" has no usable API key` };
+        }
+        return { credentialId: selected.id };
+    }
+    if (entry.needsKey === false)
+        return {};
+    if (compatible.length === 1)
+        return { credentialId: compatible[0].id };
+    if (compatible.length === 0) {
+        return { error: `no compatible credential is configured for catalog "${entry.id}"` };
+    }
+    return {
+        error: `multiple compatible credentials exist for catalog "${entry.id}": ` +
+            `${compatible.map((credential) => credential.id).join(", ")}. Pass credentialId explicitly.`,
+    };
+}
+export async function configureModelConnectionTool(args, ctx, deps = DEFAULT_DEPS) {
+    if (!ctx)
+        return "Error: ConfigureModelConnection requires a scoped tool context.";
+    if (ctx.settingsScope === "isolated") {
+        return "Error: isolated sessions cannot persist model connections.";
+    }
+    const requestedScope = args.scope;
+    const scope = requestedScope === "user" || requestedScope === "project"
+        ? requestedScope
+        : ctx.settingsScope === "full"
+            ? "user"
+            : "project";
+    if (scope === "user" && ctx.settingsScope !== "full") {
+        return "Error: user-scope model connections require settingsScope=full.";
+    }
+    const catalogId = typeof args.catalogId === "string" ? args.catalogId.trim() : "";
+    const model = typeof args.model === "string" ? args.model.trim() : "";
+    const connectionId = typeof args.connectionId === "string" ? args.connectionId.trim() : undefined;
+    const credentialId = typeof args.credentialId === "string" ? args.credentialId.trim() : undefined;
+    if (!catalogId)
+        return "Error: catalogId is required.";
+    if (!model)
+        return "Error: model is required.";
+    if (connectionId && !connectionIdIsSafe(connectionId)) {
+        return "Error: connectionId must be 1-128 safe id characters (letters, numbers, . _ : -).";
+    }
+    if (args.paramValues !== undefined && !isRecord(args.paramValues)) {
+        return "Error: paramValues must be an object.";
+    }
+    if (args.setDefault !== undefined && typeof args.setDefault !== "boolean") {
+        return "Error: setDefault must be a boolean.";
+    }
+    if (args.testConnection !== undefined && typeof args.testConnection !== "boolean") {
+        return "Error: testConnection must be a boolean.";
+    }
+    const catalog = deps.getCatalog();
+    const entry = catalog.find((candidate) => candidate.id === catalogId);
+    if (!entry)
+        return `Error: catalog "${catalogId}" does not exist.`;
+    const preset = entry.modelPresets?.find((candidate) => candidate.value === model);
+    if (!preset) {
+        return `Error: model "${model}" is not declared in catalog "${catalogId}".`;
+    }
+    if (args.testConnection === true && entry.tag !== "text") {
+        return "Error: testConnection currently supports text catalog entries only.";
+    }
+    const manager = deps.makeSettingsManager(ctx.cwd, ctx.settingsScope === "full" ? "full" : "project");
+    let effectiveSettings;
+    let targetSettings;
+    try {
+        effectiveSettings = manager.get();
+        targetSettings = manager.getForScope(scope, ctx.cwd);
+    }
+    catch (error) {
+        return `Error: settings validation failed: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    const targetConnections = connectionsFrom(targetSettings);
+    const preflightExisting = findTargetConnection(targetConnections, entry, model, connectionId);
+    if (connectionId &&
+        preflightExisting &&
+        (preflightExisting.catalogId !== entry.id || preflightExisting.tag !== entry.tag)) {
+        return `Error: connectionId "${connectionId}" already belongs to another catalog or tag.`;
+    }
+    const effectiveCredentials = scope === "user" ? credentialsFrom(targetSettings) : credentialsFrom(effectiveSettings);
+    const selected = selectCredential(entry, catalog, effectiveCredentials, credentialId, preflightExisting?.credentialId);
+    if (selected.error)
+        return `Error: ${selected.error}`;
+    const providedParams = args.paramValues;
+    let outcome;
+    try {
+        manager.mutateSettingsForScope(scope, ctx.cwd, (current) => {
+            const connections = connectionsFrom(current);
+            const existing = findTargetConnection(connections, entry, model, connectionId);
+            if (connectionId &&
+                existing &&
+                (existing.catalogId !== entry.id || existing.tag !== entry.tag)) {
+                throw new Error(`connectionId "${connectionId}" was concurrently claimed`);
+            }
+            // Revalidate user-scope credential references inside the same locked
+            // file transaction so a concurrent credential deletion cannot leave a
+            // newly written dangling reference. Project connections may intentionally
+            // inherit a user credential from the effective settings layer.
+            if (scope === "user" && selected.credentialId) {
+                const lockedSelection = selectCredential(entry, catalog, credentialsFrom(current), selected.credentialId, undefined);
+                if (lockedSelection.error)
+                    throw new Error(lockedSelection.error);
+            }
+            const id = existing?.id ??
+                connectionId ??
+                uniqueConnectionId(entry, model, new Set(connections.map((connection) => connection.id)));
+            const defaults = paramDefaults(preset);
+            const keepExistingParams = existing?.model === model && providedParams === undefined;
+            const paramValues = keepExistingParams
+                ? (existing?.paramValues ?? defaults)
+                : { ...defaults, ...(providedParams ?? {}) };
+            const paramIssue = validateParamValues(paramValues, preset.params ?? []);
+            if (paramIssue)
+                throw new Error(paramIssue);
+            const connection = {
+                ...(existing ?? {}),
+                id,
+                catalogId: entry.id,
+                tag: entry.tag,
+                model,
+                ...(selected.credentialId ? { credentialId: selected.credentialId } : {}),
+                ...(Object.keys(paramValues).length > 0 ? { paramValues } : {}),
+            };
+            if (!selected.credentialId)
+                delete connection.credentialId;
+            if (Object.keys(paramValues).length === 0)
+                delete connection.paramValues;
+            const nextConnections = existing
+                ? connections.map((candidate) => (candidate.id === existing.id ? connection : candidate))
+                : [...connections, connection];
+            current.modelConnections = nextConnections;
+            const rawDefaults = isRecord(current.defaults) ? current.defaults : {};
+            const becameDefault = args.setDefault === true || typeof rawDefaults[entry.tag] !== "string";
+            if (becameDefault)
+                current.defaults = { ...rawDefaults, [entry.tag]: id };
+            outcome = {
+                action: existing ? "updated" : "added",
+                connection,
+                becameDefault,
+            };
+        });
+    }
+    catch (error) {
+        return `Error: could not configure model connection: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    if (!outcome)
+        return "Error: model connection write produced no result.";
+    deps.notifySettingsChanged();
+    let verification;
+    if (args.testConnection === true) {
+        try {
+            // Reload credential metadata after the settings transaction. This avoids
+            // probing with a stale key if another settings writer rotated it between
+            // preflight and persistence.
+            const refreshed = scope === "user" ? manager.getForScope("user", ctx.cwd) : manager.get();
+            verification = await deps.testTextConnection(outcome.connection, credentialsFrom(refreshed), catalog);
+        }
+        catch (error) {
+            const raw = error instanceof Error ? error.message : String(error);
+            verification = {
+                ok: false,
+                error: `could not start connection test: ${redactCredentialSecrets(raw, effectiveCredentials)}`.slice(0, 1000),
+            };
+        }
+    }
+    return JSON.stringify({
+        ok: true,
+        action: outcome.action,
+        scope,
+        connection: outcome.connection,
+        defaultForTag: outcome.becameDefault ? entry.tag : undefined,
+        hotReloadRequested: true,
+        ...(verification ? { verification } : {}),
+    }, null, 2);
+}

package/dist/tool-system/builtin/cron.d.ts

@@ -3,6 +3,7 @@
  */
 import type { ToolDefinition } from "../../types.js";
 import type { ToolContext } from "../context.js";
+import type { CronJob, CreateJobOptions } from "../../automation/scheduler.js";
 export { cronListToolDef } from "./cron-list.definition.js";
 /** Sink notified after a cron job is created/deleted, so the host (Electron
  *  main) can reload+arm the scheduler that actually executes jobs. The worker
@@ -10,6 +11,16 @@ export { cronListToolDef } from "./cron-list.definition.js";
  *  host never learns about an AI-created job until the user opens the UI. */
 type CronChangedSink = () => void;
 export declare function setCronChangedSink(sink: CronChangedSink | null): void;
+export interface CronCreateAuthorityInput extends CreateJobOptions {
+    name: string;
+    schedule: string;
+    prompt: string;
+    /** Current Engine Session, used by Desktop Main as authority even for standalone jobs. */
+    authoritySessionId?: string;
+}
+export type CronCreateAuthority = (input: CronCreateAuthorityInput) => Promise<CronJob>;
+/** Desktop installs a Main-process delegate; other hosts keep the local scheduler path. */
+export declare function setCronCreateAuthority(authority: CronCreateAuthority | null): void;
 export declare const cronCreateToolDef: ToolDefinition;
 export declare function cronCreateTool(args: Record<string, unknown>, context?: ToolContext): Promise<string>;
 export declare const cronDeleteToolDef: ToolDefinition;

package/dist/tool-system/builtin/cron.js

@@ -17,6 +17,11 @@ function fireCronChanged() {
         // Notifying the host is best-effort; never break the tool on it.
     }
 }
+let cronCreateAuthority = null;
+/** Desktop installs a Main-process delegate; other hosts keep the local scheduler path. */
+export function setCronCreateAuthority(authority) {
+    cronCreateAuthority = authority;
+}
 export const cronCreateToolDef = {
     name: "CronCreate",
     description: "Create a scheduled automation job that runs a prompt on a recurring schedule. " +
@@ -125,15 +130,33 @@ export async function cronCreateTool(args, context) {
     // time (the model never supplies it — getCurrentSid() reads the running
     // Engine's ALS context). Empty/unknown sid → treat as standalone.
     const resumeSessionId = args.continueInSession === true && getCurrentSid() ? getCurrentSid() : undefined;
+    const stableWorkspace = context?.workspace && !context.workspace.projectId.startsWith("legacy-")
+        ? {
+            projectId: context.workspace.projectId,
+            rootId: context.workspace.sessionMainRootId,
+        }
+        : undefined;
     let job;
     try {
-        job = cronScheduler.create(name, schedule, prompt, {
+        const createInput = {
+            name,
+            schedule,
+            prompt,
             ...(timezone !== undefined ? { timezone } : {}),
             ...(cwd !== undefined ? { cwd } : {}),
+            ...(stableWorkspace ?? {}),
             ...(permissionLevel !== undefined ? { permissionLevel } : {}),
             ...(once ? { once: true } : {}),
             ...(resumeSessionId !== undefined ? { resumeSessionId } : {}),
-        });
+            ...(getCurrentSid() ? { authoritySessionId: getCurrentSid() } : {}),
+        };
+        if (cronCreateAuthority) {
+            job = await cronCreateAuthority(createInput);
+        }
+        else {
+            const { name: _name, schedule: _schedule, prompt: _prompt, authoritySessionId: _authoritySessionId, ...createOptions } = createInput;
+            job = cronScheduler.create(name, schedule, prompt, createOptions);
+        }
     }
     catch (err) {
         return `Error: ${err instanceof Error ? err.message : String(err)}`;
@@ -162,12 +185,14 @@ export async function cronDeleteTool(args) {
     const id = args.jobId;
     if (!id)
         return "Error: jobId is required";
+    cronScheduler.loadJobs({ arm: false });
     const deleted = cronScheduler.delete(id);
     if (deleted)
         fireCronChanged();
     return deleted ? `Cron job #${id} deleted.` : `Cron job #${id} not found.`;
 }
 export async function cronListTool(_args) {
+    cronScheduler.loadJobs({ arm: false });
     const jobs = cronScheduler.list();
     if (jobs.length === 0)
         return "No cron jobs scheduled.";

package/dist/tool-system/builtin/edit-model-catalog.d.ts

@@ -1,9 +1,7 @@
 import type { ToolDefinition } from "../../types.js";
-/** Notifies process hosts after the user catalog has been persisted. Desktop
- * uses this to refresh mounted settings/connection views without waiting for
- * a parent turn_complete event (which may be absent for child/yielded runs). */
-type ModelCatalogChangedSink = () => void;
-export declare function setModelCatalogChangedSink(sink: ModelCatalogChangedSink | null): void;
+import { type SettingsChangedSink } from "./settings-changed.js";
+/** Backwards-compatible catalog-specific name for the shared settings/resource
+ * invalidation sink. */
+export declare function setModelCatalogChangedSink(sink: SettingsChangedSink | null): void;
 export declare const editModelCatalogToolDef: ToolDefinition;
 export declare function editModelCatalogTool(args: Record<string, unknown>): Promise<string>;
-export {};

package/dist/tool-system/builtin/edit-model-catalog.js

@@ -13,6 +13,7 @@ import { saveCatalogEntry } from "../../model-catalog/save-entry.js";
 import { catalogEntrySchema, modelPresetSchema, } from "../../model-catalog/types.js";
 import { upsertModelPreset } from "../../model-catalog/upsert.js";
 import { PROVIDER_KINDS } from "../../llm/provider-kinds.js";
+import { notifySettingsChanged, setSettingsChangedSink, } from "./settings-changed.js";
 const CATALOG_ADAPTER_KINDS = [...Object.keys(PROVIDER_KINDS), "fal"].join("|");
 /**
  * Recognise first-party provider hosts so the catalog tool can reject the
@@ -52,17 +53,13 @@ function providerIdentityError(entry) {
         `protocol="${protocolHint}". adapterKind identifies the provider/gateway account; ` +
         `protocol only identifies the HTTP wire format.`);
 }
-let modelCatalogChangedSink = null;
+/** Backwards-compatible catalog-specific name for the shared settings/resource
+ * invalidation sink. */
 export function setModelCatalogChangedSink(sink) {
-    modelCatalogChangedSink = sink;
+    setSettingsChangedSink(sink);
 }
 function fireModelCatalogChanged() {
-    try {
-        modelCatalogChangedSink?.();
-    }
-    catch {
-        // Host notification is best-effort; the catalog write itself succeeded.
-    }
+    notifySettingsChanged();
 }
 export const editModelCatalogToolDef = {
     name: "EditModelCatalog",

package/dist/tool-system/builtin/edit.js

@@ -51,8 +51,10 @@ export async function editTool(args, ctx) {
     if (!existsSync(filePath))
         return `Error: File not found: ${filePath}`;
     try {
-        const approvedPath = getFinalWritePathSnapshot(args, filePath, cwd);
-        const beforeRead = revalidateFinalWritePath(filePath, cwd, approvedPath);
+        const roots = ctx?.workspace?.roots.map((root) => root.path);
+        const digest = ctx?.workspace?.rootsDigest;
+        const approvedPath = getFinalWritePathSnapshot(args, filePath, cwd, roots, digest);
+        const beforeRead = revalidateFinalWritePath(filePath, cwd, approvedPath, roots, digest);
         if ("error" in beforeRead)
             return { ok: false, error: beforeRead.error };
         const raw = await readFile(beforeRead.resolvedPath, "utf-8");
@@ -75,7 +77,7 @@ export async function editTool(args, ctx) {
             }
         }
         const updatedLf = replaceAll ? content.split(oldLf).join(newLf) : content.replace(oldLf, newLf);
-        const beforeWrite = revalidateFinalWritePath(filePath, cwd, approvedPath);
+        const beforeWrite = revalidateFinalWritePath(filePath, cwd, approvedPath, roots, digest);
         if ("error" in beforeWrite)
             return { ok: false, error: beforeWrite.error };
         await writeFileNoFollow(beforeWrite.resolvedPath, applyEol(updatedLf, eol));

package/dist/tool-system/builtin/index.js

@@ -5,6 +5,7 @@ import { readToolDef, readTool } from "./read.js";
 import { writeToolDef, writeTool } from "./write.js";
 import { generateImageToolDef, generateImageTool, isGenerateImageAvailable, } from "./generate-image.js";
 import { editModelCatalogToolDef, editModelCatalogTool } from "./edit-model-catalog.js";
+import { configureModelConnectionToolDef, configureModelConnectionTool, } from "./configure-model-connection.js";
 import { generateVideoToolDef, generateVideoTool, isGenerateVideoAvailable, } from "./generate-video.js";
 import { viewImageToolDef, viewImageTool } from "./view-image.js";
 import { editToolDef, editTool } from "./edit.js";
@@ -123,6 +124,19 @@ const BUILTIN_CONTRIBUTIONS = [
         execute: editModelCatalogTool,
         exposure: expose(GENERAL_TAGS),
     },
+    {
+        definition: {
+            ...configureModelConnectionToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            // One lock-protected settings transaction; concurrent model connection
+            // mutations must serialize to preserve unique ids and defaults.
+            isConcurrencySafe: false,
+        },
+        execute: configureModelConnectionTool,
+        exposure: expose(GENERAL_TAGS),
+    },
     {
         definition: {
             ...generateImageToolDef,