sneakoscope 4.0.3 → 4.0.5

package/dist/core/providers/glm/glm-52-settings.js

@@ -1,24 +1,66 @@
 export { OPENROUTER_CHAT_COMPLETIONS_URL } from '../openrouter/openrouter-types.js';
 export const GLM_52_OPENROUTER_MODEL = 'z-ai/glm-5.2';
-export const GLM_MAD_MODE = 'mad-glm';
-export const GLM_52_MAX_TOKENS_DEFAULT = 32768;
+export const GLM_52_MODEL = GLM_52_OPENROUTER_MODEL;
+export const GLM_SPEED_MODE = 'mad-glm-speed';
+export const GLM_DEEP_MODE = 'mad-glm-deep';
+export const GLM_XHIGH_MODE = 'mad-glm-xhigh';
+export const GLM_STRICT_MODE = 'mad-glm-strict';
+export const GLM_MAD_MODE = GLM_SPEED_MODE;
+export const GLM_52_MAX_TOKENS_SPEED = 4096;
+export const GLM_52_MAX_TOKENS_DEFAULT = GLM_52_MAX_TOKENS_SPEED;
+export const GLM_52_MAX_TOKENS_DEEP = 16384;
+export const GLM_52_MAX_TOKENS_XHIGH = 32768;
 export const GLM_52_MAX_TOKENS_LONG = 65536;
 export const GLM_52_MAX_TOKENS_XLONG = 131072;
 export const GLM_52_TOP_PROVIDER_MAX_COMPLETION_TOKENS = 262144;
