sneakoscope 4.0.4 → 4.0.6

package/dist/core/providers/glm/glm-patch-apply.js

@@ -0,0 +1,58 @@
+import { spawn } from 'node:child_process';
+import { parseUnifiedDiffPatch } from './glm-patch-parser.js';
+const PROTECTED_PATH = /(^|\/)(\.github|dist|node_modules)(\/|$)/;
+export async function checkAndApplyGlmPatch(input) {
+    const parsed = parseUnifiedDiffPatch(input.patch);
+    if (parsed.empty) {
+        return issue('glm_patch_empty', 'GLM output did not contain a non-empty unified diff.');
+    }
+    const blockedPath = parsed.touchedPaths.find((file) => PROTECTED_PATH.test(file));
+    if (blockedPath) {
+        return issue('glm_patch_protected_path', `GLM patch touched protected path: ${blockedPath}`);
+    }
+    const check = await runGitApply(input.cwd, input.patch, ['apply', '--check', '--whitespace=nowarn', '-']);
+    if (check.code !== 0) {
+        return issue('glm_patch_gate_failed', check.stderr || check.stdout || 'git apply --check failed.');
+    }
+    if (!input.apply) {
+        return {
+            ok: true,
+            value: {
+                checked: true,
+                applied: false,
+                touchedPaths: parsed.touchedPaths,
+                stdout: check.stdout,
+                stderr: check.stderr
+            }
+        };
+    }
+    const applied = await runGitApply(input.cwd, input.patch, ['apply', '--whitespace=nowarn', '-']);
+    if (applied.code !== 0) {
+        return issue('glm_patch_apply_failed', applied.stderr || applied.stdout || 'git apply failed.');
+    }
+    return {
+        ok: true,
+        value: {
+            checked: true,
+            applied: true,
+            touchedPaths: parsed.touchedPaths,
+            stdout: applied.stdout,
+            stderr: applied.stderr
+        }
+    };
+}
+function issue(code, message) {
+    return { ok: false, error: { code, message, severity: 'blocked' } };
+}
+function runGitApply(cwd, patch, args) {
+    return new Promise((resolve) => {
+        const child = spawn('git', [...args], { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => { stdout += String(chunk); });
+        child.stderr.on('data', (chunk) => { stderr += String(chunk); });
+        child.on('close', (code) => resolve({ code, stdout, stderr }));
+        child.stdin.end(patch);
+    });
+}
+//# sourceMappingURL=glm-patch-apply.js.map

package/dist/core/providers/glm/glm-patch-parser.js

@@ -0,0 +1,19 @@
+export function parseUnifiedDiffPatch(patch) {
+    const touched = new Set();
+    for (const line of patch.split(/\r?\n/)) {
+        const diff = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+        if (diff?.[1])
+            touched.add(diff[1]);
+        if (diff?.[2])
+            touched.add(diff[2]);
+        const file = line.match(/^(?:---|\+\+\+) [ab]\/(.+)$/);
+        if (file?.[1] && file[1] !== '/dev/null')
+            touched.add(file[1]);
+    }
+    return {
+        patch,
+        touchedPaths: [...touched],
+        empty: !patch.trim() || !/^diff --git /m.test(patch)
+    };
+}
+//# sourceMappingURL=glm-patch-parser.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-readiness.js

@@ -0,0 +1,5 @@
+import { runMadGlmMode } from './glm-mad-mode.js';
+export async function runGlmReadinessAndExit(args = []) {
+    return runMadGlmMode(args);
+}
+//# sourceMappingURL=glm-readiness.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

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

@@ -0,0 +1,64 @@
+import crypto from 'node:crypto';
+import { SksLruCache } from '../../perf/lru-cache.js';
+export function createGlmEncodedRequestCache(maxEntries = 128) {
+    return new SksLruCache(maxEntries);
+}
+export function encodeGlmRequestWithCache(request, cache = defaultEncodedRequestCache) {
+    const key = digestRequestForCache(request);
+    const hit = cache.get(key);
+    const body = JSON.stringify(request);
+    if (hit)
+        return { body: hit.bodyStored ? hit.body : body, entry: hit, cacheHit: true };
+    if (containsSecretLikeContent(body)) {
+        const entry = {
+            key,
+            body: '',
+            bodySha256: crypto.createHash('sha256').update(body).digest('hex'),
+            byteLength: Buffer.byteLength(body),
+            createdAt: Date.now(),
+            bodyStored: false,
+            skippedReason: 'secret_like_request_body_not_cached'
+        };
+        return { body, entry, cacheHit: false };
+    }
+    const entry = {
+        key,
+        body,
+        bodySha256: crypto.createHash('sha256').update(body).digest('hex'),
+        byteLength: Buffer.byteLength(body),
+        createdAt: Date.now(),
+        bodyStored: true
+    };
+    cache.set(key, entry);
+    return { body, entry, cacheHit: false };
+}
+export function digestRequestForCache(request) {
+    const safe = {
+        model: request.model,
+        messages: request.messages,
+        tools: request.tools || null,
+        response_format: request.response_format || null,
+        provider: request.provider || null,
+        max_tokens: request.max_tokens || null,
+        temperature: request.temperature || null,
+        top_p: request.top_p || null,
+        tool_choice: request.tool_choice || null,
+        parallel_tool_calls: request.parallel_tool_calls || null,
+        reasoning: request.reasoning || null,
+        session_id: request.session_id || null
+    };
+    return crypto.createHash('sha256').update(stableStringify(safe)).digest('hex');
+}
+function containsSecretLikeContent(body) {
+    return /\b(?:Bearer\s+[A-Za-z0-9._~+/-]+|sk-(?:or-)?[A-Za-z0-9_-]{12,}|OPENROUTER_API_KEY|SKS_OPENROUTER_API_KEY)\b/.test(body);
+}
+function stableStringify(value) {
+    if (!value || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(',')}]`;
+    const object = value;
+    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(',')}}`;
+}
+const defaultEncodedRequestCache = createGlmEncodedRequestCache();
+//# sourceMappingURL=glm-request-cache.js.map

