@link-assistant/agent 0.18.2 → 0.19.0

package/src/session/prompt.ts

@@ -24,7 +24,7 @@ import { Instance } from '../project/instance';
 import { Bus } from '../bus';
 import { ProviderTransform } from '../provider/transform';
 import { SystemPrompt } from './system';
-import { Flag } from '../flag/flag';
+import { config, isVerbose } from '../config/config';
 import { Token } from '../util/token';
 
 import PROMPT_PLAN from '../session/prompt/plan.txt';
@@ -684,7 +684,7 @@ export namespace SessionPrompt {
         : [];
 
       // Verbose logging: output request details for debugging
-      if (Flag.OPENCODE_VERBOSE) {
+      if (isVerbose()) {
         const systemTokens = system.reduce(
           (acc, s) => acc + Token.estimate(s),
           0
@@ -766,8 +766,8 @@ export namespace SessionPrompt {
       const result = await processor.process(() =>
         streamText({
           timeout: {
-            chunkMs: Flag.STREAM_CHUNK_TIMEOUT_MS(),
-            stepMs: Flag.STREAM_STEP_TIMEOUT_MS(),
+            chunkMs: config.streamChunkTimeoutMs,
+            stepMs: config.streamStepTimeoutMs,
           },
           onError(error) {
             log.error(() => ({ message: 'stream error', error }));
@@ -1671,7 +1671,7 @@ export namespace SessionPrompt {
     modelID: string;
   }) {
     // Skip title generation if disabled (default)
-    if (!Flag.GENERATE_TITLE) {
+    if (!config.generateTitle) {
       log.info(() => ({
         message: 'title generation disabled',
         hint: 'Enable with --generate-title flag or AGENT_GENERATE_TITLE=true',

package/src/session/retry.ts

@@ -1,5 +1,5 @@
 import { MessageV2 } from './message-v2';
-import { Flag } from '../flag/flag';
+import { config } from '../config/config';
 import { Log } from '../util/log';
 
 export namespace SessionRetry {
@@ -13,16 +13,16 @@ export namespace SessionRetry {
   // This caps exponential backoff when headers are not available
   // Can be configured via AGENT_MAX_RETRY_DELAY env var
   export function getMaxRetryDelay(): number {
-    return Flag.MAX_RETRY_DELAY();
+    return config.maxRetryDelay * 1000;
   }
 
   // Get retry timeout in milliseconds
   export function getRetryTimeout(): number {
-    return Flag.RETRY_TIMEOUT() * 1000;
+    return config.retryTimeout * 1000;
   }
 
   /**
-   * Error thrown when retry-after exceeds AGENT_RETRY_TIMEOUT
+   * Error thrown when retry-after exceeds LINK_ASSISTANT_AGENT_RETRY_TIMEOUT
    * This indicates the wait time is too long and we should fail immediately
    */
   export class RetryTimeoutExceededError extends Error {
@@ -34,7 +34,7 @@ export namespace SessionRetry {
       const maxTimeoutHours = (maxTimeoutMs / 1000 / 3600).toFixed(2);
       super(
         `API returned retry-after of ${retryAfterHours} hours, which exceeds the maximum retry timeout of ${maxTimeoutHours} hours. ` +
-          `Failing immediately instead of waiting. You can adjust AGENT_RETRY_TIMEOUT env var to increase the limit.`
+          `Failing immediately instead of waiting. You can adjust LINK_ASSISTANT_AGENT_RETRY_TIMEOUT env var to increase the limit.`
       );
       this.name = 'RetryTimeoutExceededError';
       this.retryAfterMs = retryAfterMs;
@@ -75,7 +75,7 @@ export namespace SessionRetry {
     sessionID: string,
     errorType: string
   ): { shouldRetry: boolean; elapsedTime: number; maxTime: number } {
-    const maxTime = Flag.RETRY_TIMEOUT() * 1000; // Convert to ms
+    const maxTime = config.retryTimeout * 1000; // Convert to ms
     const state = retryStates.get(sessionID);
 
     if (!state || state.errorType !== errorType) {
@@ -198,15 +198,15 @@ export namespace SessionRetry {
    *
    * RETRY LOGIC (per issue #157 requirements):
    * 1. If retry-after header is available:
-   *    - If retry-after <= AGENT_RETRY_TIMEOUT: use it directly (exact time)
-   *    - If retry-after > AGENT_RETRY_TIMEOUT: throw RetryTimeoutExceededError (fail immediately)
+   *    - If retry-after <= LINK_ASSISTANT_AGENT_RETRY_TIMEOUT: use it directly (exact time)
+   *    - If retry-after > LINK_ASSISTANT_AGENT_RETRY_TIMEOUT: throw RetryTimeoutExceededError (fail immediately)
    * 2. If no retry-after header:
    *    - Use exponential backoff up to AGENT_MAX_RETRY_DELAY
    *
    * Adds jitter to prevent thundering herd when multiple requests retry.
    * See: https://github.com/link-assistant/agent/issues/157
    *
-   * @throws {RetryTimeoutExceededError} When retry-after exceeds AGENT_RETRY_TIMEOUT
+   * @throws {RetryTimeoutExceededError} When retry-after exceeds LINK_ASSISTANT_AGENT_RETRY_TIMEOUT
    */
   export function delay(error: MessageV2.APIError, attempt: number): number {
     const maxRetryTimeout = getRetryTimeout();

package/src/session/summary.ts

@@ -13,7 +13,7 @@ import path from 'path';
 import { Instance } from '../project/instance';
 import { Storage } from '../storage/storage';
 import { Bus } from '../bus';
-import { Flag } from '../flag/flag';
+import { config, isVerbose } from '../config/config';
 import { Token } from '../util/token';
 
 export namespace SessionSummary {
@@ -83,7 +83,7 @@ export namespace SessionSummary {
 
     // Skip AI-powered summarization if disabled
     // See: https://github.com/link-assistant/agent/issues/217
-    if (!Flag.SUMMARIZE_SESSION) {
+    if (!config.summarizeSession) {
       log.info(() => ({
         message: 'session summarization disabled',
         hint: 'Enable with --summarize-session flag (enabled by default) or AGENT_SUMMARIZE_SESSION=true',
@@ -141,7 +141,7 @@ export namespace SessionSummary {
       return;
     }
 
-    if (Flag.OPENCODE_VERBOSE) {
+    if (isVerbose()) {
       log.info(() => ({
         message: 'summarization model loaded',
         providerID: model.providerID,
@@ -167,7 +167,7 @@ export namespace SessionSummary {
               </text>
             `;
 
-      if (Flag.OPENCODE_VERBOSE) {
+      if (isVerbose()) {
         log.info(() => ({
           message: 'generating title via API',
           providerID: model.providerID,
@@ -203,7 +203,7 @@ export namespace SessionSummary {
         model: model.language,
       });
 
-      if (Flag.OPENCODE_VERBOSE) {
+      if (isVerbose()) {
         log.info(() => ({
           message: 'title API response received',
           providerID: model.providerID,
@@ -234,7 +234,7 @@ export namespace SessionSummary {
         const modelMessages = await MessageV2.toModelMessage(messages);
         const conversationContent = JSON.stringify(modelMessages);
 
-        if (Flag.OPENCODE_VERBOSE) {
+        if (isVerbose()) {
           log.info(() => ({
             message: 'generating body summary via API',
             providerID: model.providerID,
@@ -264,7 +264,7 @@ export namespace SessionSummary {
           ],
           headers: model.info.headers,
         }).catch((err) => {
-          if (Flag.OPENCODE_VERBOSE) {
+          if (isVerbose()) {
             log.warn(() => ({
               message: 'body summary API call failed',
               providerID: model.providerID,
@@ -276,7 +276,7 @@ export namespace SessionSummary {
           return undefined;
         });
         if (result) {
-          if (Flag.OPENCODE_VERBOSE) {
+          if (isVerbose()) {
             log.info(() => ({
               message: 'body summary API response received',
               providerID: model.providerID,

package/src/session/system.ts

@@ -1,7 +1,7 @@
 import { Ripgrep } from '../file/ripgrep';
 import { Global } from '../global';
 import { Filesystem } from '../util/filesystem';
-import { Config } from '../config/config';
+import { Config } from '../config/file-config';
 
 import { Instance } from '../project/instance';
 import path from 'path';

package/src/snapshot/index.ts

@@ -4,7 +4,7 @@ import fs from 'fs/promises';
 import { Log } from '../util/log';
 import { Global } from '../global';
 import z from 'zod';
-import { Config } from '../config/config';
+import { Config } from '../config/file-config';
 import { Instance } from '../project/instance';
 
 export namespace Snapshot {

package/src/tool/read.ts

@@ -4,6 +4,7 @@ import * as path from 'path';
 import { Tool } from './tool';
 import { FileTime } from '../file/time';
 import DESCRIPTION from './read.txt';
+import { config } from '../config/config';
 import { Filesystem } from '../util/filesystem';
 import { Instance } from '../project/instance';
 import { Provider } from '../provider/provider';
@@ -70,8 +71,8 @@ export const ReadTool = Tool.define('read', {
       return model.info.modalities?.input?.includes('image') ?? false;
     })();
     if (isImage) {
-      // Image format validation (can be disabled via environment variable)
-      const verifyImages = process.env.VERIFY_IMAGES_AT_READ_TOOL !== 'false';
+      // Image format validation (can be disabled via LINK_ASSISTANT_AGENT_VERIFY_IMAGES_AT_READ_TOOL)
+      const verifyImages = config.verifyImagesAtReadTool;
       if (verifyImages && !supportsImages) {
         throw new Error(
           `Failed to read image: ${filepath}, model may not be able to read images`
@@ -90,7 +91,7 @@ export const ReadTool = Tool.define('read', {
               )
                 .map((b) => b.toString(16).padStart(2, '0'))
                 .join(' ')}\n` +
-              `To disable image validation, set environment variable: VERIFY_IMAGES_AT_READ_TOOL=false`
+              `To disable image validation, set environment variable: LINK_ASSISTANT_AGENT_VERIFY_IMAGES_AT_READ_TOOL=false`
           );
         }
       }

package/src/tool/registry.ts

@@ -13,10 +13,9 @@ import { InvalidTool } from './invalid';
 import type { Agent } from '../agent/agent';
 import { Tool } from './tool';
 import { Instance } from '../project/instance';
-import { Config } from '../config/config';
+import { Config } from '../config/file-config';
 import { WebSearchTool } from './websearch';
 import { CodeSearchTool } from './codesearch';
-import { Flag } from '../flag/flag';
 
 export namespace ToolRegistry {
   export const state = Instance.state(async () => {

package/src/tool/websearch.ts

@@ -1,7 +1,7 @@
 import z from 'zod';
 import { Tool } from './tool';
 import DESCRIPTION from './websearch.txt';
-import { Config } from '../config/config';
+import { Config } from '../config/file-config';
 import { createVerboseFetch } from '../util/verbose-fetch';
 
 const verboseFetch = createVerboseFetch(fetch, { caller: 'websearch' });

package/src/util/log-lazy.ts

@@ -1,5 +1,5 @@
 import makeLog, { levels, LogLevel } from 'log-lazy';
-import { Flag } from '../flag/flag';
+import { config, isVerbose } from '../config/config';
 
 /**
  * JSON Lazy Logger
@@ -53,10 +53,8 @@ const LEVEL_PRESETS = {
 
 type LevelPreset = keyof typeof LEVEL_PRESETS;
 
-import { Flag } from '../flag/flag';
-
-// Compact JSON mode (can be set at runtime, initialized from Flag)
-let compactJsonMode = Flag.COMPACT_JSON();
+// Compact JSON mode (can be set at runtime, initialized from config)
+let compactJsonMode = false; // Deferred to avoid circular init; config.compactJson checked at runtime
 
 /**
  * Set compact JSON output mode
@@ -99,8 +97,8 @@ function formatLogEntry(
     logEntry.message = String(data);
   }
 
-  // Check both local setting and global Flag
-  const useCompact = compactJsonMode || Flag.COMPACT_JSON();
+  // Check both local setting and global config
+  const useCompact = compactJsonMode || config.compactJson;
   return useCompact
     ? JSON.stringify(logEntry)
     : JSON.stringify(logEntry, null, 2);
@@ -158,7 +156,7 @@ export function createLazyLogger(
   initialTags?: Record<string, unknown>
 ): LazyLogger {
   // Determine initial log level based on verbose flag
-  const initialLevel = Flag.OPENCODE_VERBOSE ? LEVEL_VERBOSE : LEVEL_DISABLED;
+  const initialLevel = isVerbose() ? LEVEL_VERBOSE : LEVEL_DISABLED;
 
   // Create base log-lazy instance
   const baseLog = makeLog({ level: initialLevel });
@@ -281,7 +279,7 @@ export function createLazyLogger(
 
   // Configuration
   Object.defineProperty(wrappedLog, 'enabled', {
-    get: () => Flag.OPENCODE_VERBOSE,
+    get: () => isVerbose(),
     enumerable: true,
   });
 
@@ -296,10 +294,10 @@ export const lazyLog = createLazyLogger({ service: 'agent' });
 
 /**
  * Utility to update the global logger level at runtime
- * Call this after Flag.setVerbose() to sync the logger state
+ * Call this after setVerbose() to sync the logger state
  */
 export function syncLoggerWithVerboseFlag(): void {
-  if (Flag.OPENCODE_VERBOSE) {
+  if (isVerbose()) {
     lazyLog.setLevel('verbose');
   } else {
     lazyLog.setLevel('disabled');

package/src/util/log.ts

@@ -3,7 +3,7 @@ import fs from 'fs/promises';
 import { Global } from '../global';
 import z from 'zod';
 import makeLog, { levels } from 'log-lazy';
-import { Flag } from '../flag/flag';
+import { config, isVerbose } from '../config/config';
 
 /**
  * Logging module with JSON output and lazy evaluation support.
@@ -32,7 +32,7 @@ export namespace Log {
 
   let level: Level = 'INFO';
   let jsonOutput = false; // Whether to output JSON format (enabled in verbose mode)
-  let compactJsonOutput = Flag.COMPACT_JSON(); // Whether to use compact JSON (single line)
+  let compactJsonOutput = false; // Whether to use compact JSON (single line); deferred to avoid circular init
 
   function shouldLog(input: Level): boolean {
     return levelPriority[input] >= levelPriority[level];
@@ -109,8 +109,9 @@ export namespace Log {
     // Always use JSON output format for logs
     jsonOutput = true;
 
-    // Configure lazy logging level based on verbose flag
-    if (Flag.OPENCODE_VERBOSE || options.print) {
+    // Configure lazy logging level based on verbose flag (with env var fallback)
+    // See: https://github.com/link-assistant/agent/issues/227
+    if (isVerbose() || options.print) {
       // Enable all levels for lazy logging when verbose
       lazyLogInstance = makeLog({
         level: levels.debug | levels.info | levels.warn | levels.error,
@@ -208,8 +209,8 @@ export namespace Log {
     }
 
     // Use compact or pretty format based on configuration
-    // Check both local setting and global Flag
-    const useCompact = compactJsonOutput || Flag.COMPACT_JSON();
+    // Check both local setting and global config
+    const useCompact = compactJsonOutput || config.compactJson;
     return useCompact
       ? JSON.stringify(logEntry)
       : JSON.stringify(logEntry, null, 2);
@@ -371,10 +372,10 @@ export namespace Log {
 
   /**
    * Sync lazy logging with verbose flag at runtime
-   * Call after Flag.setVerbose() to update lazy logging state
+   * Call after setVerbose() to update lazy logging state
    */
   export function syncWithVerboseFlag(): void {
-    if (Flag.OPENCODE_VERBOSE) {
+    if (isVerbose()) {
       jsonOutput = true;
       // Use stdout for verbose output (following Unix conventions)
       write = (msg: any) => process.stdout.write(msg);

package/src/util/verbose-fetch.ts

@@ -1,5 +1,5 @@
 import { Log } from './log';
-import { Flag } from '../flag/flag';
+import { isVerbose } from '../config/config';
 
 /**
  * Shared verbose HTTP fetch wrapper.
@@ -14,7 +14,7 @@ import { Flag } from '../flag/flag';
  * - Logs HTTP errors: stack trace, error cause chain
  * - Sequential call numbering for correlation
  * - Error-resilient: logging failures never break the actual HTTP request
- * - Runtime verbose check: respects Flag.OPENCODE_VERBOSE at call time
+ * - Runtime verbose check: respects isVerbose() at call time (with env var fallback)
  *
  * @see https://github.com/link-assistant/agent/issues/215
  */
@@ -98,7 +98,7 @@ export interface VerboseFetchOptions {
 /**
  * Wrap a fetch function with verbose HTTP logging.
  *
- * When Flag.OPENCODE_VERBOSE is true, logs all HTTP requests and responses
+ * When isVerbose() returns true, logs all HTTP requests and responses
  * as JSON objects. When verbose is false, returns a no-op passthrough.
  *
  * All logging is wrapped in try/catch so it never breaks the actual HTTP request.
@@ -121,8 +121,11 @@ export function createVerboseFetch(
     input: RequestInfo | URL,
     init?: RequestInit
   ): Promise<Response> => {
-    // Check verbose flag at call time
-    if (!Flag.OPENCODE_VERBOSE) {
+    // Check verbose flag at call time, with env var fallback for resilience.
+    // Uses isVerbose() which checks both the in-memory flag and environment
+    // variables, preventing silent logging loss when the flag state is disrupted.
+    // See: https://github.com/link-assistant/agent/issues/227
+    if (!isVerbose()) {
       return innerFetch(input, init);
     }
 

package/src/flag/flag.ts

@@ -1,212 +0,0 @@
-export namespace Flag {
-  // Helper to check env vars with new prefix first, then fall back to old prefix for backwards compatibility
-  function getEnv(newKey: string, oldKey: string): string | undefined {
-    return process.env[newKey] ?? process.env[oldKey];
-  }
-
-  function truthy(key: string) {
-    const value = process.env[key]?.toLowerCase();
-    return value === 'true' || value === '1';
-  }
-
-  function truthyCompat(newKey: string, oldKey: string): boolean {
-    const value = (getEnv(newKey, oldKey) ?? '').toLowerCase();
-    return value === 'true' || value === '1';
-  }
-
-  // LINK_ASSISTANT_AGENT_AUTO_SHARE removed - no sharing support
-  export const OPENCODE_CONFIG = getEnv(
-    'LINK_ASSISTANT_AGENT_CONFIG',
-    'OPENCODE_CONFIG'
-  );
-  export const OPENCODE_CONFIG_DIR = getEnv(
-    'LINK_ASSISTANT_AGENT_CONFIG_DIR',
-    'OPENCODE_CONFIG_DIR'
-  );
-  export const OPENCODE_CONFIG_CONTENT = getEnv(
-    'LINK_ASSISTANT_AGENT_CONFIG_CONTENT',
-    'OPENCODE_CONFIG_CONTENT'
-  );
-  export const OPENCODE_DISABLE_AUTOUPDATE = truthyCompat(
-    'LINK_ASSISTANT_AGENT_DISABLE_AUTOUPDATE',
-    'OPENCODE_DISABLE_AUTOUPDATE'
-  );
-  export const OPENCODE_DISABLE_PRUNE = truthyCompat(
-    'LINK_ASSISTANT_AGENT_DISABLE_PRUNE',
-    'OPENCODE_DISABLE_PRUNE'
-  );
-  export const OPENCODE_ENABLE_EXPERIMENTAL_MODELS = truthyCompat(
-    'LINK_ASSISTANT_AGENT_ENABLE_EXPERIMENTAL_MODELS',
-    'OPENCODE_ENABLE_EXPERIMENTAL_MODELS'
-  );
-  export const OPENCODE_DISABLE_AUTOCOMPACT = truthyCompat(
-    'LINK_ASSISTANT_AGENT_DISABLE_AUTOCOMPACT',
-    'OPENCODE_DISABLE_AUTOCOMPACT'
-  );
-
-  // Experimental
-  export const OPENCODE_EXPERIMENTAL = truthyCompat(
-    'LINK_ASSISTANT_AGENT_EXPERIMENTAL',
-    'OPENCODE_EXPERIMENTAL'
-  );
-  export const OPENCODE_EXPERIMENTAL_WATCHER =
-    OPENCODE_EXPERIMENTAL ||
-    truthyCompat(
-      'LINK_ASSISTANT_AGENT_EXPERIMENTAL_WATCHER',
-      'OPENCODE_EXPERIMENTAL_WATCHER'
-    );
-
-  // Verbose mode - enables detailed logging of API requests
-  export let OPENCODE_VERBOSE = truthyCompat(
-    'LINK_ASSISTANT_AGENT_VERBOSE',
-    'OPENCODE_VERBOSE'
-  );
-
-  // Dry run mode - simulate operations without making actual API calls or changes
-  export let OPENCODE_DRY_RUN = truthyCompat(
-    'LINK_ASSISTANT_AGENT_DRY_RUN',
-    'OPENCODE_DRY_RUN'
-  );
-
-  // Title generation configuration
-  // When disabled, sessions will use default "New session - {timestamp}" titles
-  // This saves tokens and prevents rate limit issues with free tier models
-  // See: https://github.com/link-assistant/agent/issues/157
-  export let GENERATE_TITLE = truthyCompat(
-    'LINK_ASSISTANT_AGENT_GENERATE_TITLE',
-    'AGENT_GENERATE_TITLE'
-  );
-
-  // Allow setting title generation mode programmatically (e.g., from CLI --generate-title flag)
-  export function setGenerateTitle(value: boolean) {
-    GENERATE_TITLE = value;
-  }
-
-  // Output response model information in step-finish parts
-  // Enabled by default - includes model info (providerID, requestedModelID, respondedModelID) in output
-  // Can be disabled with AGENT_OUTPUT_RESPONSE_MODEL=false
-  // See: https://github.com/link-assistant/agent/issues/179
-  export let OUTPUT_RESPONSE_MODEL = (() => {
-    const value = (
-      getEnv(
-        'LINK_ASSISTANT_AGENT_OUTPUT_RESPONSE_MODEL',
-        'AGENT_OUTPUT_RESPONSE_MODEL'
-      ) ?? ''
-    ).toLowerCase();
-    if (value === 'false' || value === '0') return false;
-    return true; // Default to true
-  })();
-
-  // Allow setting output-response-model mode programmatically (e.g., from CLI --output-response-model flag)
-  export function setOutputResponseModel(value: boolean) {
-    OUTPUT_RESPONSE_MODEL = value;
-  }
-
-  // Session summarization configuration
-  // Enabled by default - generates AI-powered session summaries using the same model
-  // Can be disabled with --no-summarize-session or AGENT_SUMMARIZE_SESSION=false
-  // See: https://github.com/link-assistant/agent/issues/217
-  export let SUMMARIZE_SESSION = (() => {
-    const value = (
-      getEnv(
-        'LINK_ASSISTANT_AGENT_SUMMARIZE_SESSION',
-        'AGENT_SUMMARIZE_SESSION'
-      ) ?? ''
-    ).toLowerCase();
-    if (value === 'false' || value === '0') return false;
-    return true; // Default to true
-  })();
-
-  // Allow setting summarize-session mode programmatically (e.g., from CLI --summarize-session flag)
-  export function setSummarizeSession(value: boolean) {
-    SUMMARIZE_SESSION = value;
-  }
-
-  // Retry timeout configuration
-  // Maximum total time to keep retrying for the same error type (default: 7 days in seconds)
-  // For different error types, the timer resets
-  // See: https://github.com/link-assistant/agent/issues/157
-  export function RETRY_TIMEOUT(): number {
-    const val = getEnv(
-      'LINK_ASSISTANT_AGENT_RETRY_TIMEOUT',
-      'AGENT_RETRY_TIMEOUT'
-    );
-    return val ? parseInt(val, 10) : 604800; // 7 days in seconds
-  }
-
-  // Maximum delay for a single retry attempt (default: 20 minutes in milliseconds)
-  export function MAX_RETRY_DELAY(): number {
-    const val = getEnv(
-      'LINK_ASSISTANT_AGENT_MAX_RETRY_DELAY',
-      'AGENT_MAX_RETRY_DELAY'
-    );
-    return val ? parseInt(val, 10) * 1000 : 1200000; // 20 minutes in ms
-  }
-
-  // Minimum retry interval to prevent rapid retries (default: 30 seconds)
-  // This ensures we don't hammer the API with rapid retry attempts
-  // See: https://github.com/link-assistant/agent/issues/167
-  export function MIN_RETRY_INTERVAL(): number {
-    const val = getEnv(
-      'LINK_ASSISTANT_AGENT_MIN_RETRY_INTERVAL',
-      'AGENT_MIN_RETRY_INTERVAL'
-    );
-    return val ? parseInt(val, 10) * 1000 : 30000; // 30 seconds in ms
-  }
-
-  // Stream timeout configuration
-  // chunkMs: timeout between stream chunks - detects stalled streams (default: 2 minutes)
-  // stepMs: timeout for each individual LLM step (default: 10 minutes)
-  export function STREAM_CHUNK_TIMEOUT_MS(): number {
-    const val = getEnv(
-      'LINK_ASSISTANT_AGENT_STREAM_CHUNK_TIMEOUT_MS',
-      'AGENT_STREAM_CHUNK_TIMEOUT_MS'
-    );
-    return val ? parseInt(val, 10) : 120_000;
-  }
-
-  export function STREAM_STEP_TIMEOUT_MS(): number {
-    const val = getEnv(
-      'LINK_ASSISTANT_AGENT_STREAM_STEP_TIMEOUT_MS',
-      'AGENT_STREAM_STEP_TIMEOUT_MS'
-    );
-    return val ? parseInt(val, 10) : 600_000;
-  }
-
-  // Compact JSON mode - output JSON on single lines (NDJSON format)
-  // Enabled by AGENT_CLI_COMPACT env var or --compact-json flag
-  // Uses getter to check env var at runtime for tests
-  let _compactJson: boolean | null = null;
-
-  export function COMPACT_JSON(): boolean {
-    if (_compactJson !== null) return _compactJson;
-    return (
-      truthy('AGENT_CLI_COMPACT') ||
-      truthyCompat('LINK_ASSISTANT_AGENT_COMPACT_JSON', 'OPENCODE_COMPACT_JSON')
-    );
-  }
-
-  // Allow setting verbose mode programmatically (e.g., from CLI --verbose flag)
-  export function setVerbose(value: boolean) {
-    OPENCODE_VERBOSE = value;
-  }
-
-  // Allow setting dry run mode programmatically (e.g., from CLI --dry-run flag)
-  export function setDryRun(value: boolean) {
-    OPENCODE_DRY_RUN = value;
-  }
-
-  // Allow setting compact JSON mode programmatically (e.g., from CLI --compact-json flag)
-  export function setCompactJson(value: boolean) {
-    _compactJson = value;
-  }
-
-  // Retry on rate limits - when disabled, 429 responses are returned immediately without retrying
-  // Enabled by default. Use --no-retry-on-rate-limits in integration tests to avoid waiting for rate limits.
-  export let RETRY_ON_RATE_LIMITS = true;
-
-  // Allow setting retry-on-rate-limits mode programmatically (e.g., from CLI --retry-on-rate-limits flag)
-  export function setRetryOnRateLimits(value: boolean) {
-    RETRY_ON_RATE_LIMITS = value;
-  }
-}