@khorsheed/dsh-local-agent-kimi 0.1.0-rc.6

package/lib/types/model-catalog.js

@@ -0,0 +1,86 @@
+import { join } from 'node:path';
+import { ModelDirectoryCache, modelDirectoryContextKey } from '@khorsheed/dsh-local-agent';
+import { readKimiModelConfiguration } from './model-configuration.js';
+const object = (value) => typeof value === 'object' && value !== null ? value : undefined;
+function options(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap(candidate => {
+        const entry = object(candidate);
+        if (entry === undefined)
+            return [];
+        if (Array.isArray(entry['options']))
+            return options(entry['options']);
+        if (typeof entry['value'] !== 'string')
+            return [];
+        return [{ value: entry['value'], label: typeof entry['name'] === 'string' ? entry['name'] : entry['value'], ...typeof entry['description'] === 'string' ? { description: entry['description'] } : {} }];
+    });
+}
+/** ACP v1 configOptions are authoritative; old models metadata is a read-only fallback. */
+export function kimiNativeConfiguration(value) {
+    const response = object(value);
+    if (response === undefined)
+        return undefined;
+    const configuration = response['configOptions'];
+    if (Array.isArray(configuration)) {
+        const choices = configuration.map(object).filter((entry) => entry !== undefined && entry['type'] === 'select');
+        const model = choices.find(entry => entry['category'] === 'model');
+        const effort = choices.find(entry => entry['category'] === 'thought_level');
+        if (model !== undefined) {
+            const currentModel = typeof model['currentValue'] === 'string' ? model['currentValue'] : undefined;
+            const entries = options(model['options']).map(option => ({
+                ...option, source: 'native',
+                // Dependent options describe the CURRENT model only, not every candidate.
+                ...effort === undefined || option.value !== currentModel ? {} : { reasoning: { options: options(effort['options']) } },
+            }));
+            return {
+                directory: { entries, complete: true, customInput: false },
+                ...typeof model['id'] === 'string' ? { modelConfigId: model['id'] } : {},
+                ...typeof effort?.['id'] === 'string' ? { effortConfigId: effort['id'] } : {},
+                ...currentModel === undefined ? {} : { currentModel },
+                ...typeof effort?.['currentValue'] === 'string' ? { currentEffort: effort['currentValue'] } : {},
+            };
+        }
+    }
+    const legacy = object(response['models']);
+    if (!Array.isArray(legacy?.['availableModels']))
+        return undefined;
+    const entries = legacy['availableModels'].flatMap(candidate => {
+        const model = object(candidate);
+        if (typeof model?.['modelId'] !== 'string')
+            return [];
+        return [{ value: model['modelId'], label: typeof model['name'] === 'string' ? model['name'] : model['modelId'], source: 'native', ...typeof model['description'] === 'string' ? { description: model['description'] } : {} }];
+    });
+    return {
+        directory: { entries, complete: true, customInput: false },
+        ...typeof legacy['currentModelId'] === 'string' ? { currentModel: legacy['currentModelId'] } : {},
+    };
+}
+/** Reads configuration before a session exists; never starts a disposable ACP session. */
+export class KimiModelCatalog {
+    context;
+    cache = new ModelDirectoryCache({ load: async (key) => {
+            const context = JSON.parse(key);
+            if (context.native !== undefined)
+                return context.native;
+            const { entries, defaultModel } = await readKimiModelConfiguration(context.homeDir);
+            return {
+                entries,
+                ...defaultModel === undefined ? {} : { defaultModel },
+                complete: false, customInput: true,
+                reason: 'Configured candidates; native session model metadata is not available yet',
+            };
+        } });
+    constructor(context) {
+        this.context = context;
+    }
+    key(childSessionId) {
+        const context = this.context(childSessionId);
+        const stamp = modelDirectoryContextKey({ provider: 'kimi', homeDir: context.homeDir, cwd: context.cwd ?? context.homeDir, cli: ['kimi'], files: [join(context.homeDir, 'config.toml'), join(context.homeDir, 'credentials', 'kimi-code.json')] });
+        return JSON.stringify({ homeDir: context.homeDir, stamp, childSessionId, ...context.native === undefined ? {} : { native: context.native.directory } });
+    }
+    read(childSessionId) { return this.cache.read(this.key(childSessionId)); }
+    refresh(childSessionId) { return this.cache.refresh(this.key(childSessionId)); }
+    follow(childSessionId, signal) { return this.cache.follow(() => this.key(childSessionId), signal); }
+    dispose() { this.cache.dispose(); }
+}

