@bahulam/code 0.1.23 → 0.1.25

package/src/core/context-reduction.mjs

@@ -0,0 +1,207 @@
+import { findShippedModel } from '../config/model-catalog.mjs';
+
+/**
+ * Shared client-side context reduction contract.
+ *
+ * This mirrors the backend context contract so LocalAgent can reduce the
+ * same history shape at the same boundary. The transport-specific LLM call
+ * is supplied by the caller; this module owns policy and history rewriting.
+ */
+
+export const SUMMARY_MARKER = '[Context summary — earlier conversation condensed]';
+export const DISTILLATION_MARKER = '[Context distillation — active ingredients preserved]';
+
+const PRODUCT_POLICIES = Object.freeze({
+  // workingSetRatio is an optimization budget, not a provider hard limit.
+  // It scales with the selected model's usable context window so large
+  // models do not grow to their full capacity before we protect cache reuse
+  // and attention quality.
+  chat: Object.freeze({ triggerRatio: 0.72, targetRatio: 0.48, workingSetRatio: 0.18, preserve: 12, prune: 'aggressive' }),
+  ide: Object.freeze({ triggerRatio: 0.78, targetRatio: 0.52, workingSetRatio: 0.20, preserve: 10, prune: 'conservative' }),
+  workspace: Object.freeze({ triggerRatio: 0.70, targetRatio: 0.45, workingSetRatio: 0.16, preserve: 14, prune: 'protected' }),
+});
+
+export function contextProduct(product = 'ide') {
+  const value = String(product || '').toLowerCase();
+  if (value.includes('chat')) return 'chat';
+  if (value.includes('workspace')) return 'workspace';
+  return 'ide';
+}
+
+export function contextPolicy(product = 'ide') {
+  return PRODUCT_POLICIES[contextProduct(product)];
+}
+
+export function toolPruningPolicy(product = 'ide') {
+  const profile = contextProduct(product);
+  return {
+    profile,
+    protected: [
+      'write_file', 'edit_file', 'delete_file', 'validate_build',
+      'lint_check', 'remember', 'todo_write', 'ask_user',
+    ],
+    eligible: profile === 'chat'
+      ? ['read_file', 'search_code', 'search_files', 'list_files', 'shell']
+      : profile === 'workspace'
+        ? ['read_file', 'search_code', 'search_files', 'list_files']
+        : ['read_file', 'search_code', 'search_files', 'list_files', 'shell'],
+  };
+}
+
+export function resolveContextBudget({
+  product = 'ide', model = null, contextLength = null, maxOutput = null,
+  fixedPromptTokens = 0, explicitThreshold = null,
+} = {}) {
+  const policy = contextPolicy(product);
+  const catalog = findShippedModel(model);
+  const window = Number(contextLength || catalog?.context_length || 0);
+  const output = Number(maxOutput || catalog?.max_output || 0);
+  const explicit = Number(explicitThreshold || 0);
+  if (explicit > 0) {
+    return { ...policy, threshold: Math.max(20_000, Math.floor(explicit)), source: 'explicit' };
+  }
+  if (!Number.isFinite(window) || window <= 0) {
+    return { ...policy, threshold: 160_000, source: 'fallback' };
+  }
+  const reservedOutput = output > 0 ? output : Math.floor(window * 0.10);
+  const safety = Math.max(1024, Math.floor(window * 0.03));
+  const usable = Math.max(20_000, window - reservedOutput - Math.max(0, fixedPromptTokens) - safety);
+  const workingSet = Math.max(20_000, Math.floor(usable * policy.workingSetRatio));
+  return {
+    ...policy,
+    threshold: Math.max(20_000, Math.floor(workingSet * policy.triggerRatio)),
+    targetTokens: Math.max(10_000, Math.floor(workingSet * policy.targetRatio)),
+    contextLength: window,
+    reservedOutput,
+    usableTokens: usable,
+    workingSetTokens: workingSet,
+    fixedPromptTokens: Math.max(0, fixedPromptTokens),
+    source: 'model_catalog',
+  };
+}
+
+export function contextReductionConfig(env = process.env, product = 'ide') {
+  const profileName = contextProduct(product).toUpperCase();
+  const strategyRaw = String(
+    env[`BAHULAM_${profileName}_CONTEXT_STRATEGY`]
+      || env.BAHULAM_CONTEXT_STRATEGY
+      || env.BAHULAM_CONTEXT_REDUCTION_STRATEGY
+      || 'distillation',
+  ).trim().toLowerCase();
+  const threshold = Number.parseInt(
+    env.BAHULAM_SUMMARIZE_THRESHOLD || env.BAHULAM_CHAT_SUMMARIZE_THRESHOLD || '',
+    10,
+  );
+  const preserve = Number.parseInt(
+    env.BAHULAM_SUMMARIZE_PRESERVE_TURNS || env.BAHULAM_CHAT_SUMMARIZE_PRESERVE_TURNS || '',
+    10,
+  );
+  const sigma = Number.parseFloat(
+    env.BAHULAM_CONTEXT_DISTILLATION_SIGMA || env.BAHULAM_COMPACTION_SIGMA || '1.5',
+  );
+  return {
+    enabled: !['0', 'false', 'no', 'off'].includes(String(env.BAHULAM_SUMMARIZE || 'true').toLowerCase()),
+    strategy: ['summary', 'summarize', 'summarization'].includes(strategyRaw)
+      ? 'summarization'
+      : 'distillation',
+    threshold: Number.isFinite(threshold) && threshold > 0 ? Math.max(20_000, threshold) : null,
+    preserve: Number.isFinite(preserve) && preserve > 0 ? Math.max(2, preserve) : null,
+    sigma: Number.isFinite(sigma) ? Math.max(0.5, Math.min(4, sigma)) : 1.5,
+  };
+}
+
+export function estimateMessagesTokens(messages = []) {
+  return (Array.isArray(messages) ? messages : []).reduce((total, message) => {
+    let content = message?.content;
+    if (typeof content !== 'string') {
+      try { content = JSON.stringify(content ?? ''); } catch { content = String(content ?? ''); }
+    }
+    return total + Math.floor(String(content).length / 4) + 8;
+  }, 0);
+}
+
+function messageText(message) {
+  const content = message?.content;
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map(block => block?.text || block?.content || block?.name || '').join(' ');
+  }
+  try { return JSON.stringify(content ?? ''); } catch { return String(content ?? ''); }
+}
+
+function toolNames(message) {
+  return (Array.isArray(message?.content) ? message.content : [])
+    .map(block => block?.name || block?.tool || block?.tool_name)
+    .filter(Boolean)
+    .map(String)
+    .map(name => name.toLowerCase());
+}
+
+function scoreMessage(message, index, total, preserve) {
+  const pos = total <= 1 ? 1 : index / (total - 1);
+  const edgeScore = 2 * ((Math.abs(pos - 0.5) * 2) ** 2);
+  const text = messageText(message);
+  const tools = toolNames(message);
+  let score = edgeScore;
+  const reasons = ['position'];
+  if (index === 0) { score += 4; reasons.push('root_intent'); }
+  if (index >= Math.max(0, total - preserve)) { score += 4; reasons.push('recent_tail'); }
+  if (message?.role === 'user') { score += 1.5; reasons.push('user_instruction'); }
+  if (tools.some(t => ['write', 'write_file', 'edit', 'edit_file', 'delete_file'].includes(t))) {
+    score += 4; reasons.push('durable_write');
+  }
+  if (tools.some(t => ['read', 'read_file', 'search_code', 'search_files', 'list_files'].includes(t))) {
+    score += 1.2; reasons.push('reference');
+  }
+  if (/(exit[_ -]?code|traceback|error|failed|exception|fatal)/i.test(text)) {
+    score += 1.2; reasons.push('failure_signal');
+  }
+  return { score, reasons, tools, text };
+}
+
+export function distillMessages(messages = [], { preserve = 10, sigma = 1.5, maxLines = 180 } = {}) {
+  const rows = (Array.isArray(messages) ? messages : []).filter(Boolean);
+  if (!rows.length) return null;
+  const scored = rows.map((message, index) => scoreMessage(message, index, rows.length, preserve));
+  const mean = scored.reduce((sum, row) => sum + row.score, 0) / scored.length;
+  const variance = scored.reduce((sum, row) => sum + ((row.score - mean) ** 2), 0) / scored.length;
+  const fullThreshold = mean + sigma * Math.sqrt(variance);
+  const groups = { full: [], structured: [], distilled: [] };
+  scored.forEach((row, index) => {
+    const forced = index === 0 || index >= Math.max(0, rows.length - preserve) || row.reasons.includes('durable_write');
+    const action = forced || row.score >= fullThreshold
+      ? 'full'
+      : row.score >= mean ? 'structured' : 'distilled';
+    const compact = row.text.replace(/\s+/g, ' ').trim().slice(0, action === 'full' ? 400 : 260);
+    groups[action].push(`- ${action}: ${row.tools.length ? `tool=${row.tools.slice(0, 3).join(',')}; ` : ''}${rows[index]?.role || 'message'}: ${compact}`);
+  });
+  return [
+    DISTILLATION_MARKER,
+    `policy=context-distillation-v1 sigma=${sigma} counts=${JSON.stringify({ keep_full: groups.full.length, keep_structured: groups.structured.length, distill: groups.distilled.length })}`,
+    '', 'Active ingredients kept full:', ...(groups.full.slice(0, maxLines) || ['- none']),
+    '', 'Structured middle evidence:', ...(groups.structured.slice(0, maxLines) || ['- none']),
+    '', 'Boiled-away noisy trail:', ...(groups.distilled.slice(0, Math.max(12, Math.floor(maxLines / 3))) || ['- none']),
+  ].join('\n');
+}
+
+export function collapseMessages(messages, summary, preserve = 10) {
+  const rows = Array.isArray(messages) ? messages : [];
+  let start = Math.max(0, rows.length - Math.max(2, preserve));
+  // Never hand the next provider an orphaned tool_result. If the retention
+  // boundary lands on a result-only user message, include the preceding
+  // assistant tool-use message as well.
+  while (start > 0 && isToolResultOnly(rows[start])) start--;
+  const tail = rows.slice(start);
+  return [
+    { role: 'user', content: summary },
+    { role: 'assistant', content: 'Understood — continuing from the summarized context above.' },
+    ...tail,
+  ];
+}
+
+function isToolResultOnly(message) {
+  return message?.role === 'user'
+    && Array.isArray(message.content)
+    && message.content.length > 0
+    && message.content.every(block => block?.type === 'tool_result');
+}