-export const GLM_52_DEFAULT_REQUEST_SETTINGS = {
+export const GLM_SPEED_PROFILE = {
     model: GLM_52_OPENROUTER_MODEL,
-    temperature: 1,
-    top_p: 0.95,
-    reasoning_effort: 'high',
+    mode: GLM_SPEED_MODE,
+    temperature: 0.2,
+    top_p: 0.85,
     stream: true,
     provider: {
         allow_fallbacks: false,
-        require_parameters: true
+        require_parameters: true,
+        sort: 'throughput',
+        preferred_min_throughput: { p50: 80, p90: 40 },
+        preferred_max_latency: { p50: 2, p90: 5 }
+    },
+    tool_choice: 'none',
+    parallel_tool_calls: false,
+    max_tokens: GLM_52_MAX_TOKENS_SPEED,
+    reasoning_effort: 'xhigh',
+    reasoning_default: 'xhigh-speed-optimized'
+};
+export const GLM_DEEP_PROFILE = {
+    model: GLM_52_OPENROUTER_MODEL,
+    mode: GLM_DEEP_MODE,
+    temperature: 0.3,
+    top_p: 0.9,
+    stream: true,
+    provider: {
+        allow_fallbacks: false,
+        require_parameters: true,
+        sort: 'throughput'
     },
     tool_choice: 'auto',
     parallel_tool_calls: false,
-    max_tokens: GLM_52_MAX_TOKENS_DEFAULT
+    max_tokens: GLM_52_MAX_TOKENS_DEEP,
+    reasoning_effort: 'high'
+};
+export const GLM_XHIGH_PROFILE = {
+    ...GLM_DEEP_PROFILE,
+    mode: GLM_XHIGH_MODE,
+    max_tokens: GLM_52_MAX_TOKENS_XHIGH,
+    reasoning_effort: 'xhigh'
+};
+export const GLM_STRICT_PROFILE = {
+    ...GLM_DEEP_PROFILE,
+    mode: GLM_STRICT_MODE,
+    structured_outputs: true,
+    response_format: 'json_schema'
 };
+export const GLM_52_DEFAULT_REQUEST_SETTINGS = GLM_SPEED_PROFILE;
 export function clampGlm52MaxTokens(value) {
     const numeric = Number.isFinite(value) ? Math.floor(Number(value)) : GLM_52_MAX_TOKENS_DEFAULT;
     return Math.max(1, Math.min(numeric, GLM_52_TOP_PROVIDER_MAX_COMPLETION_TOKENS));

package/dist/core/providers/glm/glm-bench.js

@@ -0,0 +1,90 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../../fsx.js';
+import { profileFromConst } from './glm-profile-resolver.js';
+import { createEmptyGlmLatencyTrace, writeGlmLatencyTrace } from './glm-latency-trace.js';
+const SYNTHETIC_CASES = Object.freeze([
+    benchCase('small doc edit', 'doc_edit', 420, 980),
+    benchCase('small TS function edit', 'small_edit', 460, 1100),
+    benchCase('failing test fix from small error', 'test_fix', 520, 1220),
+    benchCase('simple config edit', 'config_edit', 390, 930)
+]);
+export async function runGlmBench(root, args = []) {
+    const execute = args.includes('--execute');
+    if (execute) {
+        const blocked = {
+            schema: 'sks.glm-bench-result.v1',
+            version: '4.0.5',
+            generated_at: nowIso(),
+            status: 'blocked',
+            dry_run: true,
+            cases: [],
+            summary: {
+                speed_p50_total_ms: 0,
+                speed_p90_total_ms: 0,
+                speed_p50_ttft_ms: null
+            },
+            warnings: ['execute_requested_but_live_openrouter_bench_not_implemented']
+        };
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'glm', 'bench-blocked.json'), blocked);
+        return blocked;
+    }
+    const speedTotals = SYNTHETIC_CASES.map((row) => row.speed.total_ms);
+    const deepTotals = SYNTHETIC_CASES.map((row) => row.deep.total_ms);
+    const result = {
+        schema: 'sks.glm-bench-result.v1',
+        version: '4.0.5',
+        generated_at: nowIso(),
+        status: 'dry_run',
+        dry_run: true,
+        cases: SYNTHETIC_CASES,
+        summary: {
+            speed_p50_total_ms: percentile(speedTotals, 50),
+            speed_p90_total_ms: percentile(speedTotals, 90),
+            speed_p50_ttft_ms: null,
+            deep_p50_total_ms: percentile(deepTotals, 50),
+            speed_vs_deep_ratio: Number((percentile(speedTotals, 50) / percentile(deepTotals, 50)).toFixed(3))
+        },
+        warnings: ['synthetic_dry_run_no_network_no_gpt_key_required']
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'glm', 'bench-result.json'), result);
+    await writeGlmLatencyTrace(root, {
+        ...createEmptyGlmLatencyTrace('speed'),
+        total_ms: result.summary.speed_p50_total_ms,
+        context_estimated_tokens: 16_000,
+        request_encode_ms: 1,
+        encoded_request_cache_hit: true
+    });
+    return result;
+}
+function benchCase(name, taskKind, speedMs, deepMs) {
+    return {
+        name,
+        task_kind: taskKind,
+        speed: {
+            mode: 'speed',
+            synthetic: true,
+            llm_calls: 1,
+            max_tokens: profileFromConst('speed').max_tokens,
+            context_target_tokens: 16_000,
+            total_ms: speedMs,
+            ttft_ms: null
+        },
+        deep: {
+            mode: 'deep',
+            synthetic: true,
+            llm_calls: 1,
+            max_tokens: profileFromConst('deep').max_tokens,
+            context_target_tokens: 64_000,
+            total_ms: deepMs,
+            ttft_ms: null
+        }
+    };
+}
+function percentile(values, p) {
+    const sorted = [...values].sort((a, b) => a - b);
+    if (!sorted.length)
+        return 0;
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil((p / 100) * sorted.length) - 1));
+    return sorted[index] || 0;
+}
+//# sourceMappingURL=glm-bench.js.map

package/dist/core/providers/glm/glm-context-budget.js