package/dist/core/providers/glm/glm-run-controller.js

@@ -0,0 +1,66 @@
+import path from 'node:path';
+import { nowIso, randomId, writeJsonAtomic } from '../../fsx.js';
+import { GLM_SPEED_LIMITS } from './glm-run-timeout.js';
+import { isGlmTerminalPhase } from './glm-run-state.js';
+export function createGlmRunController(input = {}) {
+    const clock = input.now || nowIso;
+    const startedAt = clock();
+    const startedMs = Date.now();
+    let state = {
+        run_id: input.runId || `glm-${startedAt.replace(/[:.]/g, '-')}-${randomId(6)}`,
+        ...(input.missionId ? { mission_id: input.missionId } : {}),
+        phase: 'idle',
+        started_at: startedAt,
+        updated_at: startedAt,
+        turn_count: 0,
+        tool_round_count: 0,
+        no_progress_count: 0,
+        repeated_output_count: 0,
+        terminal: false
+    };
+    const limits = input.limits || GLM_SPEED_LIMITS;
+    return {
+        state: () => state,
+        transition: (phase, reason) => {
+            if (state.terminal || isGlmTerminalPhase(state.phase))
+                return state;
+            state = {
+                ...state,
+                phase,
+                updated_at: clock(),
+                terminal: isGlmTerminalPhase(phase),
+                ...(reason ? { terminal_reason: reason } : {})
+            };
+            return state;
+        },
+        terminate: (phase, reason, blockers = [], warnings = []) => {
+            state = {
+                ...state,
+                phase,
+                updated_at: clock(),
+                terminal: true,
+                terminal_reason: reason
+            };
+            return {
+                schema: 'sks.glm-run-termination.v1',
+                run_id: state.run_id,
+                terminal: true,
+                phase,
+                reason,
+                turn_count: state.turn_count,
+                wall_clock_ms: Math.min(Date.now() - startedMs, limits.max_wall_clock_ms),
+                blockers,
+                warnings
+            };
+        }
+    };
+}
+export async function writeGlmRunArtifacts(input) {
+    const dir = path.join(input.cwd, '.sneakoscope', 'glm', 'runs', input.state.run_id);
+    await writeJsonAtomic(path.join(dir, 'run-state.json'), input.state);
+    await writeJsonAtomic(path.join(dir, 'termination.json'), input.termination);
+    await writeJsonAtomic(path.join(dir, 'loop-guard.json'), input.loopGuard || { schema: 'sks.glm-loop-guard.v1', ok: true });
+    await writeJsonAtomic(path.join(dir, 'context-omissions.json'), input.contextOmissions || { omitted: [] });
+    return dir;
+}
+//# sourceMappingURL=glm-run-controller.js.map

