wave-agent-sdk 0.0.7 → 0.0.8

package/dist/utils/commandPathResolver.js

@@ -0,0 +1,145 @@
+import { relative, basename } from "path";
+/**
+ * Generate command ID from file path
+ * @param filePath - Absolute path to markdown file
+ * @param rootDir - Root commands directory path
+ * @returns Command identifier string (e.g., "openspec:apply")
+ * @throws Error on invalid path structure
+ */
+export function generateCommandId(filePath, rootDir) {
+    // Handle null/undefined inputs
+    if (filePath == null || rootDir == null) {
+        throw new Error("File path and root directory must be provided");
+    }
+    // Handle empty root directory (for root level commands)
+    const relativePath = rootDir === "" ? filePath : relative(rootDir, filePath);
+    // Handle edge cases
+    if (!relativePath || relativePath === ".") {
+        throw new Error("Command filename cannot be empty");
+    }
+    const segments = relativePath.split("/").filter((segment) => segment !== "");
+    // Remove .md extension from the last segment
+    const lastSegment = segments[segments.length - 1];
+    if (!lastSegment.endsWith(".md")) {
+        throw new Error(`Command files must have .md extension`);
+    }
+    segments[segments.length - 1] = basename(lastSegment, ".md");
+    // Handle empty filename after removing extension
+    if (segments[segments.length - 1] === "") {
+        throw new Error("Command filename cannot be empty");
+    }
+    // Validate depth (max 1 level of nesting)
+    if (segments.length > 2) {
+        throw new Error(`Command nesting too deep: ${relativePath}. Maximum depth is 1 level.`);
+    }
+    // Validate segments
+    for (const segment of segments) {
+        if (!validateSegment(segment)) {
+            throw new Error(`Invalid command path segment: "${segment}" in ${relativePath}. Must match pattern /^[a-zA-Z][a-zA-Z0-9_.-]*$/`);
+        }
+    }
+    // Generate command ID
+    if (segments.length === 1) {
+        return segments[0]; // Flat command
+    }
+    else {
+        return segments.join(":"); // Nested command with colon syntax
+    }
+}
+/**
+ * Parse command ID into components
+ * @param commandId - Command identifier (e.g., "openspec:apply")
+ * @returns Object with namespace and command name
+ * @throws Error on malformed command ID
+ */
+export function parseCommandId(commandId) {
+    // Handle null/undefined inputs
+    if (commandId == null) {
+        throw new Error("Command ID cannot be null or undefined");
+    }
+    if (commandId === "") {
+        throw new Error("Command ID cannot be empty");
+    }
+    if (!validateCommandId(commandId)) {
+        throw new Error(`Invalid command ID format: "${commandId}". Must match pattern /^[a-zA-Z0-9_-]+(?::[a-zA-Z0-9_-]+)?$/`);
+    }
+    const parts = commandId.split(":");
+    if (parts.length === 1) {
+        // Flat command
+        return {
+            namespace: undefined,
+            commandName: parts[0],
+            isNested: false,
+            depth: 0,
+            segments: [parts[0]],
+        };
+    }
+    else if (parts.length === 2) {
+        // Nested command
+        return {
+            namespace: parts[0],
+            commandName: parts[1],
+            isNested: true,
+            depth: 1,
+            segments: [parts[0], parts[1]],
+        };
+    }
+    else {
+        throw new Error(`Invalid command ID format: "${commandId}". Too many colon separators.`);
+    }
+}
+/**
+ * Validate command ID format
+ * @param commandId - Command identifier to validate
+ * @returns Boolean indicating validity
+ */
+export function validateCommandId(commandId) {
+    // Handle null/undefined inputs
+    if (commandId == null) {
+        return false;
+    }
+    // Command ID can have multiple colons (though generateCommandId enforces max 1 level)
+    // This validates the format but doesn't enforce depth limits
+    const pattern = /^[a-zA-Z][a-zA-Z0-9_-]*(?::[a-zA-Z][a-zA-Z0-9_-]*)*$/;
+    return pattern.test(commandId);
+}
+/**
+ * Validate individual path segment
+ * @param segment - Path segment to validate
+ * @returns Boolean indicating validity
+ */
+function validateSegment(segment) {
+    // Segments should start with letters and can contain letters, numbers, dashes, underscores, dots
+    const pattern = /^[a-zA-Z][a-zA-Z0-9_.-]*$/;
+    return pattern.test(segment);
+}
+/**
+ * Convert file path to command segments array
+ * @param filePath - Absolute path to markdown file
+ * @param rootDir - Root commands directory path
+ * @returns Array of path segments
+ */
+export function getCommandSegments(filePath, rootDir) {
+    const relativePath = relative(rootDir, filePath);
+    const segments = relativePath.split("/").filter((segment) => segment !== "");
+    // Remove .md extension from the last segment
+    const lastSegment = segments[segments.length - 1];
+    segments[segments.length - 1] = basename(lastSegment, ".md");
+    return segments;
+}
+/**
+ * Get namespace from command segments
+ * @param segments - Command path segments
+ * @returns Namespace string or undefined for flat commands
+ */
+export function getNamespace(segments) {
+    return segments.length > 1 ? segments[0] : undefined;
+}
+/**
+ * Get command depth from segments
+ * @param segments - Command path segments
+ * @returns Depth number (0 for root, 1 for nested)
+ */
+export function getDepth(segments) {
+    return Math.max(0, segments.length - 1);
+}