@@ -0,0 +1,15 @@
+export const GLM_SPEED_CONTEXT_TARGET_TOKENS = 16_000;
+export const GLM_SPEED_CONTEXT_HARD_CAP_TOKENS = 32_000;
+export const GLM_DEEP_CONTEXT_TARGET_TOKENS = 64_000;
+export function estimateGlmTokens(text) {
+    if (!text)
+        return 0;
+    return Math.ceil(text.length / 4);
+}
+export function trimToEstimatedTokens(text, maxTokens) {
+    const maxChars = Math.max(0, Math.floor(maxTokens) * 4);
+    if (text.length <= maxChars)
+        return text;
+    return text.slice(0, maxChars);
+}
+//# sourceMappingURL=glm-context-budget.js.map

package/dist/core/providers/glm/glm-context-cache.js

@@ -0,0 +1,9 @@
+import { SksLruCache } from '../../perf/lru-cache.js';
+export function createGlmContextCache(maxEntries = 64) {
+    const cache = new SksLruCache(maxEntries);
+    return {
+        getByDigest: (digest) => cache.get(digest),
+        set: (context) => cache.set(context.digest, context)
+    };
+}
+//# sourceMappingURL=glm-context-cache.js.map

package/dist/core/providers/glm/glm-latency-trace.js

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../../fsx.js';
+export function createEmptyGlmLatencyTrace(mode) {
+    return {
+        schema: 'sks.glm-latency-trace.v1',
+        version: '4.0.5',
+        mode,
+        total_ms: 0,
+        preflight_ms: 0,
+        key_resolve_ms: 0,
+        model_meta_ms: 0,
+        task_classify_ms: 0,
+        context_build_ms: 0,
+        context_estimated_tokens: 0,
+        context_cache_hit: false,
+        tool_schema_build_ms: 0,
+        tool_schema_cache_hit: false,
+        request_build_ms: 0,
+        request_encode_ms: 0,
+        encoded_request_cache_hit: false,
+        openrouter_ttft_ms: null,
+        openrouter_total_ms: null,
+        output_parse_ms: 0,
+        model_guard_ms: 0,
+        patch_apply_ms: 0,
+        deterministic_gate_ms: 0,
+        proof_write_ms: 0
+    };
+}
+export async function writeGlmLatencyTrace(root, trace) {
+    const safeTrace = redactTrace(trace);
+    const filename = `${nowIso().replace(/[:.]/g, '-')}-glm-${trace.mode}-trace.json`;
+    const out = path.join(root, '.sneakoscope', 'glm', 'traces', filename);
+    await writeJsonAtomic(out, safeTrace);
+    return out;
+}
+function redactTrace(trace) {
+    return JSON.parse(JSON.stringify(trace).replace(/sk-or-[A-Za-z0-9_-]+/g, 'sk-or-...redacted...'));
+}
+//# sourceMappingURL=glm-latency-trace.js.map

package/dist/core/providers/glm/glm-mad-launch.js