package/lib/types/model-configuration.d.ts

@@ -0,0 +1,11 @@
+import type { LocalAgentModelEntry } from '@khorsheed/dsh-local-agent/types';
+/** Native configuration metadata only; provider credentials never leave this function. */
+export declare function readKimiModelConfiguration(home: string, selectedModel?: string): Promise<{
+    entries: LocalAgentModelEntry[];
+    defaultModel?: string;
+    effort?: string;
+    protocol?: string;
+}>;
+/** Only the native Kimi protocol advertises a general exec effort override. */
+export declare function kimiExecConfiguration(home: string, model: string | undefined, effort: string | undefined): Promise<Record<string, string>>;
+//# sourceMappingURL=model-configuration.d.ts.map

package/lib/types/model-configuration.js

@@ -0,0 +1,55 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parse } from 'smol-toml';
+const table = (value) => typeof value === 'object' && value !== null && !Array.isArray(value) ? value : {};
+const string = (value) => typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+/** Native configuration metadata only; provider credentials never leave this function. */
+export async function readKimiModelConfiguration(home, selectedModel) {
+    let text;
+    try {
+        text = await readFile(join(home, 'config.toml'), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { entries: [] };
+        throw error;
+    }
+    const config = parse(text);
+    const models = table(config['models']);
+    const entries = Object.entries(models).map(([value, raw]) => {
+        const model = table(raw);
+        const efforts = model['support_efforts'];
+        const defaultEffort = string(model['default_effort']);
+        return {
+            value, label: string(model['display_name']) ?? value, source: 'configuration',
+            ...!Array.isArray(efforts) ? {} : { reasoning: {
+                    options: efforts.flatMap(value => typeof value === 'string' ? [{ value, label: value }] : []),
+                    ...defaultEffort === undefined ? {} : { default: defaultEffort },
+                } },
+        };
+    });
+    const defaultModel = string(config['default_model']);
+    const selected = selectedModel ?? defaultModel;
+    const model = table(selected === undefined ? undefined : models[selected]);
+    const provider = table(table(config['providers'])[string(model['provider']) ?? '']);
+    const protocol = string(model['protocol']) ?? string(provider['type']);
+    const thinking = table(config['thinking']);
+    const requestedEffort = string(thinking['effort']);
+    const options = entries.find(entry => entry.value === selected)?.reasoning?.options;
+    const effort = thinking['enabled'] === false ? undefined
+        : requestedEffort !== undefined && options?.some(option => option.value === requestedEffort) ? requestedEffort : string(model['default_effort']);
+    return { entries, ...defaultModel === undefined ? {} : { defaultModel }, ...effort === undefined ? {} : { effort }, ...protocol === undefined ? {} : { protocol } };
+}
+/** Only the native Kimi protocol advertises a general exec effort override. */
+export async function kimiExecConfiguration(home, model, effort) {
+    if (effort === undefined)
+        return {};
+    const config = await readKimiModelConfiguration(home, model);
+    const entry = config.entries.find(entry => entry.value === (model ?? config.defaultModel));
+    if (!entry?.reasoning?.options.some(option => option.value === effort))
+        throw new Error('Kimi configuration does not advertise this model/effort combination');
+    if (config.protocol !== 'kimi') {
+        throw new Error('This Kimi model protocol has no per-invocation exec effort control; use ACP live mode');
+    }
+    return { KIMI_MODEL_THINKING_EFFORT: effort };
+}

package/lib/types/preset-tools.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Legacy kimi preset-variant cleanup. Earlier versions of this bundle
+ * bootstrapped `standard-kimi`, `code-kimi`, `minimal-kimi`, and `kimi`
+ * preset variants into the user preset root so an official-style preset could
+ * carry the `subagent_kimi` tool row. The tool row now mounts at the profile
+ * root (see the bundle patch), so every preset delegates without variants;
+ * this module removes the leftovers once on startup. The repo is pre-release,
+ * so no compatibility path is kept — variants that still exist are deleted.
+ * @module @khorsheed/dsh-local-agent-kimi/preset-tools
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Remove the legacy kimi preset variants from the user preset root. Uses the
+ * agent-presets service's remove (which also clears a default that named one
+ * of them), so a session later created under a different default no longer
+ * points at a deleted composition.
+ * @param ctx - host context carrying the agent-presets service.
+ */
+export declare function removeLegacyVariants(ctx: Context): Promise<void>;
+//# sourceMappingURL=preset-tools.d.ts.map

