salmon-loop 0.2.3

package/dist/cli/ui/styles/theme.js

@@ -0,0 +1,295 @@
+/**
+ * Salmon Loop CLI Theme
+ * Based on Figma design system from CLI-AI-Assistant-Design
+ * Color palette extracted from /home/shangxin/Projects/Cliaiassistantdesign
+ */
+import chalk from 'chalk';
+/**
+ * Core color palette (hex values from Figma design)
+ */
+export const COLORS = {
+    // Background layers
+    bg: {
+        outer: '#0e1117', // Outer background (matched to terminal)
+        terminal: '#0e1117', // Terminal main background
+        highlight: '#171b22', // Hover/highlight areas
+        errorBg: '#1a0f0f', // Error background
+        warningBg: '#1a1a0f', // Warning background
+    },
+    // Text hierarchy
+    text: {
+        primary: '#c7d1db', // Primary text
+        muted: '#6e7681', // Secondary/gray text
+    },
+    // Borders
+    border: {
+        main: '#1f2933', // Main borders (thick)
+        subtle: '#21262d', // Subtle borders
+    },
+    // Semantic colors (key brand colors)
+    semantic: {
+        salmon: '#d95030', // Brand color - AI assistant messages
+        cyan: '#30d9b9', // User messages, success states
+        blue: '#3095d9', // PLAN type, checkpoint
+        orange: '#ff9e64', // TOOL type
+        red: '#ff6b6b', // Danger/error
+        yellow: '#ffd93d', // Warning
+    },
+};
+/**
+ * Ink-compatible color names
+ * Maps Figma hex colors to Ink's supported color names
+ */
+export const INK_COLORS = {
+    salmon: 'red', // Closest to #d95030
+    cyan: 'cyan', // Matches #30d9b9
+    blue: 'blue', // Matches #3095d9
+    orange: 'yellow', // Closest to #ff9e64
+    red: 'red', // Matches #ff6b6b
+    yellow: 'yellow', // Matches #ffd93d
+    gray: 'gray',
+    green: 'green',
+};
+/**
+ * Message style configuration based on Figma design
+ * Includes color, label, border, and spacing for each message type
+ */
+export const MESSAGE_STYLES = {
+    // Level 1 - Emphasis (with border)
+    assistant: {
+        inkColor: COLORS.semantic.salmon,
+        label: '<>< SALMON',
+        hasBorder: true,
+        marginBottom: 1,
+    },
+    assistant_stream: {
+        inkColor: COLORS.semantic.salmon,
+        label: '<>< SALMON',
+        hasBorder: true,
+        marginBottom: 1,
+    },
+    todo_card: {
+        inkColor: COLORS.semantic.blue,
+        label: 'TODO',
+        hasBorder: true,
+        marginBottom: 1,
+    },
+    error: {
+        inkColor: COLORS.semantic.red,
+        label: 'ERROR',
+        hasBorder: true,
+        marginBottom: 1,
+    },
+    warning: {
+        inkColor: COLORS.semantic.yellow,
+        label: 'WARNING',
+        hasBorder: true,
+        marginBottom: 1,
+    },
+    // Level 2 - Standard
+    user: {
+        inkColor: COLORS.semantic.cyan,
+        label: 'USER',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    tool_result: {
+        inkColor: COLORS.semantic.orange,
+        label: 'TOOL',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    checkpoint: {
+        inkColor: COLORS.semantic.blue,
+        label: 'CHKPT',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    interrupt: {
+        inkColor: COLORS.semantic.red,
+        label: 'INTR',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    // Level 3 - Lightweight (no label, compact)
+    system: {
+        inkColor: COLORS.text.muted,
+        label: null,
+        hasBorder: false,
+        marginBottom: 0,
+    },
+    queue: {
+        inkColor: COLORS.text.muted,
+        label: null,
+        hasBorder: false,
+        marginBottom: 0,
+    },
+    thinking: {
+        inkColor: COLORS.text.muted,
+        label: 'THNK',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    explore_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'EXPL',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    plan_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'PLAN',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    patch_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'PATCH',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    apply_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'APPLY',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    validate_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'VLD',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    verify_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'VRF',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    preflight_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'PRE',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    context_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'CTX',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    ast_validate_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'AST',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    rollback_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'RLBK',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    shrink_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'SHRK',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    review_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'REVW',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    report_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'REPORT',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    analyze_issues_step: {
+        inkColor: COLORS.semantic.blue,
+        label: 'ANLZ',
+        hasBorder: false,
+        marginBottom: 1,
+    },
+    tool_call: {
+        inkColor: COLORS.text.muted,
+        label: null,
+        hasBorder: false,
+        marginBottom: 0,
+    },
+    welcome: {
+        inkColor: COLORS.text.muted,
+        label: null,
+        hasBorder: false,
+        marginBottom: 1,
+    },
+};
+/**
+ * Chalk-based theme for terminal output
+ * Uses chalk.hex() for precise color matching
+ */
+export const SALMON_THEME = {
+    // Message type colors (based on Figma LogStream component)
+    messageType: {
+        user: chalk.hex(COLORS.semantic.cyan), // Cyan - USER messages
+        assistant: chalk.hex(COLORS.semantic.salmon), // Salmon - AI messages
+        system: chalk.hex(COLORS.text.muted), // Gray - SYSTEM messages
+        tool: chalk.hex(COLORS.semantic.orange), // Orange - TOOL calls
+        plan: chalk.hex(COLORS.semantic.blue), // Blue - PLAN/analysis
+        error: chalk.hex(COLORS.semantic.red), // Red - errors
+        warning: chalk.hex(COLORS.semantic.yellow), // Yellow - warnings
+    },
+    // Text hierarchy
+    text: {
+        primary: chalk.hex(COLORS.text.primary),
+        muted: chalk.hex(COLORS.text.muted),
+        bold: chalk.hex(COLORS.text.primary).bold,
+    },
+    // Semantic colors for status/feedback
+    semantic: {
+        success: chalk.hex(COLORS.semantic.cyan),
+        warning: chalk.hex(COLORS.semantic.yellow),
+        error: chalk.hex(COLORS.semantic.red),
+        info: chalk.hex(COLORS.semantic.blue),
+    },
+    // Brand elements
+    brand: {
+        salmon: chalk.hex(COLORS.semantic.salmon).bold,
+        prompt: chalk.hex(COLORS.semantic.salmon).bold, // For s8p> prompt
+        logo: chalk.hex(COLORS.semantic.salmon).bold, // For <><< ASCII salmon
+    },
+    // Border colors (Ink limitations - using closest named colors)
+    border: {
+        main: 'gray', // Approximates #1f2933
+        subtle: 'gray', // Approximates #21262d
+    },
+};
+/**
+ * Check if separator should be shown between messages
+ * Based on Figma design's smart separator logic
+ */
+export function shouldShowSeparator(currentType, nextType) {
+    if (!nextType)
+        return false;
+    // Always separate user/assistant messages
+    const emphasisTypes = ['user', 'assistant', 'assistant_stream', 'todo_card'];
+    if (emphasisTypes.includes(currentType) || emphasisTypes.includes(nextType)) {
+        return true;
+    }
+    // Get styles for level comparison
+    const currentStyle = MESSAGE_STYLES[currentType];
+    const nextStyle = MESSAGE_STYLES[nextType];
+    if (!currentStyle || !nextStyle) {
+        return true; // Default to showing separator if style is missing
+    }
+    // Keep lightweight messages compact (no separator between them)
+    if (!currentStyle.label && !nextStyle.label) {
+        return false;
+    }
+    // Separate on type change
+    return currentType !== nextType;
+}
+//# sourceMappingURL=theme.js.map

package/dist/cli/ui/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/cli/ui/utils/sanitizer.js

@@ -0,0 +1,122 @@
+import { UI_CONFIG } from '../config.js';
+import { normalizeLegacyType } from '../store/types.js';
+/**
+ * Sanitizes and truncates messages to prevent technical detail leaks (e.g. 429 errors)
+ * and UI breakage from massive strings.
+ *
+ * Strictly follows functional purity and captures both raw content and messages.
+ */
+export function sanitizeMessage(ev) {
+    let safeMessage = String(ev.content || ev.message || '');
+    // 0. Block massive Zod/Validation JSON dumps immediately
+    // Matches "code": "invalid_union", "code": "invalid_type", etc., with flexible quoting/spacing
+    // Also catches AI SDK's "Error message: [" prefix for validation errors
+    const zodJsonPattern = /['"]?code['"]?\s*:\s*['"]?invalid_(union|type|value|enum|string|date|literal)['"]?/i;
+    if (safeMessage.includes('ZodError: [') ||
+        safeMessage.startsWith('Error message: [') ||
+        zodJsonPattern.test(safeMessage)) {
+        return 'Error: Invalid input parameters (Validation failed)';
+    }
+    // 0.5. Heuristic Block: Massive non-code-block JSON/Object dumps
+    // This acts as a safety net for any structural error dumps that bypass specific filters
+    const isLong = safeMessage.length > 500;
+    const hasCodeBlock = safeMessage.includes('```');
+    if (isLong && !hasCodeBlock) {
+        // Count JSON/Object structural characters: { } [ ] " : ,
+        const structureChars = (safeMessage.match(/[{}[\]":,]/g) || []).length;
+        const density = structureChars / safeMessage.length;
+        // Threshold > 10% density is extremely high for natural language
+        if (density > 0.1) {
+            return 'Error: Complex system error (details hidden). See logs.';
+        }
+    }
+    // 1. Block massive SDK error objects/stacks and 429 details
+    const isAiError = /RetryError|APICallError|statusCode: 429|Rate limit exceeded|ZodError|ValidationError|TypeError.*at\s+/i.test(safeMessage);
+    // 2. Filter out stack traces (security & UX)
+    // Enhanced detection: check for any stack trace indicators
+    // Also detect JSON fragments mixed with stack traces (e.g., Zod errors)
+    const hasStackTrace = /^\s*at\s+/m.test(safeMessage) ||
+        /\s+at\s+\w+.*\(/m.test(safeMessage) ||
+        safeMessage.includes('node_modules') ||
+        safeMessage.includes('file:///') ||
+        /:\d+:\d+\)$/m.test(safeMessage) || // matches line:col) at end of lines
+        (/^\s*[\]},]/.test(safeMessage) && /\s+at\s+/.test(safeMessage)); // JSON fragments + stack traces
+    if (isAiError || hasStackTrace) {
+        const lastErrorMatch = safeMessage.match(/Last error:\s*([^\n{]+)/i);
+        const jsonMessageMatch = safeMessage.match(/"message"\s*:\s*"([^"]+)"/i);
+        const plainMessageMatch = safeMessage.match(/message:\s*'([^']+)'/i);
+        // Extract just the error type and message, aggressively filter stack traces
+        const errorLines = safeMessage.split('\n').filter((line) => {
+            const trimmed = line.trim();
+            // Reject empty lines, stack traces, file paths
+            if (!trimmed)
+                return false;
+            if (trimmed.startsWith('at '))
+                return false;
+            if (trimmed.includes('node_modules'))
+                return false;
+            if (trimmed.includes('file:///'))
+                return false;
+            if (/:\d+:\d+\)?$/.test(trimmed))
+                return false; // line:col at end
+            if (/^\w+Error:/.test(trimmed) && trimmed.length > 200)
+                return false; // suspiciously long error line
+            return true;
+        });
+        if (lastErrorMatch) {
+            safeMessage = `Error: ${lastErrorMatch[1].trim()}`;
+        }
+        else if (jsonMessageMatch) {
+            safeMessage = `Error: ${jsonMessageMatch[1]}`;
+        }
+        else if (plainMessageMatch) {
+            safeMessage = `Error: ${plainMessageMatch[1]}`;
+        }
+        else if (errorLines.length > 0) {
+            // Use first non-stack-trace line, clean up error type prefix
+            const cleanLine = errorLines[0]
+                .replace(/^(ZodError|ValidationError|TypeError|Error|APICallError|RetryError):\s*/i, '')
+                .trim()
+                .substring(0, 150);
+            // If line is still too technical or empty, use generic message
+            if (!cleanLine || cleanLine.length < 3 || /^[[{]/.test(cleanLine)) {
+                safeMessage = 'An error occurred. Please try again or rephrase your request.';
+            }
+            else {
+                safeMessage = cleanLine.toLowerCase().includes('error') ? cleanLine : `Error: ${cleanLine}`;
+            }
+        }
+        else {
+            // All lines were stack traces - use generic message
+            safeMessage = 'An error occurred. Please try again or rephrase your request.';
+        }
+    }
+    // 2. Strict length limit for UI stability
+    const hasStructure = safeMessage.includes('```') || safeMessage.includes('`');
+    const isConversation = ev.type === 'ai' || ev.type === 'assistant' || ev.type === 'user';
+    const limit = isConversation
+        ? UI_CONFIG.CONVERSATION_CONTENT_LIMIT
+        : hasStructure
+            ? UI_CONFIG.STRUCTURED_CONTENT_LIMIT
+            : UI_CONFIG.LOG_CHAR_LIMIT;
+    if (safeMessage.length > limit) {
+        safeMessage = safeMessage.substring(0, limit - 3) + '...';
+    }
+    return safeMessage;
+}
+/**
+ * Prepares a sanitized message payload for the UI store.
+ */
+export function prepareMessagePayload(ev) {
+    const sanitizedContent = sanitizeMessage(ev);
+    // Normalize legacy types (e.g. 'ai' -> 'assistant')
+    const safeType = normalizeLegacyType(ev.type || 'system');
+    return {
+        ...ev,
+        id: ev.id || `sys-${Math.random().toString(36).substring(7)}`,
+        type: safeType,
+        content: sanitizedContent,
+        timestamp: ev.timestamp || new Date(),
+    };
+}
+//# sourceMappingURL=sanitizer.js.map

package/dist/cli/ui/utils/transcript.js

@@ -0,0 +1,28 @@
+export function buildTranscriptMessages(messages, options) {
+    const limit = Math.max(0, Math.floor(options?.limit ?? 200));
+    if (!Array.isArray(messages) || limit === 0)
+        return [];
+    const filtered = [];
+    for (const msg of messages) {
+        if (!msg || typeof msg !== 'object')
+            continue;
+        if (msg.role !== 'user' && msg.role !== 'assistant')
+            continue;
+        if (typeof msg.content !== 'string')
+            continue;
+        if (typeof msg.timestamp !== 'number' || !Number.isFinite(msg.timestamp))
+            continue;
+        const content = msg.content.trimEnd();
+        if (!content)
+            continue;
+        filtered.push({ role: msg.role, content, timestamp: msg.timestamp });
+    }
+    const slice = limit >= filtered.length ? filtered : filtered.slice(filtered.length - limit);
+    return slice.map((m, i) => ({
+        id: `transcript-${m.role}-${m.timestamp}-${i}`,
+        type: m.role === 'user' ? 'user' : 'assistant',
+        content: m.content,
+        timestamp: new Date(m.timestamp),
+    }));
+}
+//# sourceMappingURL=transcript.js.map

package/dist/cli/utils/asyncQueue.js

@@ -0,0 +1,125 @@
+import { logIgnoredError } from '../../core/facades/cli-observability.js';
+export function createAsyncQueue(onStateChange, options = {}) {
+    const queue = [];
+    let isProcessing = false;
+    let isPaused = false;
+    const { maxSize, overflowStrategy = 'reject' } = options;
+    const emitState = () => {
+        onStateChange?.({ pendingCount: queue.length, isProcessing, isPaused });
+    };
+    const processNext = () => {
+        if (isPaused) {
+            emitState();
+            return;
+        }
+        if (isProcessing)
+            return;
+        const next = queue.shift();
+        if (!next) {
+            emitState();
+            return;
+        }
+        isProcessing = true;
+        emitState();
+        Promise.resolve(next.task())
+            .then((result) => {
+            next.resolve(result);
+        })
+            .catch((error) => {
+            next.reject(error);
+        })
+            .finally(() => {
+            isProcessing = false;
+            emitState();
+            processNext();
+        });
+    };
+    const canAccept = () => {
+        if (typeof maxSize !== 'number' || maxSize < 0)
+            return true;
+        if (queue.length < maxSize)
+            return true;
+        return false;
+    };
+    const enforceCapacity = (onDropNewest, onDropOldest) => {
+        if (canAccept())
+            return true;
+        if (overflowStrategy === 'drop_oldest') {
+            onDropOldest();
+            return true;
+        }
+        if (overflowStrategy === 'drop_newest') {
+            onDropNewest();
+            return false;
+        }
+        onDropNewest();
+        return false;
+    };
+    const enqueue = (task) => {
+        const promise = new Promise((resolve, reject) => {
+            const dropEntry = (entry) => {
+                if (!entry)
+                    return;
+                entry.reject(new Error('AsyncQueue overflow: task dropped'));
+            };
+            const accepted = enforceCapacity(() => reject(new Error('AsyncQueue overflow: task dropped')), () => dropEntry(queue.shift()));
+            if (!accepted)
+                return;
+            queue.push({ task, resolve, reject });
+            emitState();
+            queueMicrotask(processNext);
+        });
+        promise.catch((error) => logIgnoredError('[AsyncQueue] task rejected (enqueue)', error));
+        return promise;
+    };
+    const enqueueFront = (task) => {
+        const promise = new Promise((resolve, reject) => {
+            const dropEntry = (entry) => {
+                if (!entry)
+                    return;
+                entry.reject(new Error('AsyncQueue overflow: task dropped'));
+            };
+            const accepted = enforceCapacity(() => reject(new Error('AsyncQueue overflow: task dropped')), () => dropEntry(queue.pop()));
+            if (!accepted)
+                return;
+            queue.unshift({ task, resolve, reject });
+            emitState();
+            queueMicrotask(processNext);
+        });
+        promise.catch((error) => logIgnoredError('[AsyncQueue] task rejected (enqueueFront)', error));
+        return promise;
+    };
+    const clear = () => {
+        let cleared = 0;
+        while (queue.length > 0) {
+            const entry = queue.shift();
+            if (entry) {
+                entry.reject(new Error('AsyncQueue cleared'));
+                cleared += 1;
+            }
+        }
+        emitState();
+        return cleared;
+    };
+    const pause = () => {
+        isPaused = true;
+        emitState();
+    };
+    const resume = () => {
+        if (!isPaused)
+            return;
+        isPaused = false;
+        emitState();
+        queueMicrotask(processNext);
+    };
+    const getState = () => ({ pendingCount: queue.length, isProcessing, isPaused });
+    return {
+        enqueue,
+        enqueueFront,
+        clear,
+        pause,
+        resume,
+        getState,
+    };
+}
+//# sourceMappingURL=asyncQueue.js.map

package/dist/cli/utils/audit-scope.js

@@ -0,0 +1,10 @@
+export function resolveAuditScope(params) {
+    if (params.cliValue === undefined || params.cliValue === null || params.cliValue === '') {
+        return { ok: true, value: params.configValue };
+    }
+    if (params.cliValue === 'repo' || params.cliValue === 'user') {
+        return { ok: true, value: params.cliValue };
+    }
+    return { ok: false, invalid: String(params.cliValue) };
+}
+//# sourceMappingURL=audit-scope.js.map

package/dist/cli/utils/detectors/index.js

@@ -0,0 +1,38 @@
+import { detectNodeRuntimeProfile, resolveNodeWorktreePrepareCommand, resolveNodeVerifyCommand, } from '../../../core/target-runtime/index.js';
+export class NodeDetector {
+    async detect(repoPath) {
+        const profile = await detectNodeRuntimeProfile(repoPath);
+        if (!profile)
+            return undefined;
+        return resolveNodeVerifyCommand(profile);
+    }
+}
+export const detectors = [new NodeDetector()];
+export class NodeWorktreePrepareDetector {
+    async detect(repoPath) {
+        const profile = await detectNodeRuntimeProfile(repoPath);
+        if (!profile)
+            return undefined;
+        return resolveNodeWorktreePrepareCommand(profile);
+    }
+}
+export const worktreePrepareDetectors = [new NodeWorktreePrepareDetector()];
+export async function autoDetectVerifyCommand(repoPath) {
+    for (const detector of detectors) {
+        const command = await detector.detect(repoPath);
+        if (command) {
+            return command;
+        }
+    }
+    return undefined;
+}
+export async function autoDetectWorktreePrepareCommand(repoPath) {
+    for (const detector of worktreePrepareDetectors) {
+        const command = await detector.detect(repoPath);
+        if (command) {
+            return command;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=index.js.map

package/dist/cli/utils/llm-output.js

@@ -0,0 +1,34 @@
+import { LLM_OUTPUT_KINDS, resolveLlmOutputPolicy, } from '../../core/facades/cli-utils-llm-output.js';
+const ALL_KINDS = [...LLM_OUTPUT_KINDS];
+export function parseLlmOutputKinds(raw) {
+    const trimmed = raw.trim().toLowerCase();
+    if (!trimmed)
+        return { ok: false };
+    if (trimmed === 'none')
+        return { ok: true, kinds: [] };
+    if (trimmed === 'all')
+        return { ok: true, kinds: ALL_KINDS };
+    const parts = trimmed
+        .split(',')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    if (parts.length === 0)
+        return { ok: false };
+    const kinds = [];
+    for (const part of parts) {
+        if (!ALL_KINDS.includes(part)) {
+            return { ok: false, invalid: part };
+        }
+        kinds.push(part);
+    }
+    return { ok: true, kinds };
+}
+export function resolveLlmOutputPolicyFromCli(configPolicy, cliValue) {
+    if (!cliValue)
+        return { ok: true, policy: configPolicy };
+    const parsed = parseLlmOutputKinds(cliValue);
+    if (!parsed.ok)
+        return { ok: false, invalid: parsed.invalid };
+    return { ok: true, policy: resolveLlmOutputPolicy({ kinds: parsed.kinds }) };
+}
+//# sourceMappingURL=llm-output.js.map

package/dist/cli/utils/outcome-reporter.js

@@ -0,0 +1,17 @@
+import { LiteLlmLangfuseOutcomeReporter } from '../../integrations/langfuse/litellm-langfuse-outcome-reporter.js';
+import { resolveLangfuseOutcomeProxyBaseUrl } from '../../integrations/langfuse/outcome-proxy.js';
+export function createOutcomeReporter(params) {
+    const resolved = resolveLangfuseOutcomeProxyBaseUrl({
+        enabled: params.enabled,
+        endpoint: params.endpoint,
+        llmBaseUrl: params.llmBaseUrl,
+    });
+    if (!resolved.enabled || !resolved.proxyBaseUrl)
+        return undefined;
+    return new LiteLlmLangfuseOutcomeReporter({
+        proxyBaseUrl: resolved.proxyBaseUrl,
+        proxyPathPrefix: resolved.proxyPathPrefix,
+        litellmApiKey: params.langfuseApiKey,
+    });
+}
+//# sourceMappingURL=outcome-reporter.js.map