package/dist/core/providers/glm/glm-run-state.js

@@ -0,0 +1,11 @@
+export const GLM_TERMINAL_PHASES = new Set([
+    'completed',
+    'blocked',
+    'failed',
+    'cancelled',
+    'timeout'
+]);
+export function isGlmTerminalPhase(phase) {
+    return GLM_TERMINAL_PHASES.has(phase);
+}
+//# sourceMappingURL=glm-run-state.js.map

package/dist/core/providers/glm/glm-run-timeout.js

@@ -0,0 +1,31 @@
+export const GLM_SPEED_LIMITS = {
+    max_turns: 2,
+    max_tool_rounds: 0,
+    max_wall_clock_ms: 90_000,
+    request_timeout_ms: 45_000,
+    idle_timeout_ms: 15_000,
+    max_no_progress_iterations: 1,
+    max_repeated_output: 1,
+    max_patch_retries: 1,
+    max_context_requests: 1
+};
+export const GLM_DEEP_LIMITS = {
+    max_turns: 4,
+    max_tool_rounds: 4,
+    max_wall_clock_ms: 240_000,
+    request_timeout_ms: 120_000,
+    idle_timeout_ms: 30_000,
+    max_no_progress_iterations: 2,
+    max_repeated_output: 2,
+    max_patch_retries: 2,
+    max_context_requests: 2
+};
+export function createRequestAbortController(timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), Math.max(1, timeoutMs));
+    return {
+        controller,
+        clear: () => clearTimeout(timeout)
+    };
+}
+//# sourceMappingURL=glm-run-timeout.js.map

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