package/src/core/headless.mjs

@@ -29,6 +29,9 @@ import { startHttpDashboard } from '../daemon/http-dashboard.mjs';
 import { resolvePending } from '../daemon/approval-store.mjs';
 import { startRelayBridge } from '../daemon/relay-client.mjs';
 import { loadRemoteConfig } from '../commands/remote.mjs';
+import { resolveGatewayUrl } from './backend-url.mjs';
+import { DEFAULT_REASONING_MODEL } from '../config/model-defaults.mjs';
+import { applyModelSelection, resolveModelSelection } from './model-selection.mjs';
 import { writeSessionMeta } from './event-log.mjs';
 import { daemonSessionDir } from './paths.mjs';
 import { publishSessionDirectory, markSessionClosed } from '../daemon/session-publisher.mjs';
@@ -49,8 +52,10 @@ import {
  * @param {number} [opts.maxCost] - abort if cost exceeds this USD amount
  * @param {boolean} [opts.verbose] - show progress on stderr
  */
-export async function runHeadless({ instruction, model, timeout = 300, maxCost, verbose = false, cacheReport = null, local = false, vision = [], agent = null, workflow = null }) {
+export async function runHeadless({ instruction, model, timeout = 300, maxCost, verbose = false, cacheReport = null, local = false, mode = null, vision = [], agent = null, workflow = null }) {
     const startTime = Date.now();
+    const runtimeMode = mode || 'local';
+    const cliLocal = runtimeMode === 'local' || runtimeMode === 'direct';
 
     const log = (msg) => {
         if (verbose) process.stderr.write(`[headless] ${msg}\n`);
@@ -66,9 +71,11 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
     const graphTarget = agent || workflow;
     const anthKey = process.env.ANTHROPIC_API_KEY || creds.anthropicKey;
     const orKey = process.env.OPENROUTER_API_KEY || creds.openRouterKey;
+    const gatewayUrl = resolveGatewayUrl();
+    const localSessionId = `local_${Date.now()}_${Math.random().toString(16).slice(2, 10)}`;
     // Graph runs execute locally and only need a model key; everything
     // else still requires login (the backend runs the agent loop).
-    if (!creds.token && !(graphTarget && (anthKey || orKey))) {
+    if (!creds.token && runtimeMode !== 'direct' && !(graphTarget && (anthKey || orKey))) {
         emit({ type: 'error', error: 'Not logged in. Run: bahulam login' });
         process.exit(1);
     }
@@ -94,6 +101,10 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
                 listLocalWorkflows: () => listLocalWorkflows(process.cwd()),
                 renderEvent: (event) => emit({ type: event.type, ...event.data }),
                 credentials: { apiKey: anthKey, openRouterKey: orKey },
+                modelTransport: runtimeMode === 'local' ? 'gateway' : 'direct',
+                gatewayUrl: runtimeMode === 'local' ? gatewayUrl : null,
+                gatewayToken: runtimeMode === 'local' ? creds.token : null,
+                sessionId: localSessionId,
                 defaultModel: model || null,
                 cwd: process.cwd(),
             });
@@ -121,6 +132,10 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
             listLocalWorkflows: () => listLocalWorkflows(process.cwd()),
             renderEvent: (event) => emit({ type: event.type, ...event.data }),
             credentials: { apiKey: anthKey, openRouterKey: orKey },
+            modelTransport: runtimeMode === 'local' ? 'gateway' : 'direct',
+            gatewayUrl: runtimeMode === 'local' ? gatewayUrl : null,
+            gatewayToken: runtimeMode === 'local' ? creds.token : null,
+            sessionId: localSessionId,
             defaultModel: model || null,
             cwd: process.cwd(),
         });
@@ -165,6 +180,10 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
             listLocalWorkflows: () => listLocalWorkflows(process.cwd()),
             renderEvent: (event) => emit({ type: event.type, ...event.data }),
             credentials: { apiKey: anthKey, openRouterKey: orKey },
+            modelTransport: runtimeMode === 'local' ? 'gateway' : 'direct',
+            gatewayUrl: runtimeMode === 'local' ? gatewayUrl : null,
+            gatewayToken: runtimeMode === 'local' ? creds.token : null,
+            sessionId: localSessionId,
             defaultModel: model || null,
             cwd: process.cwd(),
         });