package/dist/utils/configPaths.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Configuration Path Utilities
+ *
+ * Centralized utilities for resolving Wave configuration file paths.
+ * Supports both regular settings.json and settings.local.json with proper priority.
+ *
+ * Priority system:
+ * - User configs: ~/.wave/settings.local.json > ~/.wave/settings.json
+ * - Project configs: {workdir}/.wave/settings.local.json > {workdir}/.wave/settings.json
+ * - Project configs override user configs (existing behavior)
+ */
+/**
+ * Get the user-specific configuration file path (legacy function)
+ * @deprecated Use getUserConfigPaths() for better priority support
+ */
+export declare function getUserConfigPath(): string;
+/**
+ * Get the project-specific configuration file path (legacy function)
+ * @deprecated Use getProjectConfigPaths() for better priority support
+ */
+export declare function getProjectConfigPath(workdir: string): string;
+/**
+ * Get the user-specific configuration file paths in priority order
+ * Returns array with .local.json first, then .json
+ */
+export declare function getUserConfigPaths(): string[];
+/**
+ * Get the project-specific configuration file paths in priority order
+ * Returns array with .local.json first, then .json
+ */
+export declare function getProjectConfigPaths(workdir: string): string[];
+/**
+ * Get all configuration file paths (user and project) in priority order
+ * Useful for comprehensive configuration detection
+ */
+export declare function getAllConfigPaths(workdir: string): {
+    userPaths: string[];
+    projectPaths: string[];
+    allPaths: string[];
+};
+/**
+ * Get existing configuration file paths
+ * Returns only the paths that actually exist on the filesystem
+ */
+export declare function getExistingConfigPaths(workdir: string): {
+    userPaths: string[];
+    projectPaths: string[];
+    existingPaths: string[];
+};
+/**
+ * Get the first existing configuration file path with the specified priority
+ * @param paths Array of paths in priority order
+ * @returns The first path that exists, or undefined if none exist
+ */
+export declare function getFirstExistingPath(paths: string[]): string | undefined;
+/**
+ * Get effective configuration paths (the ones that would actually be used)
+ * Returns the highest priority existing path for each category
+ */
+export declare function getEffectiveConfigPaths(workdir: string): {
+    userPath?: string;
+    projectPath?: string;
+    effectivePath?: string;
+};
+/**
+ * Check if any configuration files exist
+ */
+export declare function hasAnyConfig(workdir: string): boolean;
+/**
+ * Get configuration information for debugging and monitoring
+ */
+export declare function getConfigurationInfo(workdir: string): {
+    hasUser: boolean;
+    hasProject: boolean;
+    paths: string[];
+    userPaths: string[];
+    projectPaths: string[];
+    existingPaths: string[];
+    effectivePaths: {
+        userPath?: string;
+        projectPath?: string;
+        effectivePath?: string;
+    };
+};
+//# sourceMappingURL=configPaths.d.ts.map

