0xray 3.0.12 → 3.0.14

package/dist/core/codex-injector.js

@@ -13,7 +13,7 @@ import { frameworkLogger } from "../core/framework-logger.js";
 import { resolveCodexPath } from "./config-paths.js";
 // Dynamic imports for cross-environment compatibility
 let extractCodexMetadata;
-let XrayContextLoader;
+let StringRayContextLoader;
 let importsInitialized = false;
 async function initializeImports() {
     if (importsInitialized)
@@ -22,13 +22,13 @@ async function initializeImports() {
         const codexParser = await import("../utils/codex-parser.js");
         const contextLoaderModule = await import("./context-loader.js");
         extractCodexMetadata = codexParser.extractCodexMetadata;
-        XrayContextLoader = contextLoaderModule.XrayContextLoader;
+        StringRayContextLoader = contextLoaderModule.StringRayContextLoader;
     }
     catch {
         const codexParser = await import("../utils/codex-parser");
         const contextLoaderModule = await import("./context-loader");
         extractCodexMetadata = codexParser.extractCodexMetadata;
-        XrayContextLoader = contextLoaderModule.XrayContextLoader;
+        StringRayContextLoader = contextLoaderModule.StringRayContextLoader;
     }
     importsInitialized = true;
 }
@@ -38,7 +38,7 @@ async function initializeImports() {
 const codexCache = new Map();
 /**
  * Codex file locations resolved through the standard priority chain.
- * Uses config-paths.ts resolver so XRAY_CONFIG_DIR and .xray/ work.
+ * Uses config-paths.ts resolver so STRRAY_CONFIG_DIR and .strray/ work.
  */
 function getCodexFileLocations(projectRoot) {
     const root = projectRoot || process.cwd();
@@ -139,7 +139,7 @@ export function createXrayCodexInjectorHook() {
                     await loadCodexContext(sessionId);
                     const stats = getCodexStats(sessionId);
                     if (stats.loaded) {
-                        await frameworkLogger.log("codex-injector", "-stringray-codex-loaded-stats-totalterms-terms-sta", "success", {
+                        await frameworkLogger.log("codex-injector", "-xray-codex-loaded-stats-totalterms-terms-sta", "success", {
                             message: `✅ 0xRay Codex loaded: ${stats.totalTerms} terms, ${stats.fileCount} sources`,
                         });
                         await frameworkLogger.log("codex-injector", "codex context loaded successfully", "success", { jobId, ...stats });
@@ -170,7 +170,7 @@ export function createXrayCodexInjectorHook() {
                     });
                     // Skip codex enforcement during testing
                     if (process.env.NODE_ENV === "test" ||
-                        process.env.XRAY_TEST_MODE === "true") {
+                        process.env.STRRAY_TEST_MODE === "true") {
                         await frameworkLogger.log("codex-injector", "skipping enforcement in test mode", "info", { jobId });
                         return;
                     }
@@ -193,7 +193,7 @@ export function createXrayCodexInjectorHook() {
                     await frameworkLogger.log("codex-injector", "codex context loaded for validation", "success", { jobId, contextCount: codexContexts.length });
                     // Use the initialized context loader
                     await initializeImports();
-                    const ContextLoaderClass = XrayContextLoader;
+                    const ContextLoaderClass = StringRayContextLoader;
                     const contextLoader = new ContextLoaderClass();
                     const loadResult = await contextLoader.loadCodexContext(sessionId);
                     if (!loadResult.success || !loadResult.context) {
@@ -263,7 +263,7 @@ export function createXrayCodexInjectorHook() {
                     frameworkLogger.log("codex-injector", "tool.execute.after hook triggered", "info", { jobId, tool: input.tool, sessionId });
                     // Skip codex enforcement during testing
                     if (process.env.NODE_ENV === "test" ||
-                        process.env.XRAY_TEST_MODE === "true") {
+                        process.env.STRRAY_TEST_MODE === "true") {
                         frameworkLogger.log("codex-injector", "skipping injection in test mode", "info", { jobId });
                         return output;
                     }
@@ -271,11 +271,11 @@ export function createXrayCodexInjectorHook() {
                         frameworkLogger.log("codex-injector", "non-critical tool - no injection", "info", { jobId, tool: input.tool });
                         return output;
                     }
-                    await frameworkLogger.log("codex-injector", "-stringray-tool-execution-hook-triggered-for-input", "info", {
+                    await frameworkLogger.log("codex-injector", "-xray-tool-execution-hook-triggered-for-input", "info", {
                         message: `🔧 0xRay: Tool execution hook triggered for ${input.tool}`,
                     });
                     const codexContexts = await loadCodexContext(sessionId);
-                    await frameworkLogger.log("codex-injector", "-stringray-loaded-codexcontexts-length-codex-conte", "info", {
+                    await frameworkLogger.log("codex-injector", "-xray-loaded-codexcontexts-length-codex-conte", "info", {
                         message: `📚 0xRay: Loaded ${codexContexts.length} codex contexts`,
                     });
                     frameworkLogger.log("codex-injector", "codex contexts loaded for injection", "success", {
@@ -422,4 +422,3 @@ export class CodexInjector {
         return { guidance, concerns };
     }
 }
-//# sourceMappingURL=codex-injector.js.map

package/dist/core/config-loader.js

@@ -10,7 +10,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "./framework-logger.js";
 import { getConfigDir, resolveConfigPath } from "./config-paths.js";
-export class XrayConfigLoader {
+export class StringRayConfigLoader {
     configPath;
     cachedConfig = null;
     cacheExpiry = 30000; // 30 seconds
@@ -145,7 +145,4 @@ export class XrayConfigLoader {
     }
 }
 // Export singleton instance
-export const xrayConfigLoader = new XrayConfigLoader();
-// Backward compat alias
-export { xrayConfigLoader as strRayConfigLoader };
-//# sourceMappingURL=config-loader.js.map
+export const strRayConfigLoader = new StringRayConfigLoader();

package/dist/core/config-paths.js

@@ -2,35 +2,25 @@
  * Config Path Resolver
  *
  * Centralizes all 0xRay config file path resolution.
- * Supports XRAY_CONFIG_DIR env var for custom config roots.
+ * Supports STRRAY_CONFIG_DIR env var for custom config roots,
+ * making .opencode/ completely optional for environments like Hermes Agent.
  *
  * Resolution order (per file type):
- *   1. XRAY_CONFIG_DIR/<relative_path>     (if env var set)
- *   2. .xray/<relative_path>                (preferred lightweight root)
- *   3. .opencode/xray/<relative_path>        (OpenCode root)
+ *   1. STRRAY_CONFIG_DIR/<relative_path>     (if env var set)
+ *   2. .strray/<relative_path>                (preferred lightweight root)
+ *   3. .opencode/strray/<relative_path>       (legacy OpenCode root)
  *   4. null                                   (callers fall back to built-in defaults)
  *
  * For state/data directories, uses:
- *   1. XRAY_CONFIG_DIR/state                 (if env var set)
- *   2. .xray/state
+ *   1. STRRAY_CONFIG_DIR/state                 (if env var set)
+ *   2. .strray/state
  *   3. .opencode/state                         (legacy)
- *   4. .xray/state                           (default — always writable)
+ *   4. .strray/state                           (default — always writable)
  */
 import { existsSync } from "fs";
 import { join, resolve } from "path";
 /** Environment variable name for custom config root */
-export const XRAY_CONFIG_DIR_ENV = "XRAY_CONFIG_DIR";
-/** Environment variable name for project root override (set by Grok MCP registration) */
-const XRAY_ROOT_ENV = "XRAY_ROOT";
-/**
- * Resolve the effective project root.
- * Priority: explicit projectRoot param > XRAY_ROOT env var > process.cwd()
- */
-export function resolveProjectRoot(projectRoot) {
-    return projectRoot || process.env[XRAY_ROOT_ENV] || process.cwd();
-}
-/** Legacy env var name (backward compat) */
-// Legacy consumer compat (see bridge and tests)
+export const STRRAY_CONFIG_DIR_ENV = "STRRAY_CONFIG_DIR";
 /** Resolved config directories, cached per projectRoot */
 const _resolvedConfigDirs = new Map();
 /**
@@ -38,11 +28,11 @@ const _resolvedConfigDirs = new Map();
  * Scans in priority order and caches the first one that exists (or the first default).
  */
 export function getConfigDir(projectRoot) {
-    const root = resolveProjectRoot(projectRoot);
+    const root = projectRoot || process.cwd();
     const cached = _resolvedConfigDirs.get(root);
     if (cached)
         return cached;
-    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
+    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
     // Priority candidates
     const candidates = [];
     if (envDir) {
@@ -50,8 +40,8 @@ export function getConfigDir(projectRoot) {
         const resolved = resolve(root, envDir);
         candidates.push({ dir: resolved, source: "env" });
     }
-    candidates.push({ dir: join(root, ".xray"), source: "dot-xray" });
-    candidates.push({ dir: join(root, ".opencode", "xray"), source: "dot-opencode" });
+    candidates.push({ dir: join(root, ".strray"), source: "dot-strray" });
+    candidates.push({ dir: join(root, ".opencode", "strray"), source: "dot-opencode" });
     // Return the first that exists, or the highest-priority default
     for (const c of candidates) {
         if (existsSync(c.dir)) {
@@ -59,7 +49,7 @@ export function getConfigDir(projectRoot) {
             return c.dir;
         }
     }
-    // Nothing exists — use highest priority default (env > .xray > .opencode)
+    // Nothing exists — use highest priority default (env > .strray > .opencode)
     const defaultDir = candidates[0];
     _resolvedConfigDirs.set(root, defaultDir.dir);
     return defaultDir.dir;
@@ -72,14 +62,14 @@ export function getConfigDir(projectRoot) {
  * @param projectRoot  - Optional project root override
  */
 export function resolveConfigPath(relativePath, projectRoot) {
-    const root = resolveProjectRoot(projectRoot);
-    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
+    const root = projectRoot || process.cwd();
+    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
     const candidates = [];
     if (envDir) {
         candidates.push(resolve(root, envDir, relativePath));
     }
-    candidates.push(join(root, ".xray", relativePath));
-    candidates.push(join(root, "xray", relativePath));
+    candidates.push(join(root, ".strray", relativePath));
+    candidates.push(join(root, ".opencode", "strray", relativePath));
     for (const candidate of candidates) {
         if (existsSync(candidate)) {
             return candidate;
@@ -94,13 +84,13 @@ export function resolveConfigPath(relativePath, projectRoot) {
  * Similar logic to resolveConfigPath but for the state/ subdirectory.
  */
 export function resolveStateDir(projectRoot) {
-    const root = resolveProjectRoot(projectRoot);
-    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
+    const root = projectRoot || process.cwd();
+    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
     const candidates = [];
     if (envDir) {
         candidates.push(join(root, envDir, "state"));
     }
-    candidates.push(join(root, ".xray", "state"));
+    candidates.push(join(root, ".strray", "state"));
     candidates.push(join(root, ".opencode", "state"));
     for (const candidate of candidates) {
         if (existsSync(candidate)) {
@@ -121,14 +111,14 @@ export function resolveStateFilePath(projectRoot) {
  * Get the profiles storage directory.
  */
 export function resolveProfilesDir(projectRoot) {
-    const root = resolveProjectRoot(projectRoot);
-    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
+    const root = projectRoot || process.cwd();
+    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
     const candidates = [];
     if (envDir) {
         candidates.push(join(root, envDir, "profiles"));
     }
-    candidates.push(join(root, ".xray", "profiles"));
-    candidates.push(join(root, ".opencode", "xray", "profiles"));
+    candidates.push(join(root, ".strray", "profiles"));
+    candidates.push(join(root, ".opencode", "strray", "profiles"));
     for (const candidate of candidates) {
         if (existsSync(candidate)) {
             return candidate;
@@ -141,14 +131,15 @@ export function resolveProfilesDir(projectRoot) {
  * Has additional fallback locations beyond the standard config dir.
  */
 export function resolveCodexPath(projectRoot) {
-    const root = resolveProjectRoot(projectRoot);
-    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
+    const root = projectRoot || process.cwd();
+    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
     const candidates = [];
     if (envDir) {
         candidates.push(join(root, envDir, "codex.json"));
     }
-    candidates.push(join(root, ".xray", "codex.json"));
+    candidates.push(join(root, ".strray", "codex.json"));
     candidates.push(join(root, "xray", "codex.json"));
+    candidates.push(join(root, ".opencode", "strray", "codex.json"));
     // Additional fallback locations (for standalone usage)
     candidates.push(join(root, "codex.json"));
     candidates.push(join(root, "src", "codex.json"));
@@ -159,7 +150,7 @@ export function resolveCodexPath(projectRoot) {
  * Get the logs directory for framework logging.
  */
 export function resolveLogDir(projectRoot) {
-    const root = resolveProjectRoot(projectRoot);
+    const root = projectRoot || process.cwd();
     // Logs always go to logs/framework/ regardless of config dir
     return join(root, "logs", "framework");
 }
@@ -169,4 +160,3 @@ export function resolveLogDir(projectRoot) {
 export function resetConfigDirCache() {
     _resolvedConfigDirs.clear();
 }
-//# sourceMappingURL=config-paths.js.map

package/dist/core/context-loader.js

@@ -22,7 +22,7 @@ function isValidMatch(match, index) {
  *
  * Loads and parses the Universal Development Codex v1.2.0 from codex.json
  */
-export class XrayContextLoader {
+export class StringRayContextLoader {
     static instance;
     cachedContext = null;
     codexFilePaths = [];
@@ -33,10 +33,10 @@ export class XrayContextLoader {
      * Get singleton instance
      */
     static getInstance() {
-        if (!XrayContextLoader.instance) {
-            XrayContextLoader.instance = new XrayContextLoader();
+        if (!StringRayContextLoader.instance) {
+            StringRayContextLoader.instance = new StringRayContextLoader();
         }
-        return XrayContextLoader.instance;
+        return StringRayContextLoader.instance;
     }
     /**
      * Load codex context
@@ -266,7 +266,4 @@ export class XrayContextLoader {
 /**
  * Export singleton instance
  */
-export const xrayContextLoader = XrayContextLoader.getInstance();
-// Backward compat alias
-export { xrayContextLoader as strRayContextLoader };
-//# sourceMappingURL=context-loader.js.map
+export const strRayContextLoader = StringRayContextLoader.getInstance();

package/dist/core/context-validator.js

@@ -210,4 +210,3 @@ export function generateSafeSystemPrompt(baseTemplate, additionalContext, maxTok
         safe: estimateTokenCount(finalPrompt) <= maxTokens
     };
 }
-//# sourceMappingURL=context-validator.js.map

package/dist/core/features-config.js

@@ -286,7 +286,7 @@ export class FeaturesConfigLoader {
      */
     getDefaultConfig() {
         return {
-            version: "3.0.11",
+            version: "1.22.67",
             description: "0xRay Framework - Unified Feature Configuration",
             token_optimization: {
                 enabled: true,
@@ -455,4 +455,3 @@ export const isFeatureEnabled = (feature) => featuresConfigLoader.isFeatureEnabl
 export const getTokenOptimization = () => featuresConfigLoader.getTokenOptimization();
 export const getBatchOperations = () => featuresConfigLoader.getBatchOperations();
 export const getAgentSpawn = () => featuresConfigLoader.getAgentSpawn();
-//# sourceMappingURL=features-config.js.map

package/dist/core/framework-logger.js

@@ -1,4 +1,5 @@
-import { promises as fs, existsSync, mkdirSync, appendFileSync } from "fs";
+import { isLoggingEnabled, shouldLog, } from "./logging-config.js";
+import { promises as fs, existsSync, mkdirSync } from "fs";
 import { join } from "path";
 /**
  * Generate a unique job ID for tracking work sessions
@@ -74,55 +75,25 @@ export function withJobContext(operation, jobId) {
         if (result instanceof Promise) {
             return result.finally(async () => {
                 // Auto-complete job on operation finish
-                await jobContext.complete(true);
+                await jobContext.complete(true).catch(() => { });
                 // Restore original context
                 currentJobContext = originalContext;
             });
         }
         else {
             // Sync operation - complete immediately
-            jobContext.complete(true);
+            jobContext.complete(true).catch(() => { });
             currentJobContext = originalContext;
             return Promise.resolve(result);
         }
     }
     catch (error) {
         // Error occurred - complete job with failure
-        jobContext.complete(false, { error: String(error) });
+        jobContext.complete(false, { error: String(error) }).catch(() => { });
         currentJobContext = originalContext;
         throw error;
     }
 }
-const defaultLoggingConfig = {
-    enabled: (process.env.XRAY_LOGGING_ENABLED) !== "false",
-    level: (process.env.XRAY_LOG_LEVEL) || "info",
-    destinations: ["console", "file"],
-    performanceMode: (process.env.XRAY_PERFORMANCE_MODE) === "true",
-};
-const LOG_LEVELS = ["debug", "info", "warn", "error"];
-let globalLoggingConfig = { ...defaultLoggingConfig };
-function isLoggingEnabled() {
-    return globalLoggingConfig.enabled;
-}
-function shouldLog(level) {
-    if (!globalLoggingConfig.enabled)
-        return false;
-    const currentLevelIndex = LOG_LEVELS.indexOf(globalLoggingConfig.level);
-    const messageLevelIndex = LOG_LEVELS.indexOf(level);
-    if (currentLevelIndex === -1 || messageLevelIndex === -1)
-        return true;
-    return messageLevelIndex >= currentLevelIndex;
-}
-// Module-level side effects for env var config (previously in logging-config.ts)
-if (process.env.XRAY_LOGGING_ENABLED === "false") {
-    globalLoggingConfig.enabled = false;
-}
-if (process.env.XRAY_LOG_LEVEL) {
-    globalLoggingConfig.level = process.env.XRAY_LOG_LEVEL;
-}
-if (process.env.XRAY_PERFORMANCE_MODE === "true") {
-    globalLoggingConfig.performanceMode = true;
-}
 export class JobContext {
     jobId;
     startTime;
@@ -233,7 +204,7 @@ export class FrameworkUsageLogger {
             ...(currentTraceId && { traceId: currentTraceId }),
             ...(currentSpanId && { spanId: currentSpanId }),
             ...(currentParentSpanId && { parentSpanId: currentParentSpanId }),
-            ...(details !== undefined && { details }),
+            details,
         };
         this.logs.push(entry);
         if (this.logs.length > this.maxLogs) {
@@ -241,7 +212,7 @@ export class FrameworkUsageLogger {
         }
         this.bufferEntry(entry);
     }
-    async bufferEntry(entry) {
+    bufferEntry(entry) {
         const jobIdPart = entry.jobId ? `[${entry.jobId}] ` : "";
         const tracePart = entry.traceId ? `[${entry.traceId}.${entry.spanId}] ` : "";
         const detailsPart = entry.details
@@ -255,7 +226,7 @@ export class FrameworkUsageLogger {
         const line = `${new Date(entry.timestamp).toISOString()} ${jobIdPart}${tracePart}[${entry.component}] ${entry.action} - ${entry.status.toUpperCase()}${detailsPart}\n`;
         this.buffer.push(line);
         if (this.buffer.length >= this.MAX_BUFFER_SIZE) {
-            await this.flushBuffer();
+            this.flushBuffer();
             return;
         }
         if (!this.flushTimer) {
@@ -276,21 +247,17 @@ export class FrameworkUsageLogger {
         const data = toWrite.join("");
         try {
             const cwd = process.cwd();
-            if (!cwd) {
-                this.flushing = false;
+            if (!cwd)
                 return;
-            }
             const logDir = join(cwd, "logs", "framework");
             const logFile = join(logDir, "activity.log");
             if (!existsSync(logDir)) {
                 mkdirSync(logDir, { recursive: true });
             }
-            await fs.appendFile(logFile, data);
+            await fs.appendFile(logFile, data).catch(() => { });
+            this.flushing = false;
         }
         catch {
-            // flush failure is non-fatal
-        }
-        finally {
             this.flushing = false;
         }
     }
@@ -304,36 +271,5 @@ export class FrameworkUsageLogger {
     printRundown() {
         // Framework usage analytics placeholder
     }
-    flushSync() {
-        if (this.flushing || this.buffer.length === 0)
-            return;
-        const toWrite = this.buffer.splice(0, this.buffer.length);
-        const data = toWrite.join("");
-        try {
-            const cwd = process.cwd();
-            if (!cwd)
-                return;
-            const logDir = join(cwd, "logs", "framework");
-            const logFile = join(logDir, "activity.log");
-            if (!existsSync(logDir)) {
-                mkdirSync(logDir, { recursive: true });
-            }
-            appendFileSync(logFile, data);
-        }
-        catch {
-            // flush failure is non-fatal
-        }
-    }
 }
 export const frameworkLogger = new FrameworkUsageLogger();
-// Flush buffer synchronously on exit so CLI commands don't lose log entries
-if (typeof process !== "undefined" && process.env?.NODE_ENV !== "test") {
-    process.on("exit", () => {
-        frameworkLogger.flushSync();
-    });
-}
-// Startup self-test: verify logger works
-if (typeof process !== "undefined" && process.env?.NODE_ENV !== "test") {
-    frameworkLogger.log("system", "logger initialized", "info").catch(() => { });
-}
-//# sourceMappingURL=framework-logger.js.map

package/dist/core/index.js

@@ -1,9 +1,6 @@
 export { KernelOrchestrator } from "./orchestrator.js";
-export { defaultXrayConfig } from "./xray-activation.js";
+export { defaultStringRayConfig } from "./xray-activation.js"; // consumer runtime compat from prior StringRay releases (1-line min per Scope Rule)
 // Decoupled config path resolution (Layer 1)
-export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, XRAY_CONFIG_DIR_ENV,
-// Legacy export for compat shims
- } from "./config-paths.js";
+export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, STRRAY_CONFIG_DIR_ENV, } from "./config-paths.js";
 // Standalone codex formatter (Layer 2)
 export { formatCodexPrompt, formatMinimalCodexPrompt, getCodexConfig, findCodexPath, loadCodex, BUILTIN_CODEX, } from "./codex-formatter.js";
-//# sourceMappingURL=index.js.map

package/dist/core/kernel-patterns.js

@@ -300,4 +300,3 @@ export function getKernel() {
 export function resetKernel() {
     kernelInstance = null;
 }
-//# sourceMappingURL=kernel-patterns.js.map

package/dist/core/logging-config.js

@@ -0,0 +1,43 @@
+// Default logging configuration
+const defaultLoggingConfig = {
+    enabled: process.env.STRRAY_LOGGING_ENABLED !== "false", // Default true, can be disabled
+    level: process.env.STRRAY_LOG_LEVEL || "info",
+    destinations: ["console", "file"],
+    performanceMode: process.env.STRRAY_PERFORMANCE_MODE === "true",
+};
+// Available log levels in priority order (higher index = more verbose)
+const LOG_LEVELS = ["debug", "info", "warn", "error"];
+// Global logging configuration instance
+let globalLoggingConfig = { ...defaultLoggingConfig };
+export function getLoggingConfig() {
+    return { ...globalLoggingConfig };
+}
+export function setLoggingConfig(config) {
+    globalLoggingConfig = { ...globalLoggingConfig, ...config };
+}
+export function isLoggingEnabled() {
+    return globalLoggingConfig.enabled;
+}
+export function shouldLog(level) {
+    if (!globalLoggingConfig.enabled) {
+        return false;
+    }
+    const currentLevelIndex = LOG_LEVELS.indexOf(globalLoggingConfig.level);
+    const messageLevelIndex = LOG_LEVELS.indexOf(level);
+    // If either level is not found, default to showing the message
+    if (currentLevelIndex === -1 || messageLevelIndex === -1) {
+        return true;
+    }
+    // Show message if its level is >= current configured level
+    return messageLevelIndex >= currentLevelIndex;
+}
+// Environment variable configuration
+if (process.env.STRRAY_LOGGING_ENABLED === "false") {
+    setLoggingConfig({ enabled: false });
+}
+if (process.env.STRRAY_LOG_LEVEL) {
+    setLoggingConfig({ level: process.env.STRRAY_LOG_LEVEL });
+}
+if (process.env.STRRAY_PERFORMANCE_MODE === "true") {
+    setLoggingConfig({ performanceMode: true });
+}

package/dist/core/model-router.js

@@ -173,4 +173,3 @@ export default modelRouter;
 export const getModelForTask = (context) => modelRouter.getModelForTask(context);
 export const getModelForTaskType = (taskType) => modelRouter.getModelForTaskType(taskType);
 export const getValidatedModel = (agentType) => modelRouter.getValidatedModel(agentType);
-//# sourceMappingURL=model-router.js.map