@@ -185,27 +204,70 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
     // just added to _callClaude / _callOpenRouter. Model comes from the
     // --model flag (which overrides settings dynamically for benchmarking).
     let client;
-    if (local) {
+    if (runtimeMode === 'local') {
         const { LocalAgent } = await import('./local-agent.mjs');
-        const localModel = model || creds.models?.local || 'anthropic/claude-sonnet-4';
-        const orKey = process.env.OPENROUTER_API_KEY || creds.openRouterKey;
-        const anthKey = process.env.ANTHROPIC_API_KEY || creds.anthropicKey;
-        if (!orKey && !anthKey) {
-            emit({ type: 'error', error: '--local requires OPENROUTER_API_KEY or ANTHROPIC_API_KEY' });
+        const localSelection = resolveModelSelection({
+            explicitModel: model,
+            modelOverrides: creds.modelConfig,
+            modelMode: creds.modelMode,
+            modelRoute: creds.routePreference,
+            profileModels: creds.models,
+            modeModels: { fast: creds.models?.fast },
+            fallbackModel: DEFAULT_REASONING_MODEL,
+        });
+        const localModel = localSelection.model;
+        const gatewayToken = creds.token;
+        if (!gatewayToken) {
+            emit({ type: 'error', error: '--local requires an authenticated Bahulam session' });
             process.exit(1);
         }
+        const pluginSchemas = toolExecutor.listPluginToolSchemas?.() || [];
         client = {
             execute: (instr, ctx) => new LocalAgent({
-                apiKey: anthKey,
-                openRouterKey: orKey,
                 model: localModel,
                 toolExecutor,
                 verbose,
                 cwd: process.cwd(),
                 maxTurns: 50,
+                gatewayUrl,
+                gatewayToken,
+                sessionId: localSessionId,
+                extraToolSchemas: pluginSchemas,
+            }).execute(instr, ctx),
+        };
+        log(`Local mode via Bahulam Gateway: ${localModel}`);
+    } else if (runtimeMode === 'direct') {
+        const { LocalAgent } = await import('./local-agent.mjs');
+        const directSelection = resolveModelSelection({
+            explicitModel: model,
+            modelOverrides: creds.modelConfig,
+            modelMode: creds.modelMode,
+            modelRoute: creds.routePreference,
+            profileModels: creds.models,
+            modeModels: { fast: creds.models?.fast },
+            fallbackModel: DEFAULT_REASONING_MODEL,
+        });
+        const directModel = directSelection.model;
+        const directOpenRouterKey = process.env.OPENROUTER_API_KEY || creds.openRouterKey;
+        const directAnthropicKey = process.env.ANTHROPIC_API_KEY || creds.anthropicKey;
+        if (!directOpenRouterKey && !directAnthropicKey) {
+            emit({ type: 'error', error: '--direct requires OPENROUTER_API_KEY or ANTHROPIC_API_KEY' });
+            process.exit(1);
+        }
+        const pluginSchemas = toolExecutor.listPluginToolSchemas?.() || [];
+        client = {
+            execute: (instr, ctx) => new LocalAgent({
+                apiKey: directAnthropicKey,
+                openRouterKey: directOpenRouterKey,
+                model: directModel,
+                toolExecutor,
+                verbose,
+                cwd: process.cwd(),
+                maxTurns: 50,
+                extraToolSchemas: pluginSchemas,
             }).execute(instr, ctx),
         };
-        log(`Local mode: ${localModel}`);
+        log(`Direct mode: ${directModel}`);
     } else {
         client = new BahulamStreamClient({
             baseUrl: creds.backendUrl,
@@ -213,6 +275,7 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
             toolExecutor,
             approvalManager: approval,
             pluginRegistry,
+            mode: runtimeMode === 'bundled' ? 'bundled' : 'remote',
         });
     }
 
@@ -225,7 +288,7 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
     }, timeoutMs);
 
     // ── Vision analysis preflight ──
-    if (!local) {
+    if (!cliLocal) {
         try {
             const prepared = prepareImageAttachments(instruction, {
                 cwd: process.cwd(),
@@ -280,7 +343,16 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
         }),
         agent_context: toolExecutor.getAgentContext(),
     };
-    if (model) execContext.model_override = model;
+    const modelSelection = resolveModelSelection({
+        explicitModel: model,
+        modelOverrides: creds.modelConfig,
+        modelMode: creds.modelMode,
+        modelRoute: creds.routePreference,
+        profileModels: creds.models,
+        modeModels: { fast: creds.models?.fast },
+        fallbackModel: DEFAULT_REASONING_MODEL,
+    });
+    Object.assign(execContext, applyModelSelection({}, modelSelection));
 
     let primaryToolCount = 0;
     let subAgentForwardedToolCount = 0;