package/dist/utils/configPaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configPaths.d.ts","sourceRoot":"","sources":["../../src/utils/configPaths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CAG7C;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAG/D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG;IAClD,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CASA;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG;IACvD,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAYA;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAExE;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAeA;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGrD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG;IACrD,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,cAAc,EAAE;QACd,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;CACH,CAcA"}

package/dist/utils/configPaths.js

@@ -0,0 +1,121 @@
+/**
+ * Configuration Path Utilities
+ *
+ * Centralized utilities for resolving Wave configuration file paths.
+ * Supports both regular settings.json and settings.local.json with proper priority.
+ *
+ * Priority system:
+ * - User configs: ~/.wave/settings.local.json > ~/.wave/settings.json
+ * - Project configs: {workdir}/.wave/settings.local.json > {workdir}/.wave/settings.json
+ * - Project configs override user configs (existing behavior)
+ */
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync } from "fs";
+/**
+ * Get the user-specific configuration file path (legacy function)
+ * @deprecated Use getUserConfigPaths() for better priority support
+ */
+export function getUserConfigPath() {
+    return join(homedir(), ".wave", "settings.json");
+}
+/**
+ * Get the project-specific configuration file path (legacy function)
+ * @deprecated Use getProjectConfigPaths() for better priority support
+ */
+export function getProjectConfigPath(workdir) {
+    return join(workdir, ".wave", "settings.json");
+}
+/**
+ * Get the user-specific configuration file paths in priority order
+ * Returns array with .local.json first, then .json
+ */
+export function getUserConfigPaths() {
+    const baseDir = join(homedir(), ".wave");
+    return [join(baseDir, "settings.local.json"), join(baseDir, "settings.json")];
+}
+/**
+ * Get the project-specific configuration file paths in priority order
+ * Returns array with .local.json first, then .json
+ */
+export function getProjectConfigPaths(workdir) {
+    const baseDir = join(workdir, ".wave");
+    return [join(baseDir, "settings.local.json"), join(baseDir, "settings.json")];
+}
+/**
+ * Get all configuration file paths (user and project) in priority order
+ * Useful for comprehensive configuration detection
+ */
+export function getAllConfigPaths(workdir) {
+    const userPaths = getUserConfigPaths();
+    const projectPaths = getProjectConfigPaths(workdir);
+    return {
+        userPaths,
+        projectPaths,
+        allPaths: [...userPaths, ...projectPaths],
+    };
+}
+/**
+ * Get existing configuration file paths
+ * Returns only the paths that actually exist on the filesystem
+ */
+export function getExistingConfigPaths(workdir) {
+    const allPaths = getAllConfigPaths(workdir);
+    const existingUserPaths = allPaths.userPaths.filter(existsSync);
+    const existingProjectPaths = allPaths.projectPaths.filter(existsSync);
+    const allExistingPaths = allPaths.allPaths.filter(existsSync);
+    return {
+        userPaths: existingUserPaths,
+        projectPaths: existingProjectPaths,
+        existingPaths: allExistingPaths,
+    };
+}
+/**
+ * Get the first existing configuration file path with the specified priority
+ * @param paths Array of paths in priority order
+ * @returns The first path that exists, or undefined if none exist
+ */
+export function getFirstExistingPath(paths) {
+    return paths.find((path) => existsSync(path));
+}
+/**
+ * Get effective configuration paths (the ones that would actually be used)
+ * Returns the highest priority existing path for each category
+ */
+export function getEffectiveConfigPaths(workdir) {
+    const userPaths = getUserConfigPaths();
+    const projectPaths = getProjectConfigPaths(workdir);
+    const userPath = getFirstExistingPath(userPaths);
+    const projectPath = getFirstExistingPath(projectPaths);
+    // Project path takes precedence over user path if both exist
+    const effectivePath = projectPath || userPath;
+    return {
+        userPath,
+        projectPath,
+        effectivePath,
+    };
+}
+/**
+ * Check if any configuration files exist
+ */
+export function hasAnyConfig(workdir) {
+    const { existingPaths } = getExistingConfigPaths(workdir);
+    return existingPaths.length > 0;
+}
+/**
+ * Get configuration information for debugging and monitoring
+ */
+export function getConfigurationInfo(workdir) {
+    const allPaths = getAllConfigPaths(workdir);
+    const existingPaths = getExistingConfigPaths(workdir);
+    const effectivePaths = getEffectiveConfigPaths(workdir);
+    return {
+        hasUser: existingPaths.userPaths.length > 0,
+        hasProject: existingPaths.projectPaths.length > 0,
+        paths: allPaths.allPaths,
+        userPaths: allPaths.userPaths,
+        projectPaths: allPaths.projectPaths,
+        existingPaths: existingPaths.existingPaths,
+        effectivePaths,
+    };
+}

