open-multi-agent-kit 0.78.8 → 0.79.3

package/dist/providers/model-registry.js

@@ -1,7 +1,7 @@
 import { runShell } from "../util/shell.js";
 import { readOmkProvidersConfig, writeOmkProvidersConfig, } from "./deepseek/deepseek-config.js";
 import { DEFAULT_AUTHORITY_PROVIDER } from "./types.js";
-export const KNOWN_PROVIDER_IDS = ["mimo", "kimi", "deepseek", "qwen", "codex", "openrouter", "anthropic"];
+export const KNOWN_PROVIDER_IDS = ["mimo", "kimi", "deepseek", "qwen", "codex", "openrouter", "anthropic", "glm"];
 export const QWEN_DASHSCOPE_COMPAT_BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1";
 export const OPENROUTER_COMPAT_BASE_URL = "https://openrouter.ai/api/v1";
 const DEFAULT_PROVIDER_CONFIGS = {
@@ -121,6 +121,29 @@ const DEFAULT_PROVIDER_CONFIGS = {
         planKind: "qwen-coding-plan",
         routing: "advisory",
     },
+    glm: {
+        enabled: false,
+        kind: "openai-compatible",
+        baseUrl: "https://open.bigmodel.cn/api/paas/v1",
+        apiKeyEnv: "BIGMODEL_API_KEY",
+        defaultModel: "glm-5.2",
+        aliases: {
+            default: "glm-5.2",
+            glm: "glm-5.2",
+            "glm-5": "glm-5",
+            "glm-5.2": "glm-5.2",
+            "glm-5-air": "glm-5-air",
+            "glm-5-airx": "glm-5-airx",
+        },
+        capabilities: ["read", "research", "review", "qa", "advisory"],
+        contextWindow: 128_000,
+        reservedOutputTokens: 4096,
+        wireApi: "openai-chat-completions",
+        auth: { method: "api-key-env" },
+        profileType: "runtime",
+        planKind: "runtime",
+        routing: "advisory",
+    },
     openrouter: {
         enabled: false,
         kind: "openai-compatible",
@@ -176,6 +199,8 @@ export function normalizeProviderId(value) {
         return "openrouter";
     if (lower === "anthropic-api" || lower === "anthropic-direct" || lower === "claude-api")
         return "anthropic";
+    if (lower === "glm" || lower === "bigmodel" || lower === "zhipu")
+        return "glm";
     return lower;
 }
 export function parseProviderModelArg(value) {
@@ -202,11 +227,22 @@ export function parseProviderModelArg(value) {
     const slash = modelPart.indexOf("/");
     if (slash > 0) {
         const provider = normalizeProviderId(modelPart.slice(0, slash));
-        const arg = { model: normalizeModelAlias(modelPart.slice(slash + 1)) };
+        let modelSegment = modelPart.slice(slash + 1);
+        const inlineThinking = extractInlineThinkingLevel(modelSegment);
+        if (inlineThinking && !thinkingLevel) {
+            modelSegment = inlineThinking.modelPart;
+            thinkingLevel = inlineThinking.thinkingLevel;
+        }
+        const arg = { model: normalizeModelAlias(modelSegment) };
         if (provider !== "auto")
             arg.provider = provider;
         return withThinking(arg);
     }
+    const inlineThinking = extractInlineThinkingLevel(modelPart);
+    if (inlineThinking && !thinkingLevel) {
+        modelPart = inlineThinking.modelPart;
+        thinkingLevel = inlineThinking.thinkingLevel;
+    }
     const model = normalizeModelAlias(modelPart);
     if (model === "codex-cli")
         return withThinking({ provider: "codex", model });
@@ -214,6 +250,8 @@ export function parseProviderModelArg(value) {
         return withThinking({ provider: "deepseek", model });
     if (model.startsWith("claude-") || model.startsWith("gpt-") || model.startsWith("anthropic/"))
         return withThinking({ provider: "openrouter", model });
+    if (model.startsWith("glm-"))
+        return withThinking({ provider: "glm", model });
     return withThinking({ model });
 }
 function isThinkingLevelSuffix(suffix) {
@@ -225,6 +263,19 @@ function isThinkingLevelSuffix(suffix) {
     ];
     return thinkingAliases.includes(suffix);
 }
+function extractInlineThinkingLevel(value) {
+    const lower = value.trim().toLowerCase().replace(/[_\s]+/g, "-");
+    const match = lower.match(/^(glm-?5(?:\.\d+)?)-?([a-z_ -]+)$/);
+    if (!match)
+        return undefined;
+    const suffix = match[2]?.replace(/[-\s]+/g, "_") ?? "";
+    if (!isThinkingLevelSuffix(suffix))
+        return undefined;
+    const modelPart = match[1]?.replace(/^glm-?/, "glm-");
+    if (!modelPart)
+        return undefined;
+    return { modelPart, thinkingLevel: suffix.replace(/_/g, "-") };
+}
 export function normalizeModelAlias(value) {
     const trimmed = value.trim();
     const lower = trimmed.toLowerCase().replace(/[_\s]+/g, "-");
@@ -248,6 +299,17 @@ export function normalizeModelAlias(value) {
         return "qwen3-max";
     if (lower === "qwen-3.7-max" || lower === "qwen3.7-max" || lower === "qwen-3-7-max")
         return "qwen3-max";
+    const inlineThinking = extractInlineThinkingLevel(trimmed);
+    if (inlineThinking)
+        return inlineThinking.modelPart;
+    if (lower === "glm-5" || lower === "glm5")
+        return "glm-5";
+    if (lower === "glm-5.2" || lower === "glm5.2")
+        return "glm-5.2";
+    if (lower === "glm-5-air")
+        return "glm-5-air";
+    if (lower === "glm-5-airx" || lower === "glm-5-air-x")
+        return "glm-5-airx";
     return trimmed;
 }
 export async function readProviderRegistry(options = {}) {
@@ -373,7 +435,8 @@ export async function providerDoctorStatus(provider, options = {}) {
                 : "Codex CLI missing/disabled or authentication not verified; configured authority fallback is active",
         };
     }
-    const apiKeySet = entry.apiKeyEnv ? Boolean((options.env ?? process.env)[entry.apiKeyEnv]?.trim()) : undefined;
+    const env = options.env ?? process.env;
+    const apiKeySet = entry.apiKeyEnv ? Boolean(resolveProviderApiKeyEnvValue(entry, env)?.trim()) : undefined;
     const needsKey = entry.kind === "openai-compatible";
     const available = entry.enabled && (!needsKey || apiKeySet === true);
     return {
@@ -400,6 +463,14 @@ export async function providerDoctorStatus(provider, options = {}) {
                 : entry.disabledReason ?? "Provider disabled; configured authority fallback is active",
     };
 }
+function resolveProviderApiKeyEnvValue(entry, env) {
+    const primary = entry.apiKeyEnv ? env[entry.apiKeyEnv] : undefined;
+    if (primary?.trim())
+        return primary;
+    if (entry.id === "glm")
+        return env.GLM_API_KEY ?? env.BIGMODEL_API_KEY;
+    return primary;
+}
 function mergeProviderConfig(id, stored) {
     const known = isKnownProviderId(id) ? DEFAULT_PROVIDER_CONFIGS[id] : undefined;
     const aliases = { ...(known?.aliases ?? {}), ...(stored?.aliases ?? {}) };
@@ -540,11 +611,12 @@ export async function resolveUserModelAlias(input, options = {}) {
     const aliased = aliases[normalizeUserAlias(raw)];
     const candidate = aliased ?? raw;
     const parsed = parseProviderModelArg(candidate);
-    if (parsed.provider || parsed.model !== raw) {
+    if (parsed.provider || parsed.model !== raw || parsed.thinkingLevel) {
         return {
             input: raw,
             provider: parsed.provider,
             model: parsed.model ?? candidate,
+            thinkingLevel: parsed.thinkingLevel,
             source: aliased ? "user-alias" : "literal",
         };
     }

package/dist/providers/provider-runtime.js

@@ -69,7 +69,7 @@ export async function createProviderBackedTaskRunner(options) {
     for (const entry of registry) {
         if (!shouldUseOpenAICompatibleProvider(entry, providerPolicy))
             continue;
-        const apiKey = entry.apiKeyEnv ? process.env[entry.apiKeyEnv] : undefined;
+        const apiKey = resolveOpenAICompatibleApiKey(entry, process.env);
         if (apiKey && entry.baseUrl) {
             if (entry.wireApi === "anthropic-messages") {
                 providerRunners[entry.id] = createAnthropicMessagesReadOnlyTaskRunner({
@@ -192,6 +192,14 @@ function shouldUseOpenAICompatibleProvider(entry, providerPolicy) {
         return false;
     return providerPolicy === "auto" || providerPolicy === entry.id;
 }
+function resolveOpenAICompatibleApiKey(entry, env) {
+    const primary = entry.apiKeyEnv ? env[entry.apiKeyEnv] : undefined;
+    if (primary?.trim())
+        return primary;
+    if (entry.id === "glm")
+        return env.GLM_API_KEY ?? env.BIGMODEL_API_KEY;
+    return primary;
+}
 function providerModelDefault(entry) {
     return {
         model: entry.defaultModel,

package/dist/providers/thinking-levels.js

@@ -4,6 +4,7 @@ const PROVIDER_LEVELS = {
     mimo: ["medium", "high", "xhigh", "max"],
     deepseek: ["off", "high", "xhigh", "max"],
     qwen: ["off", "medium", "high", "max"],
+    glm: ["off", "medium", "high", "max"],
     anthropic: ["minimal", "low", "medium", "high", "xhigh", "max"],
     openrouter: ["minimal", "low", "medium", "high", "xhigh", "max"],
     duckcoding: ["minimal", "low", "medium", "high", "xhigh", "max"],
@@ -13,6 +14,7 @@ const MODEL_LEVELS = [
     { pattern: /kimi|mimo/i, levels: PROVIDER_LEVELS.kimi },
     { pattern: /deepseek/i, levels: PROVIDER_LEVELS.deepseek },
     { pattern: /qwen/i, levels: PROVIDER_LEVELS.qwen },
+    { pattern: /glm/i, levels: PROVIDER_LEVELS.glm },
     { pattern: /duck[-_ ]?coding/i, levels: PROVIDER_LEVELS.duckcoding },
     { pattern: /fable|claude|sonnet|opus|haiku|anthropic|gpt|openrouter/i, levels: PROVIDER_LEVELS.anthropic },
     { pattern: /codex/i, levels: PROVIDER_LEVELS.codex },

package/dist/providers/types.d.ts

@@ -1,5 +1,5 @@
 import type { TaskResult, TaskRunner } from "../contracts/orchestration.js";
-export type KnownProviderId = "mimo" | "kimi" | "deepseek" | "codex" | "qwen" | "openrouter" | "anthropic";
+export type KnownProviderId = "mimo" | "kimi" | "deepseek" | "codex" | "qwen" | "openrouter" | "anthropic" | "glm";
 export type ProviderId = KnownProviderId | (string & {});
 export type ProviderPolicy = "auto" | ProviderId;
 export declare const DEFAULT_AUTHORITY_PROVIDER: ProviderId;

package/dist/runtime/glm-api-runtime.d.ts

@@ -0,0 +1,4 @@
+import type { AgentRuntime } from "./agent-runtime.js";
+import { type KimiApiRuntimeOptions } from "./kimi-api-runtime.js";
+export type GlmApiRuntimeOptions = KimiApiRuntimeOptions;
+export declare function createGlmApiRuntime(options?: GlmApiRuntimeOptions): AgentRuntime;

package/dist/runtime/glm-api-runtime.js

@@ -0,0 +1,15 @@
+import { KimiApiRuntime } from "./kimi-api-runtime.js";
+export function createGlmApiRuntime(options = {}) {
+    const env = options.env ?? process.env;
+    return new KimiApiRuntime({
+        ...options,
+        id: options.id ?? "glm-api",
+        providerId: "glm",
+        providerName: "Zhipu GLM",
+        apiKeyEnvName: env.GLM_API_KEY && !env.BIGMODEL_API_KEY ? "GLM_API_KEY" : "BIGMODEL_API_KEY",
+        priority: options.priority ?? 84,
+        apiKey: options.apiKey ?? env.BIGMODEL_API_KEY ?? env.GLM_API_KEY,
+        model: options.model ?? env.GLM_MODEL ?? "glm-5.2",
+        baseUrl: options.baseUrl ?? env.GLM_BASE_URL ?? env.BIGMODEL_BASE_URL ?? "https://open.bigmodel.cn/api/paas/v1",
+    });
+}

package/dist/runtime/index.d.ts

@@ -5,4 +5,5 @@ export { type RuntimeRouterOptions, type RuntimeRouteDecision, type NodeIntent,
 export { type ToolProxyOptions, type ToolResultCompression, createToolProxy, } from "./tool-proxy.js";
 export { type KimiWireRuntimeOptions, createKimiWireRuntime, } from "./kimi-wire-runtime.js";
 export { type KimiPrintRuntimeOptions, createKimiPrintRuntime, } from "./kimi-print-runtime.js";
+export { type RecoveryArtifactRef, type RecoveryArtifactStore, type RecoveryArtifactStoreOptions, type RecoveryCaptureInput, type RecoveryFailureKind, createRecoveryArtifactStore, } from "./recovery-artifact-store.js";
 export { type ContextBudgetReport, type DroppedContextItem, type ContextTokenBreakdown, type ContextBudgetOptimizationResult, type ContextItemEvidenceStats, createContextBudgetOptimizer, estimateTokens, breakdownCapsuleTokens, } from "./context-budget-optimizer.js";

package/dist/runtime/index.js

@@ -5,4 +5,5 @@ export { createRuntimeRouter, } from './runtime-router.js';
 export { createToolProxy, } from "./tool-proxy.js";
 export { createKimiWireRuntime, } from "./kimi-wire-runtime.js";
 export { createKimiPrintRuntime, } from "./kimi-print-runtime.js";
+export { createRecoveryArtifactStore, } from "./recovery-artifact-store.js";
 export { createContextBudgetOptimizer, estimateTokens, breakdownCapsuleTokens, } from "./context-budget-optimizer.js";

package/dist/runtime/kimi-api-runtime.d.ts

@@ -8,6 +8,9 @@ import type { AgentRuntime, AgentRunResult, AgentResult, AgentTask, RuntimeCapab
 import type { ContextCapsule } from "./context-capsule.js";
 export interface KimiApiRuntimeOptions {
     id?: string;
+    providerId?: string;
+    providerName?: string;
+    apiKeyEnvName?: string;
     priority?: number;
     apiKey?: string;
     model?: string;
@@ -34,13 +37,15 @@ export declare function createKimiApiRuntime(options?: KimiApiRuntimeOptions): A
 export declare const createKimiWireRuntime: typeof createKimiApiRuntime;
 export declare class KimiApiRuntime implements AgentRuntime {
     readonly id: string;
-    readonly providerId = "kimi";
+    readonly providerId: string;
     readonly legacy = false;
     readonly runtimeMode = "api";
     readonly kind = "api";
     readonly priority: number;
     readonly capabilities: RuntimeCapabilities;
     private readonly apiKey;
+    private readonly apiKeyEnvName;
+    private readonly providerName;
     private readonly model;
     private readonly baseUrl;
     constructor(options?: KimiApiRuntimeOptions);

package/dist/runtime/kimi-api-runtime.js

@@ -76,6 +76,7 @@ function mapToolCalls(apiToolCalls, context) {
 export function createKimiApiRuntime(options = {}) {
     const env = options.env ?? process.env;
     return new KimiApiRuntime({
+        ...options,
         apiKey: options.apiKey ?? env.KIMI_API_KEY,
         model: options.model ?? env.KIMI_MODEL,
         baseUrl: options.baseUrl ?? env.KIMI_BASE_URL,
@@ -85,7 +86,7 @@ export function createKimiApiRuntime(options = {}) {
 export const createKimiWireRuntime = createKimiApiRuntime;
 export class KimiApiRuntime {
     id;
-    providerId = "kimi";
+    providerId;
     legacy = false;
     runtimeMode = "api";
     kind = "api";
@@ -104,11 +105,16 @@ export class KimiApiRuntime {
         supportsToolCalling: true,
     };
     apiKey;
+    apiKeyEnvName;
+    providerName;
     model;
     baseUrl;
     constructor(options = {}) {
         this.id = options.id ?? "kimi-api";
+        this.providerId = options.providerId ?? "kimi";
         this.priority = options.priority ?? 90;
+        this.apiKeyEnvName = options.apiKeyEnvName ?? "KIMI_API_KEY";
+        this.providerName = options.providerName ?? "Moonshot";
         this.apiKey = options.apiKey ?? process.env.KIMI_API_KEY;
         this.model = options.model ?? process.env.KIMI_MODEL ?? "kimi-k2-6";
         this.baseUrl = (options.baseUrl ?? "https://api.moonshot.cn/v1").replace(/\/+$/, "");
@@ -132,7 +138,7 @@ export class KimiApiRuntime {
         return {
             runtimeId: this.id,
             available,
-            reason: available ? undefined : "KIMI_API_KEY is not set",
+            reason: available ? undefined : `${this.apiKeyEnvName} is not set`,
             checkedAt: new Date().toISOString(),
         };
     }
@@ -171,7 +177,7 @@ export class KimiApiRuntime {
                 output: "",
                 exitCode: 1,
                 thinking: "",
-                metadata: { error: "KIMI_API_KEY is not set" },
+                metadata: { error: `${this.apiKeyEnvName} is not set` },
             };
         }
         if (task.capabilities.write ||
@@ -246,7 +252,7 @@ export class KimiApiRuntime {
                     output: "",
                     exitCode: 1,
                     thinking: "",
-                    metadata: { error: `Moonshot API error ${response.status}: ${errorText}` },
+                    metadata: { error: `${this.providerName} API error ${response.status}: ${errorText}` },
                 };
             }
             if (useStreaming) {

package/dist/runtime/recovery-artifact-store.d.ts

@@ -0,0 +1,39 @@
+export type RecoveryFailureKind = "rate_limit" | "quota" | "timeout" | "provider_crash" | "provider_error" | "abort" | "unknown";
+export interface RecoveryCaptureInput {
+    readonly runId: string;
+    readonly provider: string;
+    readonly nodeId: string;
+    readonly attemptId?: string;
+    readonly failureKind: RecoveryFailureKind;
+    readonly exitCode?: number;
+    readonly cwd?: string;
+    readonly command?: readonly string[];
+    readonly stdout?: string;
+    readonly stderr?: string;
+    readonly sessionPaths?: readonly string[];
+    readonly metadata?: Record<string, unknown>;
+}
+export interface RecoveryArtifactRef {
+    readonly schemaVersion: "omk.recovery-artifact.v1";
+    readonly runId: string;
+    readonly provider: string;
+    readonly nodeId: string;
+    readonly attemptId?: string;
+    readonly failureKind: RecoveryFailureKind;
+    readonly dir: string;
+    readonly manifestPath: string;
+    readonly sessionHandlePath?: string;
+}
+export interface RecoveryArtifactStore {
+    captureFailure(input: RecoveryCaptureInput): Promise<RecoveryArtifactRef>;
+    cleanup(input: {
+        runId: string;
+        provider?: string;
+        nodeId?: string;
+    }): Promise<void>;
+}
+export interface RecoveryArtifactStoreOptions {
+    readonly root?: string;
+    readonly maxLogBytes?: number;
+}
+export declare function createRecoveryArtifactStore(options?: RecoveryArtifactStoreOptions): RecoveryArtifactStore;

package/dist/runtime/recovery-artifact-store.js

@@ -0,0 +1,111 @@
+import { createHash } from "node:crypto";
+import { lstat, mkdir, readFile, readlink, rm, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { redactSecrets } from "../orchestration/state-persister.js";
+import { getRunPath, validateRunId } from "../util/run-store.js";
+const DEFAULT_MAX_LOG_BYTES = 128 * 1024;
+const MAX_SEGMENT_LENGTH = 80;
+function safeSegment(value, fallback) {
+    const sanitized = value
+        .replace(/[^A-Za-z0-9._-]/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "")
+        .slice(0, MAX_SEGMENT_LENGTH);
+    return sanitized && sanitized !== "." && sanitized !== ".." ? sanitized : fallback;
+}
+function redactText(value, maxBytes) {
+    if (!value)
+        return "";
+    const bounded = Buffer.byteLength(value, "utf8") > maxBytes
+        ? Buffer.from(value, "utf8").subarray(-maxBytes).toString("utf8")
+        : value;
+    const redacted = redactSecrets(bounded);
+    return typeof redacted === "string" ? redacted : JSON.stringify(redacted);
+}
+function sha256Text(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+async function inspectSessionPath(path) {
+    const base = { path, name: basename(path) };
+    try {
+        const stat = await lstat(path);
+        if (stat.isSymbolicLink()) {
+            return { ...base, kind: "symlink", target: await readlink(path).catch(() => "unreadable"), copied: false };
+        }
+        if (stat.isFile()) {
+            const bytes = await readFile(path);
+            return { ...base, kind: "file", size: bytes.length, sha256: createHash("sha256").update(bytes).digest("hex"), copied: false };
+        }
+        if (stat.isDirectory()) {
+            return { ...base, kind: "directory", copied: false };
+        }
+        return { ...base, kind: "other", copied: false };
+    }
+    catch (error) {
+        return { ...base, kind: "missing", error: error instanceof Error ? error.message : String(error), copied: false };
+    }
+}
+export function createRecoveryArtifactStore(options = {}) {
+    const maxLogBytes = options.maxLogBytes ?? DEFAULT_MAX_LOG_BYTES;
+    function runDir(runId) {
+        return getRunPath(validateRunId(runId), undefined, options.root);
+    }
+    function recoveryDir(input) {
+        const base = join(runDir(input.runId), "recovery");
+        const provider = input.provider ? safeSegment(input.provider, "provider") : undefined;
+        const nodeId = input.nodeId ? safeSegment(input.nodeId, "node") : undefined;
+        return provider ? nodeId ? join(base, provider, nodeId) : join(base, provider) : base;
+    }
+    return {
+        async captureFailure(input) {
+            const runId = validateRunId(input.runId);
+            const provider = safeSegment(input.provider, "provider");
+            const nodeId = safeSegment(input.nodeId, "node");
+            const dir = recoveryDir({ runId, provider, nodeId });
+            await mkdir(dir, { recursive: true });
+            const stdout = redactText(input.stdout, maxLogBytes);
+            const stderr = redactText(input.stderr, maxLogBytes);
+            const stdoutPath = join(dir, "stdout.log");
+            const stderrPath = join(dir, "stderr.redacted.log");
+            await writeFile(stdoutPath, stdout, "utf8");
+            await writeFile(stderrPath, stderr, "utf8");
+            const sessionHandlePath = join(dir, "session-handle.json");
+            const sessionHandles = await Promise.all((input.sessionPaths ?? []).map(inspectSessionPath));
+            await writeFile(sessionHandlePath, `${JSON.stringify({ schemaVersion: "omk.recovery-session.v1", sessionPaths: sessionHandles }, null, 2)}\n`, "utf8");
+            const manifestPath = join(dir, "manifest.json");
+            const manifest = {
+                schemaVersion: "omk.recovery-artifact.v1",
+                runId,
+                provider,
+                nodeId,
+                ...(input.attemptId ? { attemptId: safeSegment(input.attemptId, "attempt") } : {}),
+                failureKind: input.failureKind,
+                ...(input.exitCode !== undefined ? { exitCode: input.exitCode } : {}),
+                capturedAt: new Date().toISOString(),
+                ...(input.cwd ? { cwd: input.cwd } : {}),
+                command: input.command ? input.command.map((part) => redactText(part, maxLogBytes)) : [],
+                logs: {
+                    stdout: { path: "stdout.log", sha256: sha256Text(stdout), bytes: Buffer.byteLength(stdout, "utf8") },
+                    stderr: { path: "stderr.redacted.log", sha256: sha256Text(stderr), bytes: Buffer.byteLength(stderr, "utf8"), redacted: true },
+                },
+                sessionHandle: { path: "session-handle.json", count: sessionHandles.length },
+                metadata: redactSecrets(input.metadata ?? {}),
+            };
+            await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+            return {
+                schemaVersion: "omk.recovery-artifact.v1",
+                runId,
+                provider,
+                nodeId,
+                ...(input.attemptId ? { attemptId: safeSegment(input.attemptId, "attempt") } : {}),
+                failureKind: input.failureKind,
+                dir,
+                manifestPath,
+                sessionHandlePath,
+            };
+        },
+        async cleanup(input) {
+            await rm(recoveryDir(input), { recursive: true, force: true });
+        },
+    };
+}

package/dist/runtime/runtime-backed-task-runner.js

@@ -24,6 +24,7 @@ import { LocalLlmRuntime } from "./local-llm-runtime.js";
 import { checkCommand } from "../util/shell.js";
 import { createMimoApiRuntime } from "./mimo-api-runtime.js";
 import { createKimiApiRuntime } from "./kimi-api-runtime.js";
+import { createGlmApiRuntime } from "./glm-api-runtime.js";
 import { getUserHome } from "../util/fs.js";
 async function createDefaultRuntimeRegistry(options) {
     const registry = createRuntimeRegistry();
@@ -43,6 +44,15 @@ async function createDefaultRuntimeRegistry(options) {
     if (kimiApiKey) {
         registry.register(createKimiApiRuntime({ apiKey: kimiApiKey }));
     }
+    // ── GLM API runtime (Zhipu AI — OpenAI-compatible advisory lane) ──
+    const glmKey = options.env?.BIGMODEL_API_KEY
+        ?? options.env?.GLM_API_KEY
+        ?? process.env.BIGMODEL_API_KEY
+        ?? process.env.GLM_API_KEY
+        ?? readConfiguredProviderApiKey("glm");
+    if (glmKey) {
+        registry.register(createGlmApiRuntime({ apiKey: glmKey, env: options.env }));
+    }
     // ── codex-cli ──
     const codexBin = options.env?.CODEX_BIN ?? process.env.CODEX_BIN ?? "codex";
     if (await checkCommand(codexBin).catch(() => false)) {

package/dist/runtime/runtime-bootstrap.js

@@ -35,6 +35,16 @@ function detectProvider(provider, env) {
                 authHint: "Set DEEPSEEK_API_KEY env var",
                 modelHint: env.DEEPSEEK_MODEL ?? "deepseek-chat",
             };
+        case "glm":
+        case "bigmodel":
+        case "zhipu":
+            return {
+                envKey: env.GLM_API_KEY && !env.BIGMODEL_API_KEY ? "GLM_API_KEY" : "BIGMODEL_API_KEY",
+                sessionMode: "api-turn",
+                installHint: "export BIGMODEL_API_KEY=...",
+                authHint: "Set BIGMODEL_API_KEY env var",
+                modelHint: env.GLM_MODEL ?? "glm-5.2",
+            };
         case "local":
         case "llama":
         case "local-llm":
@@ -82,11 +92,15 @@ async function resolveAutoProvider(env) {
                 return { provider: "kimi", runtimeId: "kimi-api" };
             if (defaultModel.startsWith("deepseek") && env.DEEPSEEK_API_KEY)
                 return { provider: "deepseek", runtimeId: "deepseek-api" };
+            if (defaultModel.startsWith("glm") && (env.BIGMODEL_API_KEY || env.GLM_API_KEY || providerConfigHasApiKey(configContent, "glm")))
+                return { provider: "glm", runtimeId: "glm-api" };
         }
         if (providerConfigHasApiKey(configContent, "mimo"))
             return { provider: "mimo", runtimeId: "mimo-api" };
         if (providerConfigHasApiKey(configContent, "kimi"))
             return { provider: "kimi", runtimeId: "kimi-api" };
+        if (providerConfigHasApiKey(configContent, "glm"))
+            return { provider: "glm", runtimeId: "glm-api" };
     }
     // 2. Check for API keys in env
     if (env.MIMO_API_KEY)
@@ -95,6 +109,8 @@ async function resolveAutoProvider(env) {
         return { provider: "kimi", runtimeId: "kimi-api" };
     if (env.DEEPSEEK_API_KEY)
         return { provider: "deepseek", runtimeId: "deepseek-api" };
+    if (env.BIGMODEL_API_KEY || env.GLM_API_KEY)
+        return { provider: "glm", runtimeId: "glm-api" };
     if (env.LOCAL_LLM_BASE_URL)
         return { provider: "local-llm", runtimeId: "local-llm" };
     // 3. CLI binary detection (lowest priority)
@@ -145,7 +161,7 @@ export async function resolveRuntimeBootstrap(options) {
     }
     else if (info.envKey) {
         runtimeOk = Boolean(env[info.envKey]);
-        if (!runtimeOk && (selectedProvider === "mimo" || selectedProvider === "kimi")) {
+        if (!runtimeOk && (selectedProvider === "mimo" || selectedProvider === "kimi" || selectedProvider === "glm")) {
             const configContent = readHomeProviderConfig(env, ".omk");
             runtimeOk = configContent ? providerConfigHasApiKey(configContent, selectedProvider) : false;
         }

package/dist/runtime/slash-commands.js

@@ -91,6 +91,24 @@ function renderSlashResultContent(result, fallback) {
             lines.push("  Persistent default unchanged; use `omk model use` to persist.\n");
             return lines.join("\n");
         }
+        case "think.show": {
+            const provider = stringValue(payload, "provider", "auto");
+            const model = stringValue(payload, "model", "auto");
+            const current = stringValue(payload, "currentThinking", "");
+            const levels = stringListValue(payload, "supportedThinkingLevels");
+            const levelLine = levels
+                .map((level) => `${level === current ? "●" : "○"} ${level}`)
+                .join("  ");
+            return [
+                "\n  OMK Thinking Control · choose level",
+                `  Target: ${provider}/${model}`,
+                levelLine ? `  ${levelLine}` : undefined,
+                levels.length > 0 ? `  Choose directly: ${levels.map((level) => `/think ${level}`).join(" | ")}` : undefined,
+                "  Cycle only when explicit: /think next",
+                `  Active: ${current || "not selected"}`,
+                "",
+            ].filter((line) => typeof line === "string").join("\n");
+        }
         case "think.set": {
             const thinking = stringValue(payload, "thinking");
             const modelVariant = stringValue(payload, "modelVariant", "auto");
@@ -105,12 +123,12 @@ function renderSlashResultContent(result, fallback) {
         case "status.show":
             return `\n  Status: ${stringValue(payload, "provider")}/${stringValue(payload, "model")}  theme=${stringValue(payload, "theme")}`;
         case "theme.show": {
-            const current = stringValue(payload, "current", stringValue(payload, "theme", "omk"));
+            const current = stringValue(payload, "current", stringValue(payload, "theme", "omk-control-grid-dark"));
             const available = stringListValue(payload, "available");
             return `\n  Theme: ${current}${available.length > 0 ? `\n  Available: ${available.join(", ")}` : ""}`;
         }
         case "theme.set":
-            return `\n  Theme updated: ${stringValue(payload, "theme", "omk")}`;
+            return `\n  Theme updated: ${stringValue(payload, "theme", "omk-control-grid-dark")}`;
         case "help": {
             const commands = stringListValue(payload, "commands");
             return [`\n  OMK Slash Commands`, ...commands.map((command) => `  - ${command}`), ""].join("\n");
@@ -301,7 +319,22 @@ class ThinkCommandHandler {
                 sideEffects: [{ type: "thinking_changed", thinking: variant, modelVariant }],
             };
         }
-        const level = !requested || requested === "next" || requested === "tab"
+        if (!requested) {
+            return {
+                kind: "status",
+                command: "think.show",
+                payload: {
+                    provider: input.state.provider ?? "auto",
+                    model: input.state.model ?? "auto",
+                    currentThinking: input.state.thinking,
+                    supportedThinkingLevels: levels,
+                    usage: `/think ${levels.join(" | ")} | next | variant <name>`,
+                },
+                renderMode: "theme",
+                sideEffects: [],
+            };
+        }
+        const level = requested === "next" || requested === "tab"
             ? nextThinkingLevel(input.state.thinking, input.state.provider, input.state.model)
             : normalizeThinkingLevel(requested);
         if (!level || !levels.includes(level)) {
@@ -346,9 +379,9 @@ class ThemeCommandHandler {
                 kind: "status",
                 command: "theme.show",
                 payload: {
-                    current: input.state.theme ?? "omk",
+                    current: input.state.theme ?? "omk-control-grid-dark",
                     usage: "/theme <name>",
-                    available: ["omk", "night-city", "omk-control", "green-rain", "rust-forge", "neon-circuit", "minimal", "mono", "dark", "light"],
+                    available: ["omk-control-grid-dark", "night-city", "omk-control", "green-rain", "rust-forge", "neon-circuit", "omk", "minimal", "mono", "dark", "light"],
                 },
                 renderMode: "theme",
                 sideEffects: [],