package/lib/types/preset-tools.js

@@ -0,0 +1,36 @@
+/**
+ * Legacy kimi preset-variant cleanup. Earlier versions of this bundle
+ * bootstrapped `standard-kimi`, `code-kimi`, `minimal-kimi`, and `kimi`
+ * preset variants into the user preset root so an official-style preset could
+ * carry the `subagent_kimi` tool row. The tool row now mounts at the profile
+ * root (see the bundle patch), so every preset delegates without variants;
+ * this module removes the leftovers once on startup. The repo is pre-release,
+ * so no compatibility path is kept — variants that still exist are deleted.
+ * @module @khorsheed/dsh-local-agent-kimi/preset-tools
+ */
+/** The variant preset ids earlier bundle versions bootstrapped. */
+const LEGACY_VARIANTS = ['standard-kimi', 'code-kimi', 'minimal-kimi', 'kimi'];
+/**
+ * Remove the legacy kimi preset variants from the user preset root. Uses the
+ * agent-presets service's remove (which also clears a default that named one
+ * of them), so a session later created under a different default no longer
+ * points at a deleted composition.
+ * @param ctx - host context carrying the agent-presets service.
+ */
+export async function removeLegacyVariants(ctx) {
+    const presets = ctx.get('agentPresets');
+    if (presets === undefined)
+        return;
+    for (const id of LEGACY_VARIANTS) {
+        try {
+            await presets.remove(id);
+        }
+        catch (error) {
+            // A variant that does not exist (or was already removed) is the success
+            // case; anything else is unexpected and worth surfacing.
+            if (error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+    }
+}

package/lib/types/provision.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Kimi Code scoped-home provisioning: a working `config.toml` (provider and
+ * model definitions) is required for the ACP server to authenticate. The
+ * scoped home is provisioned once — from the user's own config, redacted —
+ * so the scoped setup mirrors the user's models while carrying no secrets.
+ * Sign-out removes the credentials and OAuth cache so a later login can
+ * authorize a different account. The agent preset the delegation tool row
+ * needs is bootstrapped into the user preset root on first boot, so
+ * installing the bundle needs no manual copy step.
+ * @module @khorsheed/dsh-local-agent-kimi/provision
+ */
+/**
+ * The managed provider's endpoint, written into a fresh scoped config and the
+ * baseline the eval snapshot compares against: a scoped config still pointing
+ * here routes through kimi's own service, i.e. no custom endpoint is in force.
+ */
+export declare const KIMI_MANAGED_BASE_URL = "https://api.kimi.com/coding/v1";
+/**
+ * The reasoning effort a fresh scoped config gets when the plugin config does
+ * not override it — the value the pre-config-item provisioning hardcoded, so
+ * the default is behavior-preserving.
+ */
+export declare const DEFAULT_THINKING_EFFORT = "high";
+/**
+ * Redact every api_key value so the scoped copy carries no secrets. The
+ * kimi-managed provider keeps an empty api_key (its auth routes through
+ * oauth), which is exactly what an empty value means here.
+ * @param config - the user's config text.
+ * @returns the same config with all api_key values blanked.
+ */
+export declare function redactApiKeys(config: string): string;
+/**
+ * Provision `<homeDir>/config.toml` unless one already exists. A present
+ * config is respected untouched (a person may have edited it); otherwise the
+ * user's own real config is copied redacted so the scoped home mirrors the
+ * user's models; with no real config, a minimal kimi-managed config is
+ * written. `thinkingEffort` feeds the minimal config's `[thinking] effort`
+ * (and the model's `default_effort`) — it applies at provision time only,
+ * never retroactively to an existing config.
+ * @param homeDir - the `kimi` harness's scoped home.
+ * @param model - the kimi-managed model id for a fresh minimal config.
+ * @param thinkingEffort - the reasoning effort a fresh minimal config pins.
+ * @returns true when a config was written, false when one already existed.
+ */
+export declare function provisionKimiConfig(homeDir: string, model: string, thinkingEffort: string): Promise<boolean>;
+/**
+ * Read the scoped config's effective LLM endpoint: the
+ * `[providers."managed:kimi-code"].base_url` key, if present. A missing or
+ * malformed config yields undefined (the CLI falls back to its default
+ * endpoint). Used only for diagnostics — the config itself is authoritative,
+ * and a user-edited value is respected untouched.
+ * @param homeDir - the `kimi` harness's scoped home.
+ * @returns the configured base URL, or undefined when absent/unreadable.
+ */
+export declare function readKimiBaseUrl(homeDir: string): Promise<string | undefined>;
+/**
+ * Read the scoped config's configured default model: the top-level
+ * `default_model` key — the selection a plain `kimi -p` round runs with. A
+ * missing or malformed config, or no key, yields undefined — the honest
+ * "unknown", never a guessed default. Read-only: the config is authoritative
+ * and a user-edited value is reported as-is.
+ * @param homeDir - the `kimi` harness's scoped home.
+ * @returns the configured model identifier, or undefined when none is set.
+ */
+export declare function readKimiDefaultModel(homeDir: string): Promise<string | undefined>;
+/**
+ * List the model identifiers the scoped config DEFINES: every
+ * `[models."…"]` table key (bare `[models.x]` keys included). This is the
+ * pickable vocabulary a model surface can offer without hardcoding a catalog —
+ * the same table `-m` resolves against. A missing or malformed config yields
+ * an empty list. Read-only: the config is authoritative.
+ * @param homeDir - the `kimi` harness's scoped home.
+ * @returns the defined model identifiers, in file order, deduplicated.
+ */
+export declare function listKimiConfigModels(homeDir: string): Promise<string[]>;
+/**
+ * Rewrite the scoped config's top-level `default_model` to `model`, so the
+ * NEXT process started under this home runs that model. This is the resident
+ * path's only lever: `kimi acp` takes no model flag (verified against kimi
+ * 0.39.1), while `kimi -p` takes `-m` — so the one-shot rounds pass the flag
+ * and the live driver writes the file before spawning its runtime.
+ *
+ * The write is surgical: the first top-level `default_model` assignment is
+ * replaced in place and everything else — model tables, providers, thinking
+ * effort, comments, key order — is left byte-identical. A config with no
+ * top-level `default_model` gains one as its first line; an absent or
+ * unreadable config is left alone (provisioning owns creation, and inventing
+ * a config here would hide a broken home).
+ * @param homeDir - the `kimi` harness's scoped home.
+ * @param model - the model identifier to pin as the default.
+ * @returns true when the file now names `model`, false when there was no
+ *   config to write into.
+ */
+export declare function writeKimiDefaultModel(homeDir: string, model: string): Promise<boolean>;
+/**
+ * Read the scoped config's effective reasoning effort: the `[thinking] effort`
+ * key, falling back to a `[models."…"]` section's `default_effort` when the
+ * thinking table carries none (the CLI resolves effort the same way). A
+ * missing or malformed config, or no effort key anywhere, yields undefined —
+ * the honest "unknown", never a guessed default. Read-only: the config is
+ * authoritative, a user-edited value is reported as-is.
+ * @param homeDir - the `kimi` harness's scoped home.
+ * @returns the effective effort, or undefined when it cannot be determined.
+ */
+export declare function readKimiReasoningEffort(homeDir: string): Promise<string | undefined>;
+/**
+ * Whether the scoped config's permission rules auto-approve the subagent's
+ * tool use: the `Bash(*)` allow rule the provisioning gate
+ * ({@link ensureKimiPermissions}) keys on, detected with the exact same
+ * substring so the snapshot and the provisioning can never disagree about
+ * the same file.
+ * @param homeDir - the `kimi` harness's scoped home.
+ * @returns whether the auto-approve rule is present.
+ */
+export declare function readKimiAutoApprove(homeDir: string): Promise<boolean>;
+/**
+ * Ensure the scoped config allows the subagent's tool use. The one-shot
+ * `kimi -p` child uses the config's permission rules, so without a rule it
+ * answers without executing tools. Idempotent; an existing rule is respected.
+ * @param homeDir - the `kimi` harness's scoped home.
+ */
+export declare function ensureKimiPermissions(homeDir: string): Promise<void>;
+/**
+ * Sign out of the scoped account: remove the credentials and OAuth token
+ * cache, so `/<name> status` reports not authenticated and the next login
+ * authorizes a fresh account. The kimi CLI has no `logout` command, so the
+ * scoped files are the logout path.
+ * @param homeDir - the `kimi` harness's scoped home.
+ */
+export declare function kimiLogout(homeDir: string): Promise<void>;
+//# sourceMappingURL=provision.d.ts.map