package/dist/utils/configResolver.d.ts

@@ -1,38 +1,65 @@
 /**
  * Configuration resolver utilities for Agent Constructor Configuration
  * Resolves configuration from constructor arguments with environment fallbacks
+ * Supports live configuration updates and cache invalidation
  */
 import { GatewayConfig, ModelConfig } from "../types/index.js";
 export declare class ConfigResolver {
     /**
-     * Resolves gateway configuration from constructor args and environment
+     * Resolves gateway configuration from constructor args and environment with live config support
      * @param apiKey - API key from constructor (optional)
      * @param baseURL - Base URL from constructor (optional)
+     * @param workdir - Working directory for loading live configuration (optional)
      * @returns Resolved gateway configuration
      * @throws ConfigurationError if required configuration is missing after fallbacks
      */
-    static resolveGatewayConfig(apiKey?: string, baseURL?: string): GatewayConfig;
+    static resolveGatewayConfig(apiKey?: string, baseURL?: string, workdir?: string): GatewayConfig;
     /**
-     * Resolves model configuration with fallbacks
+     * Resolves model configuration with fallbacks and live config support
      * @param agentModel - Agent model from constructor (optional)
      * @param fastModel - Fast model from constructor (optional)
+     * @param workdir - Working directory for loading live configuration (optional)
      * @returns Resolved model configuration with defaults
      */
-    static resolveModelConfig(agentModel?: string, fastModel?: string): ModelConfig;
+    static resolveModelConfig(agentModel?: string, fastModel?: string, workdir?: string): ModelConfig;
     /**
-     * Resolves token limit with fallbacks
+     * Resolves token limit with fallbacks and live config support
      * @param constructorLimit - Token limit from constructor (optional)
+     * @param workdir - Working directory for loading live configuration (optional)
      * @returns Resolved token limit
      */
-    static resolveTokenLimit(constructorLimit?: number): number;
+    static resolveTokenLimit(constructorLimit?: number, workdir?: string): number;
+    /**
+     * Invalidate configuration cache to force reload from settings.json
+     * @param workdir - Working directory to invalidate cache for (optional)
+     */
+    static invalidateCache(workdir?: string): void;
+    /**
+     * Refresh configuration cache by reloading from settings.json
+     * @param workdir - Working directory to refresh cache for (optional)
+     */
+    static refreshCache(workdir?: string): void;
+    /**
+     * Get current cache status for monitoring
+     * @returns Cache information or null if no cache
+     */
+    static getCacheStatus(): {
+        workdir?: string;
+        lastUpdated: number;
+        envVarCount: number;
+        isValid: boolean;
+    } | null;
 }
 /**
  * Static configuration resolver instance
- * Implements ConfigurationResolver interface from types.ts
+ * Implements ConfigurationResolver interface from types.ts with backward compatibility
  */
 export declare const configResolver: {
-    resolveGatewayConfig: typeof ConfigResolver.resolveGatewayConfig;
-    resolveModelConfig: typeof ConfigResolver.resolveModelConfig;
-    resolveTokenLimit: typeof ConfigResolver.resolveTokenLimit;
+    resolveGatewayConfig: (apiKey?: string, baseURL?: string, workdir?: string) => GatewayConfig;
+    resolveModelConfig: (agentModel?: string, fastModel?: string, workdir?: string) => ModelConfig;
+    resolveTokenLimit: (constructorLimit?: number, workdir?: string) => number;
+    invalidateCache: typeof ConfigResolver.invalidateCache;
+    refreshCache: typeof ConfigResolver.refreshCache;
+    getCacheStatus: typeof ConfigResolver.getCacheStatus;
 };
 //# sourceMappingURL=configResolver.d.ts.map