@@ -0,0 +1,128 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { nowIso, writeTextAtomic } from '../../fsx.js';
+import { resolveOpenRouterApiKey, openRouterSecretPaths } from '../openrouter/openrouter-secret-store.js';
+import { GLM_52_OPENROUTER_MODEL } from './glm-52-settings.js';
+import { resolveGlmProfileFromArgs } from './glm-profile-resolver.js';
+export const GLM_MAD_PROFILE_ID = 'sks/glm-5.2-mad';
+export const OPENROUTER_CODEX_PROVIDER = 'openrouter';
+export function buildMadGlmLaunchProfileNoWrite(args = []) {
+    const profile = resolveGlmProfileFromArgs(args);
+    const effort = codexReasoningEffortForProfile(profile);
+    return {
+        schema: 'sks.glm-mad-launch-profile.v1',
+        profile_name: GLM_MAD_PROFILE_ID,
+        provider: OPENROUTER_CODEX_PROVIDER,
+        model: GLM_52_OPENROUTER_MODEL,
+        glm_profile: profile.name,
+        glm_mode: profile.mode,
+        launch_args: [
+            '--sandbox',
+            'danger-full-access',
+            '--ask-for-approval',
+            'never',
+            '-c',
+            'service_tier=fast',
+            '-c',
+            `model_reasoning_effort=${effort}`,
+            '-c',
+            'model_provider="openrouter"',
+            '-c',
+            `model="${GLM_52_OPENROUTER_MODEL}"`,
+            '-c',
+            'model_providers.openrouter.name="OpenRouter"',
+            '-c',
+            'model_providers.openrouter.base_url="https://openrouter.ai/api/v1"',
+            '-c',
+            'model_providers.openrouter.env_key="OPENROUTER_API_KEY"',
+            '-c',
+            'model_providers.openrouter.wire_api="responses"',
+            '-c',
+            'model_providers.openrouter.requires_openai_auth=false'
+        ],
+        sandbox_mode: 'danger-full-access',
+        approval_policy: 'never',
+        model_reasoning_effort: effort,
+        service_tier: 'fast',
+        gpt_fallback_allowed: false,
+        writes_user_codex_config: false
+    };
+}
+export async function resolveMadGlmLaunchKey(env = process.env) {
+    return resolveOpenRouterApiKey({ env });
+}
+export async function writeMadGlmCodexWrapper(input) {
+    const env = input.env || process.env;
+    const paths = openRouterSecretPaths(env);
+    const realCodexBin = String(input.realCodexBin || env.SKS_CODEX_BIN || 'codex');
+    const wrapperPath = path.join(input.missionDir, 'sks-glm-codex-wrapper.sh');
+    await writeTextAtomic(wrapperPath, buildMadGlmCodexWrapperScript({
+        realCodexBin,
+        secretKeyPath: paths.keyPath
+    }));
+    await fs.chmod(wrapperPath, 0o700).catch(() => undefined);
+    return {
+        wrapper_path: wrapperPath,
+        real_codex_bin: realCodexBin,
+        secret_key_path: paths.keyPath,
+        raw_key_written_to_wrapper: false
+    };
+}
+export function buildMadGlmCodexWrapperScript(input) {
+    return [
+        '#!/bin/sh',
+        'set -eu',
+        '# Generated by SKS GLM MAD launch. This wrapper reads the key at runtime',
+        '# so Zellij layout artifacts never contain the raw OpenRouter secret.',
+        'if [ -z "${OPENROUTER_API_KEY:-}" ] && [ -n "${SKS_OPENROUTER_API_KEY:-}" ]; then',
+        '  OPENROUTER_API_KEY="$SKS_OPENROUTER_API_KEY"',
+        '  export OPENROUTER_API_KEY',
+        'fi',
+        `if [ -z "\${OPENROUTER_API_KEY:-}" ] && [ -r ${shellQuote(input.secretKeyPath)} ]; then`,
+        `  OPENROUTER_API_KEY="$(cat ${shellQuote(input.secretKeyPath)})"`,
+        '  export OPENROUTER_API_KEY',
+        'fi',
+        'if [ -z "${OPENROUTER_API_KEY:-}" ]; then',
+        '  echo "SKS GLM MAD blocked: OPENROUTER_API_KEY is missing. Run sks --mad --glm --repair or export OPENROUTER_API_KEY." >&2',
+        '  exit 66',
+        'fi',
+        `exec ${shellQuote(input.realCodexBin)} "$@"`,
+        ''
+    ].join('\n');
+}
+export function buildMadGlmLaunchArtifact(input) {
+    const profile = input.profile || buildMadGlmLaunchProfileNoWrite();
+    return {
+        schema: 'sks.glm-mad-launch.v1',
+        generated_at: nowIso(),
+        ok: Boolean(input.keyResolution.key),
+        mission_id: input.missionId,
+        provider: profile.provider,
+        model: profile.model,
+        glm_profile: profile.glm_profile,
+        glm_mode: profile.glm_mode,
+        model_reasoning_effort: profile.model_reasoning_effort,
+        profile_name: profile.profile_name,
+        strict_model_lock: true,
+        gpt_fallback_allowed: false,
+        openrouter_key_source: input.keyResolution.source || null,
+        key_preview: input.keyResolution.key_preview || null,
+        wrapper_path: input.wrapper.wrapper_path,
+        real_codex_bin: input.wrapper.real_codex_bin,
+        raw_key_written_to_wrapper: false,
+        codex_args: profile.launch_args,
+        blockers: input.keyResolution.key ? [] : input.keyResolution.blockers,
+        warnings: input.keyResolution.warnings || []
+    };
+}
+function shellQuote(value) {
+    return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+function codexReasoningEffortForProfile(profile) {
+    if (profile.name === 'xhigh')
+        return 'xhigh';
+    if (profile.name === 'deep' || profile.name === 'strict')
+        return 'high';
+    return 'xhigh';
+}
+//# sourceMappingURL=glm-mad-launch.js.map

package/dist/core/providers/glm/glm-mad-mode.js

@@ -11,23 +11,33 @@ import { redactOpenRouterKey } from '../../security/redact-secrets.js';
 import { buildGlmCodexAppModelProfile } from './glm-52-profile.js';
 import { buildGlm52KeyValidationRequest, buildGlm52Request } from './glm-52-request.js';
 import { assertGlm52ActualModel } from './glm-52-response-guard.js';
-import { GLM_52_OPENROUTER_MODEL, GLM_MAD_MODE, OPENROUTER_CHAT_COMPLETIONS_URL } from './glm-52-settings.js';
+import { GLM_52_OPENROUTER_MODEL, OPENROUTER_CHAT_COMPLETIONS_URL } from './glm-52-settings.js';
+import { resolveGlmProfileFromArgs } from './glm-profile-resolver.js';
+import { createEmptyGlmLatencyTrace, writeGlmLatencyTrace } from './glm-latency-trace.js';
 export async function runMadGlmMode(args = [], adapters = {}) {
     const runtime = buildDefaultAdapters(adapters);
     const repair = flag(args, '--repair');
     const noSaveKey = flag(args, '--no-save-key');
     const skipValidation = flag(args, '--skip-validation');
     const json = flag(args, '--json');
+    const selectedProfile = resolveGlmProfileFromArgs(args);
     const profile = buildGlmCodexAppModelProfile();
     let result;
-    if (repair) {
+    if (selectedProfile.blockers.length) {
+        result = baseResult({
+            status: 'blocked',
+            blockers: selectedProfile.blockers,
+            warnings: []
+        }, selectedProfile);
+    }
+    else if (repair) {
         const key = await runtime.promptSecret('OpenRouter API key is required for GLM 5.2 mode.\nEnter OpenRouter API key: ');
         if (!key) {
             result = baseResult({
                 status: 'blocked',
                 blockers: ['glm_key_prompt_cancelled'],
                 warnings: []
-            });
+            }, selectedProfile);
         }
         else {
             if (!noSaveKey)
@@ -43,14 +53,14 @@ export async function runMadGlmMode(args = [], adapters = {}) {
                     key_preview: redactOpenRouterKey(key),
                     blockers: [],
                     warnings: noSaveKey ? ['openrouter_key_not_saved'] : []
-                })
+                }, selectedProfile)
                 : baseResult({
                     status: 'blocked',
                     openrouter_key_source: noSaveKey ? 'prompt' : 'user-secret-store',
                     key_preview: redactOpenRouterKey(key),
                     blockers: [validation.error.code],
                     warnings: []
-                });
+                }, selectedProfile);
         }
     }
     else {
@@ -58,7 +68,7 @@ export async function runMadGlmMode(args = [], adapters = {}) {
         if (!resolved.key && process.stdin.isTTY) {
             const key = await runtime.promptSecret('OpenRouter API key is required for GLM 5.2 mode.\nEnter OpenRouter API key: ');
             if (!key) {
-                result = baseResult({ status: 'blocked', blockers: ['glm_key_prompt_cancelled'], warnings: [] });
+                result = baseResult({ status: 'blocked', blockers: ['glm_key_prompt_cancelled'], warnings: [] }, selectedProfile);
             }
             else {
                 const save = noSaveKey ? false : await runtime.promptConfirm('Save this key for future SKS GLM runs? [Y/n] ', true);
@@ -70,7 +80,7 @@ export async function runMadGlmMode(args = [], adapters = {}) {
                     key_preview: redactOpenRouterKey(key),
                     blockers: [],
                     warnings: save ? [] : ['openrouter_key_not_saved']
-                });
+                }, selectedProfile);
             }
         }
         else if (!resolved.key) {
@@ -78,7 +88,7 @@ export async function runMadGlmMode(args = [], adapters = {}) {
                 status: 'blocked',
                 blockers: resolved.blockers,
                 warnings: ['set_OPENROUTER_API_KEY_or_run_sks_--mad_--glm_--repair']
-            });
+            }, selectedProfile);
         }
         else {
             result = baseResult({
@@ -87,10 +97,19 @@ export async function runMadGlmMode(args = [], adapters = {}) {
                 key_preview: resolved.key_preview,
                 blockers: [],
                 warnings: resolved.warnings
-            });
+            }, selectedProfile);
         }
     }