@@ -0,0 +1,82 @@
+import crypto from 'node:crypto';
+import path from 'node:path';
+import { estimateGlmTokens, GLM_SPEED_CONTEXT_HARD_CAP_TOKENS, GLM_SPEED_CONTEXT_TARGET_TOKENS, trimToEstimatedTokens } from './glm-context-budget.js';
+const GENERATED_PATH = /(^|\/)(dist|node_modules|coverage|\.git)(\/|$)|(\.generated\.|\.map$)/;
+const DEFAULT_MAX_FILE_BYTES = 64 * 1024;
+export async function buildGlmSpeedContext(input) {
+    const maxTokens = Math.min(input.maxTokens || GLM_SPEED_CONTEXT_TARGET_TOKENS, GLM_SPEED_CONTEXT_HARD_CAP_TOKENS);
+    const maxFileBytes = Math.max(1024, input.maxFileBytes || DEFAULT_MAX_FILE_BYTES);
+    const sections = [];
+    const omitted = [];
+    addSection(sections, 'task', input.task);
+    addSection(sections, 'constraints', 'GLM speed mode: compact context, one-shot patch, no GPT/OpenAI fallback, no full TriWiki/proof-bank/repo dump.');
+    if (input.gitStatus)
+        addSection(sections, 'git_status', input.gitStatus);
+    if (input.lastError)
+        addSection(sections, 'error', trimToEstimatedTokens(input.lastError, 2000));
+    const readFile = input.readFile || (async () => null);
+    for (const mentioned of input.mentionedPaths || []) {
+        const normalized = mentioned.replace(/\\/g, '/');
+        if (GENERATED_PATH.test(normalized)) {
+            omitted.push({ kind: 'generated_or_large_path', path: mentioned, reason: 'speed_context_excludes_generated_or_vendor_paths' });
+            continue;
+        }
+        const absolute = path.isAbsolute(mentioned) ? mentioned : path.join(input.cwd, mentioned);
+        const rawText = input.readFileSnippet ? await input.readFileSnippet(absolute, maxFileBytes) : await readFile(absolute);
+        const text = rawText === null ? null : trimToUtf8Bytes(rawText, maxFileBytes);
+        if (text === null) {
+            omitted.push({ kind: 'file_snippet', path: mentioned, reason: 'unreadable_or_missing' });
+            continue;
+        }
+        if (Buffer.byteLength(rawText || '', 'utf8') > maxFileBytes) {
+            omitted.push({ kind: 'file_snippet_tail', path: mentioned, reason: 'speed_context_file_byte_budget' });
+        }
+        addSection(sections, 'file_snippet', trimToEstimatedTokens(text, 2400), path.relative(input.cwd, absolute) || mentioned);
+    }
+    const compact = enforceBudget(sections, omitted, maxTokens);
+    return {
+        schema: 'sks.glm-speed-context.v1',
+        digest: digestJson({ sections: compact.sections, omitted: compact.omitted }),
+        estimatedTokens: compact.sections.reduce((sum, section) => sum + section.tokenEstimate, 0),
+        sections: compact.sections,
+        omitted: compact.omitted
+    };
+}
+function addSection(sections, kind, content, sectionPath) {
+    sections.push({
+        kind,
+        ...(sectionPath ? { path: sectionPath } : {}),
+        content,
+        tokenEstimate: estimateGlmTokens(content)
+    });
+}
+function enforceBudget(sections, omitted, maxTokens) {
+    const kept = [];
+    const nextOmitted = [...omitted];
+    let total = 0;
+    for (const section of sections) {
+        if (total + section.tokenEstimate <= maxTokens) {
+            kept.push(section);
+            total += section.tokenEstimate;
+            continue;
+        }
+        nextOmitted.push({
+            kind: section.kind,
+            ...(section.path ? { path: section.path } : {}),
+            reason: 'speed_context_token_budget'
+        });
+    }
+    return { sections: kept, omitted: nextOmitted };
+}
+function digestJson(value) {
+    return crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function trimToUtf8Bytes(text, maxBytes) {
+    if (Buffer.byteLength(text, 'utf8') <= maxBytes)
+        return text;
+    let end = Math.min(text.length, maxBytes);
+    while (end > 0 && Buffer.byteLength(text.slice(0, end), 'utf8') > maxBytes)
+        end -= 1;
+    return text.slice(0, end);
+}
+//# sourceMappingURL=glm-speed-context.js.map

package/dist/core/providers/glm/glm-speed-gate.js

@@ -0,0 +1,40 @@
+import { parseGlmSpeedOutput } from './glm-speed-output-parser.js';
+const FORBIDDEN_TOUCHED_PATH = /(^|\/)(\.github|dist|node_modules)(\/|$)/;
+export function evaluateGlmSpeedGate(output) {
+    const started = Date.now();
+    const checks = [];
+    const parsed = parseGlmSpeedOutput(output);
+    checks.push(check('patch_parse', parsed.kind === 'patch', parsed.kind === 'patch' ? undefined : parsed.reason || parsed.kind));
+    const paths = parsed.kind === 'patch' ? touchedPaths(parsed.content) : [];
+    checks.push(check('touched_path_allowlist', paths.every((file) => !FORBIDDEN_TOUCHED_PATH.test(file)), paths.find((file) => FORBIDDEN_TOUCHED_PATH.test(file))));
+    checks.push(check('patch_apply_dry_run_ready', parsed.kind === 'patch' && /^diff --git /m.test(parsed.content), parsed.kind === 'patch' ? undefined : 'no_patch'));
+    const ok = checks.every((row) => row.ok);
+    return {
+        schema: 'sks.glm-speed-gate.v1',
+        ok,
+        gate_ms: Date.now() - started,
+        deterministic: true,
+        checks,
+        requiresDeepEscalation: !ok
+    };
+}
+function touchedPaths(patch) {
+    const paths = [];
+    for (const line of patch.split(/\r?\n/)) {
+        const match = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+        if (match?.[1])
+            paths.push(match[1]);
+        if (match?.[2])
+            paths.push(match[2]);
+    }
+    return [...new Set(paths)];
+}
+function check(id, ok, reason) {
+    return {
+        id,
+        ok,
+        ms: 0,
+        ...(reason ? { reason } : {})
+    };
+}
+//# sourceMappingURL=glm-speed-gate.js.map

package/dist/core/providers/glm/glm-speed-output-parser.js

@@ -0,0 +1,40 @@
+const ENVELOPES = {
+    patch: ['<sks_patch>', '</sks_patch>'],
+    need_context: ['<sks_need_context>', '</sks_need_context>'],
+    blocked: ['<sks_blocked>', '</sks_blocked>']
+};
+export function parseGlmSpeedOutput(text) {
+    for (const kind of ['patch', 'need_context', 'blocked']) {
+        const extracted = extractEnvelope(text, ENVELOPES[kind][0], ENVELOPES[kind][1]);
+        if (extracted !== null) {
+            return {
+                kind,
+                content: extracted,
+                ...(kind === 'need_context' ? { paths: parsePaths(extracted) } : {}),
+                ...(kind === 'blocked' ? { reason: parseReason(extracted) } : {})
+            };
+        }
+    }
+    const cleaned = text.trim();
+    return { kind: 'malformed', content: cleaned, reason: 'missing_glm_speed_output_envelope' };
+}
+function extractEnvelope(text, start, end) {
+    const startIndex = text.indexOf(start);
+    if (startIndex < 0)
+        return null;
+    const contentStart = startIndex + start.length;
+    const endIndex = text.indexOf(end, contentStart);
+    if (endIndex < 0)
+        return null;
+    return text.slice(contentStart, endIndex).trim();
+}
+function parsePaths(content) {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.match(/^\s*-\s*(.+?)\s*$/)?.[1])
+        .filter((value) => Boolean(value));
+}
+function parseReason(content) {
+    return content.match(/reason:\s*(.+)/i)?.[1]?.trim() || content.trim();
+}
+//# sourceMappingURL=glm-speed-output-parser.js.map