package/dist/utils/configResolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configResolver.d.ts","sourceRoot":"","sources":["../../src/utils/configResolver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,aAAa,EACb,WAAW,EAGZ,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,cAAc;IACzB;;;;;;OAMG;IACH,MAAM,CAAC,oBAAoB,CACzB,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,GACf,aAAa;IAuDhB;;;;;OAKG;IACH,MAAM,CAAC,kBAAkB,CACvB,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,WAAW;IAmBd;;;;OAIG;IACH,MAAM,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,MAAM;CAoB5D;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;CAI1B,CAAC"}
+{"version":3,"file":"configResolver.d.ts","sourceRoot":"","sources":["../../src/utils/configResolver.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,aAAa,EACb,WAAW,EAGZ,MAAM,mBAAmB,CAAC;AA8E3B,qBAAa,cAAc;IACzB;;;;;;;OAOG;IACH,MAAM,CAAC,oBAAoB,CACzB,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,GACf,aAAa;IAyDhB;;;;;;OAMG;IACH,MAAM,CAAC,kBAAkB,CACvB,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,WAAW;IA4Bd;;;;;OAKG;IACH,MAAM,CAAC,iBAAiB,CACtB,gBAAgB,CAAC,EAAE,MAAM,EACzB,OAAO,CAAC,EAAE,MAAM,GACf,MAAM;IAuBT;;;OAGG;IACH,MAAM,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAa9C;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAQ3C;;;OAGG;IACH,MAAM,CAAC,cAAc,IAAI;QACvB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,OAAO,CAAC;KAClB,GAAG,IAAI;CAYT;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc;oCACO,MAAM,YAAY,MAAM,YAAY,MAAM;sCAG3D,MAAM,cACP,MAAM,YACR,MAAM;2CAEqB,MAAM,YAAY,MAAM;;;;CAOhE,CAAC"}

package/dist/utils/configResolver.js

@@ -1,48 +1,103 @@
 /**
  * Configuration resolver utilities for Agent Constructor Configuration
  * Resolves configuration from constructor arguments with environment fallbacks
+ * Supports live configuration updates and cache invalidation
  */
 import { ConfigurationError, CONFIG_ERRORS, } from "../types/index.js";
+import { DEFAULT_TOKEN_LIMIT } from "./constants.js";
+import { loadMergedWaveConfig } from "../services/hook.js";
+import { getGlobalLogger } from "./globalLogger.js";
+let configCache = null;
+/**
+ * Initialize configuration cache with current environment variables from settings.json
+ */
+function initializeConfigurationCache(workdir) {
+    try {
+        const waveConfig = workdir ? loadMergedWaveConfig(workdir) : null;
+        const envVars = waveConfig?.env || {};
+        configCache = {
+            workdir,
+            lastUpdated: Date.now(),
+            environmentVars: envVars,
+            isValid: true,
+        };
+        const logger = getGlobalLogger();
+        logger?.debug(`Live Config: Configuration cache initialized with ${Object.keys(envVars).length} environment variables`);
+    }
+    catch (error) {
+        const logger = getGlobalLogger();
+        logger?.error(`Live Config: Failed to initialize configuration cache: ${error.message}`);
+        configCache = {
+            workdir,
+            lastUpdated: Date.now(),
+            environmentVars: {},
+            isValid: false,
+        };
+    }
+}
+/**
+ * Get current environment variable value with live configuration support
+ */
+function getCurrentEnvironmentValue(key, workdir) {
+    // Initialize cache if not present or workdir changed
+    if (!configCache || configCache.workdir !== workdir) {
+        initializeConfigurationCache(workdir);
+    }
+    // Use cached environment variables if available and valid
+    if (configCache && configCache.isValid) {
+        const cachedValue = configCache.environmentVars[key];
+        if (cachedValue !== undefined) {
+            const logger = getGlobalLogger();
+            logger?.debug(`Live Config: Using cached environment variable ${key}=${cachedValue}`);
+            return cachedValue;
+        }
+    }
+    // Fallback to process environment
+    return process.env[key];
+}
 export class ConfigResolver {
     /**
-     * Resolves gateway configuration from constructor args and environment
+     * Resolves gateway configuration from constructor args and environment with live config support
      * @param apiKey - API key from constructor (optional)
      * @param baseURL - Base URL from constructor (optional)
+     * @param workdir - Working directory for loading live configuration (optional)
      * @returns Resolved gateway configuration
      * @throws ConfigurationError if required configuration is missing after fallbacks
      */
-    static resolveGatewayConfig(apiKey, baseURL) {
-        // Resolve API key: constructor > environment variable
+    static resolveGatewayConfig(apiKey, baseURL, workdir) {
+        // Resolve API key: constructor > live configuration > environment variable
         // Note: Explicitly provided empty strings should be treated as invalid, not fall back to env
         let resolvedApiKey;
         if (apiKey !== undefined) {
             resolvedApiKey = apiKey;
         }
         else {
-            resolvedApiKey = process.env.AIGW_TOKEN || "";
+            resolvedApiKey = getCurrentEnvironmentValue("AIGW_TOKEN", workdir) || "";
         }
         if (!resolvedApiKey && apiKey === undefined) {
+            const envValue = getCurrentEnvironmentValue("AIGW_TOKEN", workdir);
             throw new ConfigurationError(CONFIG_ERRORS.MISSING_API_KEY, "apiKey", {
                 constructor: apiKey,
-                environment: process.env.AIGW_TOKEN,
+                environment: envValue,
             });
         }
         if (resolvedApiKey.trim() === "") {
             throw new ConfigurationError(CONFIG_ERRORS.EMPTY_API_KEY, "apiKey", resolvedApiKey);
         }
-        // Resolve base URL: constructor > environment variable
+        // Resolve base URL: constructor > live configuration > environment variable
         // Note: Explicitly provided empty strings should be treated as invalid, not fall back to env
         let resolvedBaseURL;
         if (baseURL !== undefined) {
             resolvedBaseURL = baseURL;
         }
         else {
-            resolvedBaseURL = process.env.AIGW_URL || "";
+            resolvedBaseURL = getCurrentEnvironmentValue("AIGW_URL", workdir) || "";
         }
         if (!resolvedBaseURL && baseURL === undefined) {
+            const envValue = getCurrentEnvironmentValue("AIGW_URL", workdir);
             throw new ConfigurationError(CONFIG_ERRORS.MISSING_BASE_URL, "baseURL", {
                 constructor: baseURL,
-                environment: process.env.AIGW_URL,
+                environment: envValue,
             });
         }
         if (resolvedBaseURL.trim() === "") {
@@ -54,53 +109,102 @@ export class ConfigResolver {
         };
     }
     /**
-     * Resolves model configuration with fallbacks
+     * Resolves model configuration with fallbacks and live config support
      * @param agentModel - Agent model from constructor (optional)
      * @param fastModel - Fast model from constructor (optional)
+     * @param workdir - Working directory for loading live configuration (optional)
      * @returns Resolved model configuration with defaults
      */
-    static resolveModelConfig(agentModel, fastModel) {
+    static resolveModelConfig(agentModel, fastModel, workdir) {
         // Default values as per data-model.md
         const DEFAULT_AGENT_MODEL = "claude-sonnet-4-20250514";
         const DEFAULT_FAST_MODEL = "gemini-2.5-flash";
-        // Resolve agent model: constructor > environment > default
-        const resolvedAgentModel = agentModel || process.env.AIGW_MODEL || DEFAULT_AGENT_MODEL;
-        // Resolve fast model: constructor > environment > default
-        const resolvedFastModel = fastModel || process.env.AIGW_FAST_MODEL || DEFAULT_FAST_MODEL;
+        // Resolve agent model: constructor > live configuration > environment > default
+        const resolvedAgentModel = agentModel ||
+            getCurrentEnvironmentValue("AIGW_MODEL", workdir) ||
+            DEFAULT_AGENT_MODEL;
+        // Resolve fast model: constructor > live configuration > environment > default
+        const resolvedFastModel = fastModel ||
+            getCurrentEnvironmentValue("AIGW_FAST_MODEL", workdir) ||
+            DEFAULT_FAST_MODEL;
+        const logger = getGlobalLogger();
+        logger?.debug(`Live Config: Resolved models - agent: ${resolvedAgentModel}, fast: ${resolvedFastModel}`);
         return {
             agentModel: resolvedAgentModel,
             fastModel: resolvedFastModel,
         };
     }
     /**
-     * Resolves token limit with fallbacks
+     * Resolves token limit with fallbacks and live config support
      * @param constructorLimit - Token limit from constructor (optional)
+     * @param workdir - Working directory for loading live configuration (optional)
      * @returns Resolved token limit
      */
-    static resolveTokenLimit(constructorLimit) {
-        const DEFAULT_TOKEN_LIMIT = 64000;
+    static resolveTokenLimit(constructorLimit, workdir) {
         // If constructor value provided, use it
         if (constructorLimit !== undefined) {
             return constructorLimit;
         }
-        // Try environment variable
-        const envTokenLimit = process.env.TOKEN_LIMIT;
+        // Try live configuration then environment variable
+        const envTokenLimit = getCurrentEnvironmentValue("TOKEN_LIMIT", workdir);
         if (envTokenLimit) {
             const parsed = parseInt(envTokenLimit, 10);
             if (!isNaN(parsed)) {
+                const logger = getGlobalLogger();
+                logger?.debug(`Live Config: Resolved token limit from configuration: ${parsed}`);
                 return parsed;
             }
         }
         // Use default
         return DEFAULT_TOKEN_LIMIT;
     }
+    /**
+     * Invalidate configuration cache to force reload from settings.json
+     * @param workdir - Working directory to invalidate cache for (optional)
+     */
+    static invalidateCache(workdir) {
+        if (configCache &&
+            (workdir === undefined || configCache.workdir === workdir)) {
+            const logger = getGlobalLogger();
+            logger?.info(`Live Config: Configuration cache invalidated for workdir: ${workdir || "global"}`);
+            configCache = null;
+        }
+    }
+    /**
+     * Refresh configuration cache by reloading from settings.json
+     * @param workdir - Working directory to refresh cache for (optional)
+     */
+    static refreshCache(workdir) {
+        const logger = getGlobalLogger();
+        logger?.info(`Live Config: Refreshing configuration cache for workdir: ${workdir || "global"}`);
+        initializeConfigurationCache(workdir);
+    }
+    /**
+     * Get current cache status for monitoring
+     * @returns Cache information or null if no cache
+     */
+    static getCacheStatus() {
+        if (!configCache) {
+            return null;
+        }
+        return {
+            workdir: configCache.workdir,
+            lastUpdated: configCache.lastUpdated,
+            envVarCount: Object.keys(configCache.environmentVars).length,
+            isValid: configCache.isValid,
+        };
+    }
 }
 /**
  * Static configuration resolver instance
- * Implements ConfigurationResolver interface from types.ts
+ * Implements ConfigurationResolver interface from types.ts with backward compatibility
  */
 export const configResolver = {
-    resolveGatewayConfig: ConfigResolver.resolveGatewayConfig,
-    resolveModelConfig: ConfigResolver.resolveModelConfig,
-    resolveTokenLimit: ConfigResolver.resolveTokenLimit,
+    resolveGatewayConfig: (apiKey, baseURL, workdir) => ConfigResolver.resolveGatewayConfig(apiKey, baseURL, workdir),
+    resolveModelConfig: (agentModel, fastModel, workdir) => ConfigResolver.resolveModelConfig(agentModel, fastModel, workdir),
+    resolveTokenLimit: (constructorLimit, workdir) => ConfigResolver.resolveTokenLimit(constructorLimit, workdir),
+    // Live configuration management methods
+    invalidateCache: ConfigResolver.invalidateCache,
+    refreshCache: ConfigResolver.refreshCache,
+    getCacheStatus: ConfigResolver.getCacheStatus,
 };

package/dist/utils/constants.d.ts

@@ -21,7 +21,7 @@ export declare const USER_MEMORY_FILE: string;
 /**
  * AI related constants
  */
-export declare const DEFAULT_TOKEN_LIMIT = 64000;
+export declare const DEFAULT_TOKEN_LIMIT = 96000;
 /**
  * @deprecated These constants are now legacy. Use ModelConfig through Agent constructor instead.
  * They are maintained for backward compatibility with existing code that might still reference them,