-    await writeGlmModeArtifacts(runtime.cwd, result, profile, runtime.nowIso()).catch(() => undefined);
+    await writeGlmModeArtifacts(runtime.cwd, result, profile, selectedProfile, runtime.nowIso()).catch(() => undefined);
+    if (flag(args, '--trace')) {
+        await writeGlmLatencyTrace(runtime.cwd, {
+            ...createEmptyGlmLatencyTrace(selectedProfile.name),
+            context_estimated_tokens: selectedProfile.name === 'speed' ? 16_000 : 64_000,
+            request_encode_ms: 1,
+            encoded_request_cache_hit: false,
+            provider: 'openrouter'
+        }).catch(() => undefined);
+    }
     if (json)
         printJson(result);
     else
@@ -99,12 +118,13 @@ export async function runMadGlmMode(args = [], adapters = {}) {
         process.exitCode = 1;
     return result;
 }
-function baseResult(input) {
+function baseResult(input, profile) {
     const result = {
         schema: 'sks.glm-mode-result.v1',
         ok: input.blockers.length === 0 && input.status !== 'failed',
         status: input.status,
-        mode: GLM_MAD_MODE,
+        mode: profile.mode,
+        profile: profile.name,
         provider: 'openrouter',
         model: GLM_52_OPENROUTER_MODEL,
         requested_model: GLM_52_OPENROUTER_MODEL,
@@ -166,25 +186,32 @@ function validationValue(actualModel) {
         gpt_fallback_allowed: false
     };
 }
-async function writeGlmModeArtifacts(cwd, result, profile, generatedAt) {
+async function writeGlmModeArtifacts(cwd, result, profile, selectedProfile, generatedAt) {
     const dir = path.join(cwd, '.sneakoscope', 'glm');
     await writeJsonAtomic(path.join(dir, 'mad-glm-session.json'), {
         schema: 'sks.glm-mad-session.v1',
         generated_at: generatedAt,
         result,
-        profile_id: profile.id
+        profile_id: profile.id,
+        selected_profile: selectedProfile.name
     });
     await writeJsonAtomic(path.join(dir, 'openrouter-request-summary.json'), {
         schema: 'sks.openrouter-request-summary.v1',
         generated_at: generatedAt,
         endpoint: OPENROUTER_CHAT_COMPLETIONS_URL,
         model: GLM_52_OPENROUTER_MODEL,
-        temperature: 1,
-        top_p: 0.95,
-        reasoning_effort: 'high',
-        stream: true,
+        mode: selectedProfile.mode,
+        profile: selectedProfile.name,
+        temperature: selectedProfile.temperature,
+        top_p: selectedProfile.top_p,
+        reasoning_effort: selectedProfile.reasoning_effort || 'xhigh',
+        max_tokens: selectedProfile.max_tokens,
+        tool_choice: selectedProfile.tool_choice,
+        parallel_tool_calls: selectedProfile.parallel_tool_calls,
+        stream: selectedProfile.stream,
         provider_allow_fallbacks: false,
-        require_parameters: true,
+        provider_sort: selectedProfile.provider.sort || null,
+        require_parameters: selectedProfile.provider.require_parameters,
         key_source: result.openrouter_key_source || null,
         key_preview: result.key_preview || null
     });
@@ -200,7 +227,7 @@ async function writeGlmModeArtifacts(cwd, result, profile, generatedAt) {
     });
 }
 function printHumanGlmResult(result, log) {
-    log(`GLM 5.2 MAD mode: ${result.ok ? result.status : 'blocked'}`);
+    log(`GLM 5.2 MAD mode: ${result.ok ? result.status : 'blocked'} (${result.profile})`);
     log(`Model: ${result.model}`);
     log(`GPT fallback: ${result.gpt_fallback_allowed ? 'allowed' : 'blocked'}`);
     if (result.openrouter_key_source)
@@ -233,6 +260,7 @@ async function promptConfirmLine(prompt, defaultYes) {
 export function buildGlmModeDryRunRequest() {
     return buildGlm52Request({
         messages: [{ role: 'user', content: 'SKS GLM dry run.' }],
+        profile: 'speed',
         stream: false,
         maxTokens: 1,
         toolChoice: 'none',

package/dist/core/providers/glm/glm-model-meta-cache.js

@@ -0,0 +1,19 @@
+import { SksLruCache } from '../../perf/lru-cache.js';
+const DAY_MS = 24 * 60 * 60 * 1000;
+export function createGlmModelMetaCache(maxEntries = 16, ttlMs = DAY_MS) {
+    const cache = new SksLruCache(maxEntries);
+    return {
+        get(model, now = Date.now()) {
+            const entry = cache.get(model);
+            if (!entry || entry.expiresAt <= now)
+                return null;
+            return entry;
+        },
+        set(model, reasoning, now = Date.now()) {
+            const entry = { model, reasoning, createdAt: now, expiresAt: now + ttlMs };
+            cache.set(model, entry, now);
+            return entry;
+        }
+    };
+}
+//# sourceMappingURL=glm-model-meta-cache.js.map

package/dist/core/providers/glm/glm-profile-resolver.js

@@ -0,0 +1,104 @@
+import { readOption } from '../../../cli/args.js';
+import { GLM_DEEP_MODE, GLM_DEEP_PROFILE, GLM_SPEED_MODE, GLM_SPEED_PROFILE, GLM_STRICT_MODE, GLM_STRICT_PROFILE, GLM_XHIGH_MODE, GLM_XHIGH_PROFILE } from './glm-52-settings.js';
+export function resolveGlmProfileFromArgs(args = []) {
+    const list = args.map(String);
+    const exactProvider = readOption(list, '--exact-provider', null);
+    const providerBlockers = exactProvider && !isValidOpenRouterProviderSlug(exactProvider)
+        ? [`invalid_openrouter_provider_slug:${exactProvider}`]
+        : [];
+    const base = list.includes('--xhigh')
+        ? profileFromConst('xhigh')
+        : list.includes('--strict')
+            ? profileFromConst('strict')
+            : list.includes('--deep')
+                ? profileFromConst('deep')
+                : profileFromConst('speed');
+    const provider = exactProvider && !providerBlockers.length
+        ? {
+            allow_fallbacks: false,
+            require_parameters: base.provider.require_parameters,
+            order: [exactProvider]
+        }
+        : list.includes('--ttft')
+            ? {
+                ...base.provider,
+                sort: 'latency',
+                preferred_max_latency: { p50: 1.5, p90: 4 }
+            }
+            : base.provider;
+    return {
+        ...base,
+        provider,
+        blockers: providerBlockers
+    };
+}
+export function profileFromConst(name) {
+    if (name === 'deep') {
+        return {
+            name,
+            mode: GLM_DEEP_MODE,
+            stream: GLM_DEEP_PROFILE.stream,
+            max_tokens: GLM_DEEP_PROFILE.max_tokens,
+            temperature: GLM_DEEP_PROFILE.temperature,
+            top_p: GLM_DEEP_PROFILE.top_p,
+            tool_choice: GLM_DEEP_PROFILE.tool_choice,
+            parallel_tool_calls: GLM_DEEP_PROFILE.parallel_tool_calls,
+            provider: GLM_DEEP_PROFILE.provider,
+            reasoning_effort: GLM_DEEP_PROFILE.reasoning_effort,
+            blockers: []
+        };
+    }
+    if (name === 'xhigh') {
+        return {
+            ...profileFromConst('deep'),
+            name,
+            mode: GLM_XHIGH_MODE,
+            max_tokens: GLM_XHIGH_PROFILE.max_tokens,
+            reasoning_effort: GLM_XHIGH_PROFILE.reasoning_effort,
+            blockers: []
+        };
+    }
+    if (name === 'strict') {
+        return {
+            ...profileFromConst('deep'),
+            name,
+            mode: GLM_STRICT_MODE,
+            response_format: {
+                type: 'json_schema',
+                json_schema: {
+                    name: 'sks_glm_strict_proof',
+                    strict: true,
+                    schema: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            summary: { type: 'string' },
+                            patch: { type: 'string' },
+                            proof: { type: 'object' }
+                        },
+                        required: ['summary', 'patch', 'proof']
+                    }
+                }
+            },
+            blockers: []
+        };
+    }
+    return {
+        name,
+        mode: GLM_SPEED_MODE,
+        stream: GLM_SPEED_PROFILE.stream,
+        max_tokens: GLM_SPEED_PROFILE.max_tokens,
+        temperature: GLM_SPEED_PROFILE.temperature,
+        top_p: GLM_SPEED_PROFILE.top_p,
+        tool_choice: GLM_SPEED_PROFILE.tool_choice,
+        parallel_tool_calls: GLM_SPEED_PROFILE.parallel_tool_calls,
+        provider: GLM_SPEED_PROFILE.provider,
+        reasoning_effort: GLM_SPEED_PROFILE.reasoning_effort,
+        stop: ['</sks_patch>'],
+        blockers: []
+    };
+}
+export function isValidOpenRouterProviderSlug(value) {
+    return /^(?!.*(?:^|\/)\.\.?(?:\/|$))[a-z0-9][a-z0-9._-]{0,63}(?:\/[a-z0-9][a-z0-9._-]{0,63}){0,3}$/i.test(value);
+}
+//# sourceMappingURL=glm-profile-resolver.js.map

package/dist/core/providers/glm/glm-reasoning-policy.js

@@ -0,0 +1,15 @@
+const FAST_REASONING_ORDER = ['none', 'minimal', 'low'];
+export function buildFastReasoningConfig(meta = null) {
+    if (meta?.mandatory === true)
+        return { exclude: true };
+    const supported = new Set(meta?.supported_efforts || []);
+    for (const effort of FAST_REASONING_ORDER) {
+        if (supported.has(effort))
+            return { effort, exclude: true };
+    }
+    return { exclude: true };
+}
+export function buildDeepReasoningConfig(effort) {
+    return { effort, exclude: true };
+}
+//# sourceMappingURL=glm-reasoning-policy.js.map