package/dist/core/providers/glm/glm-tool-schema-cache.js

@@ -0,0 +1,19 @@
+import crypto from 'node:crypto';
+import { SksLruCache } from '../../perf/lru-cache.js';
+export function createGlmToolSchemaCache(maxEntries = 64) {
+    const cache = new SksLruCache(maxEntries);
+    return {
+        get(toolsetVersion) {
+            return cache.get(toolsetVersion);
+        },
+        set(toolsetVersion, tools) {
+            const entry = { key: toolsetVersion, tools, createdAt: Date.now() };
+            cache.set(toolsetVersion, entry);
+            return entry;
+        }
+    };
+}
+export function digestToolset(tools) {
+    return crypto.createHash('sha256').update(JSON.stringify(tools)).digest('hex');
+}
+//# sourceMappingURL=glm-tool-schema-cache.js.map

package/dist/core/providers/openrouter/openrouter-client.js

@@ -1,24 +1,44 @@
 import { OPENROUTER_CHAT_COMPLETIONS_URL } from './openrouter-types.js';
 import { invalidOpenRouterResponseIssue, normalizeOpenRouterError } from './openrouter-error.js';
 import { redactOpenRouterString } from '../../security/redact-secrets.js';
+import { encodeGlmRequestWithCache } from '../glm/glm-request-cache.js';
 export async function sendOpenRouterChatCompletion(input) {
     try {
         const doFetch = input.fetchImpl || fetch;
+        const encoded = encodeGlmRequestWithCache(input.request);
+        const controller = input.timeoutMs ? new AbortController() : null;
+        const timeout = controller
+            ? setTimeout(() => controller.abort(), Math.max(1, input.timeoutMs || 0))
+            : null;
+        const signal = input.signal || controller?.signal;
         const response = await doFetch(input.endpoint || OPENROUTER_CHAT_COMPLETIONS_URL, {
             method: 'POST',
+            ...(signal ? { signal } : {}),
             headers: {
                 Authorization: `Bearer ${input.apiKey}`,
                 'Content-Type': 'application/json',
                 'X-OpenRouter-Title': 'Sneakoscope-Codex'
             },
-            body: JSON.stringify(input.request)
+            body: encoded.body
         });
+        if (timeout)
+            clearTimeout(timeout);
         const text = await response.text();
         if (!response.ok)
             return { ok: false, error: normalizeOpenRouterError(response.status, text) };
         return parseOpenRouterResponse(text);
     }
     catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+            return {
+                ok: false,
+                error: {
+                    code: 'glm_request_timeout',
+                    message: `OpenRouter request aborted after ${input.timeoutMs || 'external'}ms.`,
+                    severity: 'failed'
+                }
+            };
+        }
         return {
             ok: false,
             error: {