`;\n let resultDisplay = `

Enter goals & click \"Analyze\".

`;\n let logDisplay = \"\";\n if (initialAnalysisResult) {\n try {\n const pRes = JSON.parse(initialAnalysisResult);\n const dispRes = { ...pRes };\n delete dispRes.debugLog;\n delete dispRes.chartData;\n resultDisplay = `

${JSON.stringify(dispRes, null, 2)}

`;\n if (pRes.debugLog && Array.isArray(pRes.debugLog)) {\n logDisplay = pRes.debugLog.map(log => {\n const logT = new Date(log.timestamp).toLocaleTimeString();\n const detS = log.details ? \" :: \" + log.details : \"\";\n const msgE = String(log.message || \"\").replace(//g, \">\");\n const detE = String(detS || \"\").replace(//g, \">\");\n return `

[${logT}] [${\n log.level || \"INFO\"\n }] [${log.component || \"System\"}] ${msgE}${detE}

`;\n }).join(\"\");\n }\n } catch (e: any) {\n resultDisplay = `

Error rendering: ${e.message}

${initialAnalysisResult}

`;\n }\n }\n return `\n📈 Predictive Stock Analysis 📈\n\n\n

📈 Predictive Stock Analysis 📈

Enter goals. A multi-agent system will suggest tickers, analyze, simulate (Monte Carlo), interpret, and suggest actions, visualized.

⚠️ **Disclaimer:** Predictions are uncertain simulations based on past volatility, NOT guarantees. Informational only, NOT financial advice. Consult a qualified advisor.

Investment Goals

Risk Tolerance:

Time Horizon:

Sectors (comma-separated, or 'Any'):

Approx. Investment Amount (Optional):

Other Notes (Optional):

${resultDisplay}

Execution Log:

${logDisplay}

${sourceLinkHtml}\n`;\n}\n\nasync function callOpenAI(\n systemPrompt: string,\n userMessage: string,\n model = \"gpt-4o-mini\",\n isJsonOutputRequired = true,\n log: LogFunction,\n agentName: string,\n taskId: string,\n): Promise<{ role: \"assistant\" | \"system\"; content: string }> {\n const callId = Math.random().toString(36).substring(2, 8);\n const logPfx = `OpenAI Call [${agentName} ${taskId.split(\"-\")[1] || taskId} ${callId}]`;\n try {\n log(\"DEBUG\", agentName, `${logPfx}: Initiating (${model}, JSON: ${isJsonOutputRequired})...`);\n const openai = new OpenAI();\n const res = await openai.chat.completions.create({\n model,\n messages: [{ role: \"system\", content: systemPrompt }, { role: \"user\", content: userMessage }],\n temperature: 0.3,\n ...(isJsonOutputRequired && { response_format: { type: \"json_object\" } }),\n });\n const content = res.choices?.[0]?.message?.content;\n if (!content) {\n log(\"ERROR\", agentName, `${logPfx}: OpenAI returned empty/invalid response.`);\n throw new Error(\"Invalid/empty AI response.\");\n }\n log(\"DEBUG\", agentName, `${logPfx}: SUCCESS.`);\n return { role: \"assistant\", content };\n } catch (err: any) {\n log(\"ERROR\", agentName, `${logPfx}: FAILED. Error: ${err.message}`, err);\n let errMsg = `Error via ${agentName}.`;\n let code = err.status || (err.response ? err.response.status : null);\n const errData = err.response?.data || err.error || err.response || err;\n if (errData?.message) { errMsg = `OpenAI Err (${code || \"?\"}) via ${agentName}: ${errData.message}`; }\n else if (errData?.error?.message) { errMsg = `OpenAI Err (${code || \"?\"}) via ${agentName}: ${errData.error.message}`; }\n else if (err.message) { errMsg += ` Details: ${err.message}`; }\n else { try { errMsg += ` Unknown err: ${JSON.stringify(errData)}`; } catch { errMsg += \" Unknown non-serializable err.\"; }}\n if (code === 401) errMsg += \" (ACTION: Check API key)\";\n else if (code === 429) errMsg += \" (ACTION: Rate limit/quota exceeded)\";\n else if (code === 400) errMsg += \" (ACTION: Bad request/prompt issue)\";\n else if (err.code === \"ENOTFOUND\" || err.code === \"ECONNREFUSED\" || err.cause?.code === \"UND_ERR_CONNECT_TIMEOUT\") errMsg += \" (ACTION: Network error)\";\n else if (code >= 500) errMsg += \" (ACTION: OpenAI server issue)\";\n const escapedErr = errMsg.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, \"\\\\\\\"\").replace(/\\n/g, \"\\\\n\");\n if (isJsonOutputRequired) {\n const errJson = `{\"error\": \"${escapedErr}\"}`;\n log(\"ERROR\", agentName, `${logPfx}: Returning structured error: ${errJson}`);\n return { role: \"system\", content: errJson };\n } else {\n const plainErr = `System Error: ${errMsg}`;\n log(\"ERROR\", agentName, `${logPfx}: Returning plain text error: ${plainErr}`);\n return { role: \"system\", content: plainErr };\n }\n }\n}\n\nfunction hashCode(str: string): string {\n let hash = 0;\n if (!str || str.length === 0) return \"0\";\n for (let i = 0; i < str.length; i++) {\n const char = str.charCodeAt(i);\n hash = ((hash << 5) - hash) + char;\n hash |= 0;\n }\n return hash.toString(16);\n}\n\nasync function fetchTickerDataFromYahoo(\n ticker: string,\n range = \"1y\",\n internalLog: (msg: string) => void,\n): Promise {\n const interval = \"1d\";\n const logPfx = `YahooFetch [${ticker}, ${range}]`;\n internalLog(`${logPfx}: Init fetch...`);\n try {\n if (!/^[A-Z0-9.-]+$/.test(ticker)) {\n const err = `Invalid ticker format: ${ticker}`;\n internalLog(`${logPfx}: [ERROR] ${err}`);\n return { ticker, error: err, dates: [], open: [], high: [], low: [], close: [], volume: [] };\n }\n const validRanges = [\"1d\", \"5d\", \"1mo\", \"3mo\", \"6mo\", \"1y\", \"2y\", \"5y\", \"10y\", \"ytd\", \"max\"];\n if (!validRanges.includes(range)) {\n internalLog(`${logPfx}: [WARN] Invalid range '${range}', using '1y'.`);\n range = \"1y\";\n }\n const url = new URL(`https://query1.finance.yahoo.com/v8/finance/chart/${encodeURIComponent(ticker)}`);\n url.searchParams.set(\"range\", range);\n url.searchParams.set(\"interval\", interval);\n url.searchParams.set(\"includeTimestamps\", \"true\");\n url.searchParams.set(\"events\", \"div,splits\");\n internalLog(`${logPfx}: [INFO] Fetching: ${url}`);\n const opts = {\n method: \"GET\",\n headers: {\n \"User-Agent\": \"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36\",\n \"Accept\": \"application/json\",\n \"Accept-Language\": \"en-US,en;q=0.9\",\n \"Connection\": \"keep-alive\",\n \"Referer\": `https://finance.yahoo.com/quote/${ticker}/`,\n \"Origin\": \"https://finance.yahoo.com\",\n },\n };\n const res = await fetch(url.toString(), opts);\n const resText = await res.text();\n let jsonData;\n try {\n jsonData = JSON.parse(resText);\n } catch (parseErr) {\n internalLog(`${logPfx}: [ERROR] Failed JSON parse. Status: ${res.status}. Resp: ${resText.substring(0, 100)}...`);\n return { ticker, error: \"Failed Yahoo parse\", dates: [], open: [], high: [], low: [], close: [], volume: [] };\n }\n if (jsonData?.chart?.error) {\n const errDesc = jsonData.chart.error.description || jsonData.chart.error.code || \"Unknown Yahoo error\";\n internalLog(`${logPfx}: [ERROR] Yahoo API Error: ${errDesc}`);\n return { ticker, error: `Yahoo API Error: ${errDesc}`, dates: [], open: [], high: [], low: [], close: [], volume: [] };\n }\n if (!res.ok || !jsonData?.chart?.result?.[0]) {\n const errDet = res.ok ? \"Missing chart.result\" : `HTTP ${res.status}`;\n internalLog(`${logPfx}: [ERROR] No valid data. Detail: ${errDet}. Resp: ${resText.substring(0, 100)}...`);\n return { ticker, error: `Failed fetch: ${errDet}`, dates: [], open: [], high: [], low: [], close: [], volume: [] };\n }\n const result = jsonData.chart.result[0];\n const timestamps = result.timestamp || [];\n const quotes = result.indicators?.quote?.[0];\n if (!quotes || !timestamps.length || !quotes.close) {\n internalLog(`${logPfx}: [WARN] No valid quote data found in response.`);\n return { ticker, error: \"No valid quote data found\", dates: [], open: [], high: [], low: [], close: [], volume: [] };\n }\n const combined = timestamps.map((ts, i) => ({\n ts,\n open: quotes.open?.[i] ?? null,\n high: quotes.high?.[i] ?? null,\n low: quotes.low?.[i] ?? null,\n close: quotes.close?.[i] ?? null,\n volume: quotes.volume?.[i] ?? null,\n })).filter(d => d.ts != null && d.close != null)\n .sort((a, b) => a.ts - b.ts);\n const dates = combined.map(d => new Date(d.ts * 1000).toISOString().split(\"T\")[0]);\n const MIN_DATA_POINTS = 50;\n if (dates.length < MIN_DATA_POINTS) {\n internalLog(`${logPfx}: [WARN] Insufficient data (${dates.length}) for analysis (need ${MIN_DATA_POINTS}).`);\n return { ticker, error: `Insufficient data (${dates.length}). Need ${MIN_DATA_POINTS}.`, dates: [], open: [], high: [], low: [], close: [], volume: [] };\n }\n const data: TickerData = {\n ticker,\n dates,\n open: combined.map(d => d.open),\n high: combined.map(d => d.high),\n low: combined.map(d => d.low),\n close: combined.map(d => d.close),\n volume: combined.map(d => d.volume),\n };\n internalLog(`${logPfx}: [SUCCESS] Fetched ${data.dates.length} valid data points.`);\n return data;\n } catch (err: any) {\n internalLog(`${logPfx}: [CRITICAL ERROR] Unexpected fetch failure: ${err.message}`);\n console.error(`${logPfx} Error:`, err);\n return { ticker, error: `Unexpected fetch error: ${err.message}`, dates: [], open: [], high: [], low: [], close: [], volume: [] };\n }\n}\n\nclass SqliteMemoryAgent {\n private log: LogFunction;\n private tableName = \"agent_memory_v3_1\";\n private constructor(log: LogFunction) {\n this.log = log;\n }\n private async initDb() {\n const q = `CREATE TABLE IF NOT EXISTS ${this.tableName} (key TEXT PRIMARY KEY, value TEXT, mandateId TEXT, taskId TEXT, timestamp TEXT);`;\n try {\n await sqlite.execute({ sql: q, args: [] });\n this.log(\"INFO\", \"SqliteMemoryAgent\", `Table ${this.tableName} ensured.`);\n } catch (e) {\n this.log(\"ERROR\", \"SqliteMemoryAgent\", `Table ${this.tableName} initialization failed.`, e);\n throw e;\n }\n }\n public static async create(log: LogFunction): Promise {\n const agent = new SqliteMemoryAgent(log);\n try {\n await agent.initDb();\n log(\"INFO\", \"SqliteMemoryAgent\", \"Agent created & DB initialized successfully.\");\n return agent;\n } catch (initErr: any) {\n log(\"FATAL\", \"SqliteMemoryAgent\", \"Failed to create Memory Agent instance.\", initErr);\n throw new Error(`Memory Agent initialization failed: ${initErr.message}`);\n }\n }\n async store(mandateId: string, taskId: string, key: string, value: any): Promise> {\n const logPfx = `[${mandateId}/${taskId}]`;\n this.log(\"INFO\", \"SqliteMemoryAgent\", `${logPfx} Storing key: ${key}`);\n try {\n const valStr = JSON.stringify(value);\n const ts = new Date().toISOString();\n const q = `INSERT INTO ${this.tableName} (key, value, mandateId, taskId, timestamp) VALUES (?, ?, ?, ?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value, mandateId = excluded.mandateId, taskId = excluded.taskId, timestamp = excluded.timestamp;`;\n await sqlite.execute({ sql: q, args: [key, valStr, mandateId, taskId, ts] });\n this.log(\"DEBUG\", \"SqliteMemoryAgent\", `${logPfx} Stored OK: ${key}`);\n return { mandateId, correlationId: taskId, senderRole: \"MemoryService\", payload: { success: true } };\n } catch (e: any) {\n this.log(\"ERROR\", \"SqliteMemoryAgent\", `${logPfx} Store failed for key: ${key}`, e);\n return {\n mandateId,\n correlationId: taskId,\n senderRole: \"MemoryService\",\n payload: { success: false },\n error: `SQLite store operation failed: ${e.message}`,\n };\n }\n }\n async retrieve(mandateId: string, taskId: string, key: string): Promise> {\n const logPfx = `[${mandateId}/${taskId}]`;\n this.log(\"INFO\", \"SqliteMemoryAgent\", `${logPfx} Retrieving key: ${key}`);\n try {\n const q = `SELECT value FROM ${this.tableName} WHERE key = ?;`;\n const res = await sqlite.execute({ sql: q, args: [key] });\n if (res.rows && res.rows.length > 0) {\n const valStr = (res.rows[0] as { value: string }).value;\n try {\n const val = JSON.parse(valStr);\n this.log(\"DEBUG\", \"SqliteMemoryAgent\", `${logPfx} Retrieved OK: ${key}`);\n return { mandateId, correlationId: taskId, senderRole: \"MemoryService\", payload: { value: val } };\n } catch (parseErr: any) {\n this.log(\"ERROR\", \"SqliteMemoryAgent\", `${logPfx} Failed to parse stored JSON for key: ${key}`, parseErr);\n return {\n mandateId,\n correlationId: taskId,\n senderRole: \"MemoryService\",\n payload: { value: null },\n error: `Failed to parse stored JSON: ${parseErr.message}`,\n };\n }\n } else {\n this.log(\"INFO\", \"SqliteMemoryAgent\", `${logPfx} No data found for key: ${key}`);\n return { mandateId, correlationId: taskId, senderRole: \"MemoryService\", payload: { value: null } };\n }\n } catch (e: any) {\n this.log(\"ERROR\", \"SqliteMemoryAgent\", `${logPfx} Retrieve failed for key: ${key}`, e);\n return {\n mandateId,\n correlationId: taskId,\n senderRole: \"MemoryService\",\n payload: { value: null },\n error: `SQLite retrieve operation failed: ${e.message}`,\n };\n }\n }\n}\n\nclass MockLoggingAgent {\n private auditLog: {\n timestamp: string;\n mandateId: string;\n taskId?: string;\n level: string;\n component: string;\n message: string;\n details?: string;\n }[] = [];\n private log: LogFunction;\n constructor(log: LogFunction) {\n this.log = log;\n this.log(\"INFO\", \"LoggingAgent\", \"Mock Logging Agent Initialized.\");\n }\n async record(\n entry: { mandateId: string; taskId?: string; level: string; component: string; message: string; details?: any },\n ): Promise {\n const ts = new Date().toISOString();\n let detStr: string | undefined;\n if (entry.details !== undefined) {\n try {\n detStr = JSON.stringify(entry.details);\n } catch (e: any) {\n detStr = `[Unserializable Details: ${e.message}]`;\n }\n }\n this.auditLog.push({\n timestamp: ts,\n mandateId: entry.mandateId,\n taskId: entry.taskId,\n level: entry.level.toUpperCase(),\n component: entry.component,\n message: entry.message,\n details: detStr,\n });\n await new Promise(r => setTimeout(r, 5));\n }\n getLogs(): any[] {\n return JSON.parse(JSON.stringify(this.auditLog));\n }\n}\n\nasync function runTickerSuggestionAgent(\n task: TaskInput,\n log: LogFunction,\n): Promise> {\n const agentName = \"TickerSuggestionAgent\";\n const taskId = task.taskId;\n log(\"INFO\", agentName, `Task ${taskId}. Processing goals. Hash: ${hashCode(JSON.stringify(task.payload))}`);\n const result = await callOpenAI(\n tickerSuggestionAgentSystemPrompt,\n JSON.stringify(task.payload),\n \"gpt-4o-mini\",\n true,\n log,\n agentName,\n taskId,\n );\n let payload: { suggested_tickers: string[] } | { error: string } = { error: \"Agent processing failed.\" };\n let agentErr: string | undefined;\n try {\n const parsed = JSON.parse(result.content);\n if (parsed.error && result.role === \"system\") {\n agentErr = `AI Communication Error: ${parsed.error}`;\n payload = { error: agentErr };\n } else if (parsed.error) {\n agentErr = `Agent Logic Error: ${parsed.error}`;\n payload = { error: agentErr };\n } else if (Array.isArray(parsed.suggested_tickers)) {\n const tickers = parsed.suggested_tickers.map((t: any) =>\n String(t).toUpperCase().trim().replace(/[^A-Z0-9.-]/g, \"\")\n ).filter((t: string) => t.length > 0 && t.length < 10);\n const limited = [...new Set(tickers)].slice(0, 5);\n if (limited.length > 0) {\n payload = { suggested_tickers: limited };\n log(\"SUCCESS\", agentName, `Task ${taskId} completed. Suggested: ${limited.join(\", \")}`);\n } else {\n agentErr = \"Agent returned empty or invalid tickers after validation.\";\n payload = { error: agentErr };\n }\n } else {\n agentErr = \"LLM response missing 'suggested_tickers' array.\";\n payload = { error: agentErr };\n }\n } catch (e: any) {\n agentErr = `Failed to parse agent response: ${e.message}`;\n payload = { error: agentErr };\n log(\"ERROR\", agentName, `Task ${taskId} response parse failed. Response snippet: ${result.content.substring(0, 100)}...`, e);\n }\n if (agentErr && !(payload as any).error) { (payload as any).error = agentErr; }\n if (agentErr) { log(\"ERROR\", agentName, `Task ${taskId} failed: ${agentErr}`); }\n return { mandateId: task.mandateId, correlationId: taskId, senderRole: \"Responsible\", payload, error: agentErr };\n}\n\nasync function runContextDataFetchingAgent(\n task: TaskInput<{ tickers: string[]; data_needed: string[] }>,\n log: LogFunction,\n): Promise> {\n const agentName = \"ContextDataFetchingAgent\";\n const taskId = task.taskId;\n const { tickers: reqTickers, data_needed } = task.payload;\n const tickers = [...new Set(reqTickers)];\n log(\n \"INFO\",\n agentName,\n `Task ${taskId}. Fetching ${data_needed.join(\", \")} for ${tickers.length} tickers: ${tickers.join(\", \")}`,\n );\n const intLog = (msg: string) => log(\"DEBUG\", agentName, `[${taskId}] ${msg}`);\n const tickerDataMap = new Map();\n const fetchErrs: Record = {};\n let newsSent: Record | undefined;\n let sysErr: string | undefined;\n if (data_needed.includes(\"yahoo_1y\")) {\n const promises = tickers.map(t => fetchTickerDataFromYahoo(t, \"1y\", intLog));\n try {\n const results = await Promise.all(promises);\n results.forEach(d => {\n tickerDataMap.set(d.ticker, d);\n if (d.error) { fetchErrs[d.ticker] = `Yahoo Error: ${d.error}`; }\n });\n const successCount = tickers.length - Object.keys(fetchErrs).length;\n log(\n \"INFO\",\n agentName,\n `Yahoo fetch completed for ${taskId}. ${successCount} successful, ${Object.keys(fetchErrs).length} errors.`,\n );\n if (successCount === 0 && tickers.length > 0) {\n log(\"ERROR\", agentName, `Yahoo fetch FAILED for ALL tickers in task ${taskId}.`);\n }\n } catch (e: any) {\n log(\"ERROR\", agentName, `Critical error during parallel Yahoo fetch for task ${taskId}`, e);\n sysErr = `Parallel fetch execution failed: ${e.message}`;\n fetchErrs[\"SYSTEM\"] = sysErr;\n }\n } else { log(\"WARN\", agentName, `Task ${taskId} skipped 'yahoo_1y' data fetch.`); }\n if (data_needed.includes(\"market_news_sentiment\") && !sysErr) {\n log(\"INFO\", agentName, `Simulating news sentiment fetch for task ${taskId}...`);\n newsSent = {};\n await new Promise(r => setTimeout(r, 50 + Math.random() * 50));\n for (const t of tickers) {\n const r = Math.random();\n if (fetchErrs[t]) {\n newsSent[t] = \"Error\";\n if (!fetchErrs[t]?.includes(\"News\")) fetchErrs[t] += \"; News Error: Skipped due to prior error\";\n } else if (r < 0.05) {\n newsSent[t] = \"Error\";\n fetchErrs[t] = (fetchErrs[t] ? `${fetchErrs[t]}; ` : \"\") + \"News Error: Simulated fetch failure\";\n } else if (r < 0.35) { newsSent[t] = \"Negative\"; }\n else if (r < 0.75) { newsSent[t] = \"Neutral\"; }\n else { newsSent[t] = \"Positive\"; }\n }\n log(\"INFO\", agentName, `News sentiment simulation completed for task ${taskId}.`);\n } else if (data_needed.includes(\"market_news_sentiment\") && sysErr) {\n log(\"WARN\", agentName, `Skipping news sentiment simulation for task ${taskId} due to prior system error.`);\n } else { log(\"WARN\", agentName, `Task ${taskId} skipped 'market_news_sentiment' data fetch.`); }\n return {\n mandateId: task.mandateId,\n correlationId: taskId,\n senderRole: \"Responsible\",\n payload: { tickerDataMap, newsSentiment: newsSent, fetchErrors: fetchErrs },\n error: sysErr,\n };\n}\n\nasync function runQuantitativeAnalysisAgent(\n task: TaskInput<{ ticker: string; tickerData: TickerData }>,\n log: LogFunction,\n): Promise> {\n const agentName = \"QuantitativeAnalysisAgent\";\n const { ticker, tickerData } = task.payload;\n const taskId = task.taskId;\n log(\"INFO\", agentName, `Task ${taskId} for ${ticker}. Input data points: ${tickerData?.close?.length ?? 0}`);\n const metrics: Partial = { ticker };\n let agentErr: string | undefined;\n try {\n if (!tickerData || !tickerData.close || tickerData.close.length < 50) {\n throw new Error(`Insufficient valid close price data provided (${tickerData?.close?.length ?? 0}). Need at least 50.`);\n }\n const closes = tickerData.close.filter(p => typeof p === \"number\") as number[];\n if (closes.length < 50) {\n throw new Error(`Insufficient valid (non-null) close prices (${closes.length}). Need at least 50.`);\n }\n metrics.lastClose = closes[closes.length - 1];\n const calc = (name: string, fn: () => any) => {\n try {\n const result = fn();\n if (result === undefined || (typeof result === 'number' && isNaN(result))) {\n log(\"WARN\", agentName, `Task ${taskId} - Calculation ${name} for ${ticker} resulted in undefined/NaN.`);\n return undefined;\n }\n if (typeof result === 'object' && result !== null) {\n if (Object.values(result).some(v => v === undefined || (typeof v === 'number' && isNaN(v)))) {\n log(\"WARN\", agentName, `Task ${taskId} - Calculation ${name} for ${ticker} resulted in object with undefined/NaN properties.`);\n return undefined;\n }\n }\n return result;\n } catch (e: any) {\n log(\"WARN\", agentName, `Task ${taskId} - Calculation ${name} failed for ${ticker}: ${e.message}`);\n return undefined;\n }\n };\n if (closes.length >= 20) {\n metrics.sma20 = calc(\"SMA20\", () => ta.SMA.calculate({ period: 20, values: closes }).pop());\n metrics.bollingerBands = calc(\n \"BBands\",\n () => ta.BollingerBands.calculate({ period: 20, stdDev: 2, values: closes })?.pop(),\n );\n }\n if (closes.length >= 50) {\n metrics.sma50 = calc(\"SMA50\", () => ta.SMA.calculate({ period: 50, values: closes }).pop());\n }\n if (closes.length >= 200) {\n metrics.sma200 = calc(\"SMA200\", () => ta.SMA.calculate({ period: 200, values: closes }).pop());\n }\n if (closes.length >= 14) {\n metrics.rsi14 = calc(\"RSI14\", () => ta.RSI.calculate({ period: 14, values: closes }).pop());\n }\n if (closes.length >= 26) {\n metrics.ema12 = calc(\"EMA12\", () => ta.EMA.calculate({ period: 12, values: closes }).pop());\n metrics.ema26 = calc(\"EMA26\", () => ta.EMA.calculate({ period: 26, values: closes }).pop());\n const macdIn = { values: closes, fastPeriod: 12, slowPeriod: 26, signalPeriod: 9, SimpleMAOscillator: false, SimpleMASignal: false };\n const macdRes = calc(\"MACD\", () => ta.MACD.calculate(macdIn));\n if (macdRes?.length > 0) {\n const last = macdRes.pop();\n metrics.macdLine = last?.MACD;\n metrics.signalLine = last?.signal;\n metrics.histogram = last?.histogram;\n }\n }\n if (\n tickerData.high && tickerData.low && closes.length >= 15 && tickerData.high.length >= 15\n && tickerData.low.length >= 15\n ) {\n const atrIn = {\n high: tickerData.high.filter(p => typeof p === \"number\") as number[],\n low: tickerData.low.filter(p => typeof p === \"number\") as number[],\n close: closes,\n period: 14,\n };\n if (atrIn.high.length >= 15 && atrIn.low.length >= 15) {\n metrics.atr14 = calc(\"ATR14\", () => ta.ATR.calculate(atrIn).pop());\n }\n }\n const volPer = 30;\n if (closes.length >= volPer + 1) {\n metrics.historicalVolatility = calc(\"HistVol\", () => {\n const logRets: number[] = [];\n const prices = closes.slice(-volPer - 1);\n for (let i = 1; i < prices.length; i++) {\n if (prices[i - 1] > 0 && prices[i] > 0) {\n logRets.push(Math.log(prices[i] / prices[i - 1]));\n }\n }\n if (logRets.length < volPer / 2) return undefined;\n const mean = logRets.reduce((s, v) => s + v, 0) / logRets.length;\n const variance = logRets.reduce((s, v) => s + Math.pow(v - mean, 2), 0) / (logRets.length - 1);\n const stdDev = Math.sqrt(variance);\n return stdDev * Math.sqrt(252);\n });\n }\n log(\"SUCCESS\", agentName, `Task ${taskId} - Metrics calculation completed successfully for ${ticker}.`);\n } catch (e: any) {\n agentErr = `Quantitative analysis failed for ${ticker}: ${e.message}`;\n metrics.error = agentErr;\n log(\"ERROR\", agentName, `Task ${taskId} - ${agentErr}`, e);\n }\n return {\n mandateId: task.mandateId,\n correlationId: taskId,\n senderRole: \"Responsible\",\n payload: metrics as TickerMetrics,\n error: agentErr,\n };\n}\n\nasync function runPredictionAgent(\n task: TaskInput<{ ticker: string; metrics: TickerMetrics }>,\n log: LogFunction,\n): Promise> {\n const agentName = \"PredictionAgent\";\n const { ticker, metrics } = task.payload;\n const taskId = task.taskId;\n log(\n \"INFO\",\n agentName,\n `Task ${taskId} for ${ticker}. LastClose: ${metrics.lastClose}, HistVol: ${metrics.historicalVolatility}`,\n );\n const numSims = 7;\n const predDays = 60;\n const dt = 1 / 252;\n const paths: PredictionPath[] = [];\n let agentErr: string | undefined;\n if (\n metrics.error || !metrics.lastClose || metrics.historicalVolatility === undefined\n || metrics.historicalVolatility <= 0 || isNaN(metrics.historicalVolatility)\n ) {\n agentErr = `Skipping prediction for ${ticker}: missing or invalid inputs (Error: ${metrics.error || \"lastClose/histVol invalid/missing\"})`;\n log(\"WARN\", agentName, `Task ${taskId} - ${agentErr}`);\n return {\n mandateId: task.mandateId,\n correlationId: taskId,\n senderRole: \"Responsible\",\n payload: { ticker, predictionPaths: [], predictionPeriodDays: predDays, error: agentErr },\n error: agentErr,\n };\n }\n try {\n const S0 = metrics.lastClose;\n const sigma = metrics.historicalVolatility;\n const mu = 0;\n for (let i = 0; i < numSims; i++) {\n const path: PredictionPath = [];\n let St = S0;\n let curDate = new Date();\n for (let t = 1; t <= predDays; t++) {\n let Z: number;\n let u1: number, u2: number;\n do { u1 = Math.random(); } while (u1 === 0);\n u2 = Math.random();\n Z = Math.sqrt(-2.0 * Math.log(u1)) * Math.cos(2.0 * Math.PI * u2);\n St = St * Math.exp((mu - sigma ** 2 / 2) * dt + sigma * Math.sqrt(dt) * Z);\n St = Math.max(0.01, St);\n curDate.setDate(curDate.getDate() + 1);\n path.push({ date: curDate.toISOString().split(\"T\")[0], price: parseFloat(St.toFixed(2)) });\n }\n paths.push(path);\n }\n log(\"SUCCESS\", agentName, `Task ${taskId} - Generated ${numSims} prediction paths for ${ticker} (${predDays} days).`);\n } catch (e: any) {\n agentErr = `Monte Carlo simulation error for ${ticker}: ${e.message}`;\n log(\"ERROR\", agentName, `Task ${taskId} - ${agentErr}`, e);\n }\n return {\n mandateId: task.mandateId,\n correlationId: taskId,\n senderRole: \"Responsible\",\n payload: { ticker, predictionPaths: paths, predictionPeriodDays: predDays, error: agentErr },\n error: agentErr,\n };\n}\n\nasync function runTickerInterpretationAgent(\n task: TaskInput<{ ticker: string; userGoals: UserGoals; metrics: Partial; context?: any }>,\n log: LogFunction,\n): Promise> {\n const agentName = \"TickerInterpretationAgent\";\n const { ticker, userGoals, metrics, context } = task.payload;\n const taskId = task.taskId;\n log(\"INFO\", agentName, `Task ${taskId} for ${ticker}. Metrics provided: ${!!metrics}, Error in metrics: ${!!metrics?.error}`);\n if (\n !metrics || metrics.error || metrics.lastClose === undefined || metrics.sma20 === undefined\n || metrics.rsi14 === undefined\n ) {\n const err = `Insufficient or error-containing metrics for interpretation: ${metrics?.error || \"Key metrics (lastClose, SMA20, RSI14) missing or invalid\"}`;\n log(\"WARN\", agentName, `Task ${taskId} - ${err}`);\n return {\n mandateId: task.mandateId,\n correlationId: taskId,\n senderRole: \"Responsible\",\n payload: {\n ticker,\n error: err,\n summary: \"\", indicatorInterpretation: \"\", volatilityAssessment: \"\", alignmentWithGoals: \"\",\n confidence: \"Low\", newsContextSentiment: \"N/A\",\n },\n error: err,\n };\n }\n const input = JSON.stringify({\n ticker,\n userGoals,\n metrics: {\n lastClose: metrics.lastClose,\n sma20: metrics.sma20,\n sma50: metrics.sma50,\n sma200: metrics.sma200,\n rsi14: metrics.rsi14,\n macdLine: metrics.macdLine,\n signalLine: metrics.signalLine,\n histogram: metrics.histogram,\n bollingerBands: metrics.bollingerBands,\n atr14: metrics.atr14,\n historicalVolatility: metrics.historicalVolatility,\n },\n context: {\n newsSentiment: context?.newsSentiment?.[ticker] ?? \"N/A\"\n },\n });\n const result = await callOpenAI(\n tickerInterpretationAgentSystemPrompt,\n input,\n \"gpt-4o-mini\",\n true,\n log,\n agentName,\n taskId,\n );\n let payload: TickerInterpretation | { error: string; ticker: string } = { error: \"Agent interpretation failed.\", ticker };\n let agentErr: string | undefined;\n try {\n const parsed = JSON.parse(result.content);\n if (parsed.error && result.role === \"system\") {\n agentErr = `AI Communication Error: ${parsed.error}`;\n payload = { error: agentErr, ticker };\n } else if (parsed.error) {\n agentErr = `Agent Logic Error: ${parsed.error}`;\n payload = {\n ticker: parsed.ticker || ticker,\n error: agentErr,\n summary: parsed.summary || \"\", indicatorInterpretation: parsed.indicatorInterpretation || \"\",\n volatilityAssessment: parsed.volatilityAssessment || \"\", alignmentWithGoals: parsed.alignmentWithGoals || \"\",\n confidence: parsed.confidence || \"Low\",\n newsContextSentiment: context?.newsSentiment?.[ticker] || \"N/A\",\n };\n } else if (\n parsed.ticker && parsed.summary && parsed.indicatorInterpretation && parsed.volatilityAssessment\n && parsed.alignmentWithGoals && parsed.confidence\n ) {\n payload = parsed as TickerInterpretation;\n payload.newsContextSentiment = payload.newsContextSentiment ?? context?.newsSentiment?.[ticker] ?? \"N/A\";\n if (![\"High\", \"Medium\", \"Low\"].includes(payload.confidence)) payload.confidence = \"Low\";\n log(\"SUCCESS\", agentName, `Task ${taskId} interpretation completed successfully for ${ticker}.`);\n } else {\n agentErr = \"LLM interpretation response missing required fields.\";\n payload = { error: agentErr, ticker };\n }\n } catch (e: any) {\n agentErr = `Failed to parse interpretation agent response: ${e.message}`;\n payload = { error: agentErr, ticker };\n log(\"ERROR\", agentName, `Task ${taskId} for ${ticker} response parse failed. Response snippet: ${result.content.substring(0, 100)}...`, e);\n }\n if (agentErr && !(payload as any).error) { (payload as any).error = agentErr; }\n if (!(payload as any).ticker) { (payload as any).ticker = ticker; }\n if (agentErr) { log(\"ERROR\", agentName, `Task ${taskId} for ${ticker} failed: ${agentErr}`); }\n return {\n mandateId: task.mandateId,\n correlationId: taskId,\n senderRole: \"Responsible\",\n payload: payload as TickerInterpretation,\n error: agentErr,\n };\n}\n\nasync function runSynthesisChartingDataAgent(\n task: TaskInput<\n {\n userGoals: UserGoals;\n tickerInterpretations: (TickerInterpretation | { error: string; ticker: string })[];\n tickerPredictions: (TickerPrediction | { error: string; ticker: string })[];\n historicalDataMap: Map;\n pastPerformanceContext?: any;\n }\n >,\n log: LogFunction,\n): Promise> {\n const agentName = \"SynthesisChartingAgent\";\n const {\n userGoals,\n tickerInterpretations: interps,\n tickerPredictions: preds,\n historicalDataMap: histMap,\n pastPerformanceContext,\n } = task.payload;\n const taskId = task.taskId;\n const numInterps = interps.length;\n const okInterpsCount = interps.filter(i => !(i as any).error).length;\n log(\"INFO\", agentName, `Task ${taskId}. Synthesizing ${numInterps} interpretations (${okInterpsCount} OK).`);\n const usableTickers = interps\n .map(i => i.ticker)\n .filter(t =>\n interps.find(i => i.ticker === t && !(i as any).error) &&\n preds.find(p => p.ticker === t && !(p as any).error && p.predictionPaths?.length > 0)\n );\n if (usableTickers.length === 0 && numInterps > 0) {\n const err = \"Synthesis failed: No tickers found with both successful interpretation and prediction data.\";\n log(\"WARN\", agentName, `Task ${taskId}: ${err}`);\n return {\n mandateId: task.mandateId,\n correlationId: taskId,\n senderRole: \"Responsible\",\n payload: {\n error: err, overallOutlook: \"\", actionableSteps: [], keyRisks: [], keyOpportunities: [], disclaimer: \"\",\n },\n error: err,\n };\n }\n const input = JSON.stringify({\n userGoals,\n tickerInterpretations: interps.filter(i => !(i as any).error),\n tickerPredictions: preds\n .filter(p => !(p as any).error && p.predictionPaths?.length > 0)\n .map(p => ({\n ticker: p.ticker,\n predictionSummary: `Simulated ${p.predictionPaths?.length ?? 0} paths for ${p.predictionPeriodDays} days based on historical volatility.`,\n predictionError: (p as any).error,\n })),\n failedAnalyses: interps.filter(i => (i as any).error).map(i => ({ ticker: i.ticker, error: (i as any).error })),\n failedPredictions: preds.filter(p => (p as any).error || p.predictionPaths?.length === 0).map(p => ({ ticker: p.ticker, error: (p as any).error || \"No prediction paths generated\" })),\n pastPerformanceContext: pastPerformanceContext ?? \"N/A\",\n });\n const result = await callOpenAI(\n synthesisChartingDataAgentSystemPrompt,\n input,\n \"gpt-4o\",\n true,\n log,\n agentName,\n taskId,\n );\n let payload: Partial = { error: \"Agent synthesis processing failed.\" };\n let agentErr: string | undefined;\n try {\n const parsed = JSON.parse(result.content);\n if (parsed.error && result.role === \"system\") {\n agentErr = `AI Communication Error: ${parsed.error}`;\n payload = { error: agentErr };\n } else if (parsed.error) {\n agentErr = `Agent Logic Error: ${parsed.error}`;\n payload = { error: agentErr, details: parsed.details };\n } else if (\n parsed.overallOutlook && parsed.actionableSteps && parsed.keyRisks && parsed.keyOpportunities && parsed.disclaimer\n ) {\n payload = parsed as EnhancedActionSynthesis;\n if (!Array.isArray(payload.actionableSteps)) throw new Error(\"ActionableSteps is not an array.\");\n payload.actionableSteps = payload.actionableSteps.filter(s =>\n s.ticker && s.action && s.rationale && s.confidence\n );\n log(\"SUCCESS\", agentName, `Task ${taskId} - LLM Synthesis completed successfully.`);\n } else {\n agentErr = \"Synthesis response missing required fields (outlook, steps, risks, opps, disclaimer).\";\n payload = { error: agentErr };\n }\n } catch (e: any) {\n agentErr = `Failed to parse synthesis agent response: ${e.message}`;\n payload = { error: agentErr };\n log(\"ERROR\", agentName, `Task ${taskId} LLM response parse failed. Response snippet: ${result.content.substring(0, 100)}...`, e);\n }\n if (!agentErr) {\n payload.chartData = [];\n log(\"INFO\", agentName, `Task ${taskId} - Preparing chart data for ${usableTickers.length} tickers...`);\n for (const ticker of usableTickers) {\n const histData = histMap.get(ticker);\n const predData = preds.find(p => p.ticker === ticker && !(p as any).error && p.predictionPaths?.length > 0) as TickerPrediction | undefined;\n if (histData?.dates && histData.close && predData?.predictionPaths) {\n const lookback = 252;\n const histDates = histData.dates.slice(-lookback);\n const histClose = histData.close.slice(-lookback);\n if (histDates.length > 0 && histClose.length > 0) {\n payload.chartData.push({\n ticker,\n historical: { dates: histDates, close: histClose },\n predictions: predData.predictionPaths.map((path, i) => ({ pathId: i, data: path })),\n });\n log(\"DEBUG\", agentName, `Task ${taskId} - Chart data prepared successfully for ${ticker}.`);\n } else { log(\"WARN\", agentName, `Task ${taskId} - Insufficient historical data after slicing for chart: ${ticker}.`); }\n } else { log(\"WARN\", agentName, `Task ${taskId} - Missing required historical or prediction data for chart generation: ${ticker}.`); }\n }\n log(\"INFO\", agentName, `Task ${taskId} - Chart data preparation complete. ${payload.chartData.length} charts generated.`);\n }\n if (agentErr && !payload.error) { payload.error = agentErr; }\n if (agentErr) { log(\"ERROR\", agentName, `Task ${taskId} synthesis or chart preparation failed: ${agentErr}`); }\n return {\n mandateId: task.mandateId,\n correlationId: taskId,\n senderRole: \"Responsible\",\n payload: payload as EnhancedActionSynthesis,\n error: agentErr,\n };\n}\n\nclass Orchestrator {\n private mandateId: string;\n private userGoals: UserGoals | null = null;\n private log: LogFunction;\n private memoryAgent: SqliteMemoryAgent;\n private loggingAgent: MockLoggingAgent;\n constructor(log: LogFunction, memoryAgent: SqliteMemoryAgent, loggingAgent: MockLoggingAgent) {\n this.mandateId = `MANDATE-${Date.now()}-${Math.random().toString(16).substring(2, 8)}`;\n this.log = log;\n this.memoryAgent = memoryAgent;\n this.loggingAgent = loggingAgent;\n this.internalLog(\"INFO\", `Orchestrator initialized with Mandate ID: ${this.mandateId}`);\n }\n private async internalLog(level: string, message: string, details?: any) {\n this.log(level, \"Orchestrator\", `[${this.mandateId.split(\"-\")[1]}] ${message}`, details);\n await this.loggingAgent.record({\n mandateId: this.mandateId,\n level: level.toUpperCase(),\n component: \"Orchestrator\",\n message,\n details,\n });\n }\n private async auditAgentTaskResult(agentName: string, taskOutput: TaskOutput) {\n await this.loggingAgent.record({\n mandateId: taskOutput.mandateId,\n taskId: taskOutput.correlationId,\n level: taskOutput.error ? \"ERROR\" : \"INFO\",\n component: agentName,\n message: `Task ${taskOutput.error ? \"failed\" : \"completed\"}. Role: ${taskOutput.senderRole}`,\n details: taskOutput.error ? { error: taskOutput.error, payload: taskOutput.payload } : taskOutput.payload,\n });\n }\n async runAnalysisWorkflow(\n initialGoals: UserGoals,\n ): Promise<{ result?: EnhancedActionSynthesis; error?: string; details?: string; intermediate_results?: any }> {\n await this.internalLog(\"STEP\", \"Workflow Initiated: Starting analysis process.\");\n this.userGoals = initialGoals;\n const intRes: any = {\n userGoals: this.userGoals,\n suggestedTickers: [],\n contextData: null,\n quantitativeMetrics: [],\n predictions: [],\n interpretations: [],\n };\n let finalRes: EnhancedActionSynthesis | undefined;\n let workflowErr: string | undefined;\n let errDetails: string | undefined;\n try {\n const suggestTask: TaskInput = {\n mandateId: this.mandateId, taskId: `TSK-Suggest-${Date.now()}`, senderRole: \"Orchestrator\", recipientRole: \"Responsible\", payload: this.userGoals,\n };\n await this.internalLog(\"STEP\", `Requesting ticker suggestions. Task ID: ${suggestTask.taskId}`);\n const suggestOut = await runTickerSuggestionAgent(suggestTask, this.log);\n await this.auditAgentTaskResult(\"TickerSuggestionAgent\", suggestOut);\n if (suggestOut.error || (suggestOut.payload as { error: string })?.error || !(suggestOut.payload as { suggested_tickers: string[] }).suggested_tickers) {\n throw new Error(`Ticker Suggestion Failed: ${suggestOut.error || (suggestOut.payload as { error: string })?.error || \"No tickers returned\"}`);\n }\n intRes.suggestedTickers = (suggestOut.payload as { suggested_tickers: string[] }).suggested_tickers;\n if (intRes.suggestedTickers.length === 0) {\n throw new Error(\"Ticker Suggestion Failed: Agent returned an empty list of tickers.\");\n }\n await this.internalLog(\"SUCCESS\", `Received suggested tickers: ${intRes.suggestedTickers.join(\", \")}`);\n const fetchDataTask: TaskInput<{ tickers: string[]; data_needed: string[] }> = {\n mandateId: this.mandateId, taskId: `TSK-Fetch-${Date.now()}`, senderRole: \"Orchestrator\", recipientRole: \"Responsible\",\n payload: { tickers: intRes.suggestedTickers, data_needed: [\"yahoo_1y\", \"market_news_sentiment\"] },\n };\n await this.internalLog(\"STEP\", `Requesting context data (Yahoo, News Sim). Task ID: ${fetchDataTask.taskId}`);\n const fetchDataOut = await runContextDataFetchingAgent(fetchDataTask, this.log);\n await this.auditAgentTaskResult(\"ContextDataFetchingAgent\", fetchDataOut);\n if (fetchDataOut.error) { throw new Error(`Context Data Fetching Failed (System): ${fetchDataOut.error}`); }\n intRes.contextData = fetchDataOut.payload;\n const tickersWithData = intRes.suggestedTickers.filter(t =>\n !intRes.contextData?.fetchErrors?.[t] &&\n intRes.contextData?.tickerDataMap.has(t) &&\n (intRes.contextData?.tickerDataMap.get(t)?.close?.length ?? 0) > 0\n );\n if (tickersWithData.length === 0) {\n throw new Error(`Context Data Fetching Failed: No valid data retrieved for any suggested ticker. Errors: ${JSON.stringify(intRes.contextData?.fetchErrors)}`);\n }\n await this.internalLog(\"INFO\", `Context data retrieved for ${tickersWithData.length} tickers. Failed/Skipped: ${intRes.suggestedTickers.length - tickersWithData.length}`);\n await this.internalLog(\"STEP\", `Initiating parallel quantitative analysis for ${tickersWithData.length} tickers.`);\n const quantPromises = tickersWithData.map(ticker => {\n const tData = intRes.contextData.tickerDataMap.get(ticker);\n if (tData) {\n const task: TaskInput<{ ticker: string; tickerData: TickerData }> = {\n mandateId: this.mandateId, taskId: `TSK-Quant-${ticker}-${Date.now()}`, senderRole: \"Orchestrator\", recipientRole: \"Responsible\", payload: { ticker, tickerData: tData },\n };\n return runQuantitativeAnalysisAgent(task, this.log);\n }\n return Promise.resolve(null as unknown as TaskOutput);\n }).filter(p => p !== null);\n const quantOuts = await Promise.all(quantPromises);\n intRes.quantitativeMetrics = quantOuts.map(o => o.payload);\n await this.internalLog(\"INFO\", \"Parallel Quantitative Analysis completed.\");\n quantOuts.forEach(o => this.auditAgentTaskResult(\"QuantitativeAnalysisAgent\", o));\n await this.internalLog(\"STEP\", \"Initiating parallel prediction generation.\");\n const predPromises: Promise>[] = [];\n const tickersForPred = intRes.quantitativeMetrics\n .filter(m => !(m as any).error && m.lastClose !== undefined && m.historicalVolatility !== undefined && m.historicalVolatility > 0 && !isNaN(m.historicalVolatility))\n .map(m => m.ticker);\n for (const metrics of intRes.quantitativeMetrics) {\n if (tickersForPred.includes(metrics.ticker)) {\n const task: TaskInput<{ ticker: string; metrics: TickerMetrics }> = {\n mandateId: this.mandateId, taskId: `TSK-Predict-${metrics.ticker}-${Date.now()}`, senderRole: \"Orchestrator\", recipientRole: \"Responsible\",\n payload: { ticker: metrics.ticker, metrics: metrics as TickerMetrics },\n };\n predPromises.push(runPredictionAgent(task, this.log));\n }\n }\n const predOuts = await Promise.all(predPromises);\n intRes.predictions = predOuts.map(o => o.payload);\n await this.internalLog(\"INFO\", `Parallel Prediction generation completed for ${predOuts.length} tickers.`);\n predOuts.forEach(o => this.auditAgentTaskResult(\"PredictionAgent\", o));\n await this.internalLog(\"STEP\", \"Initiating parallel interpretation generation.\");\n const interpPromises: Promise>[] = [];\n const tickersForInterp = intRes.quantitativeMetrics\n .filter(m => !(m as any).error)\n .map(m => m.ticker);\n for (const metrics of intRes.quantitativeMetrics) {\n if (tickersForInterp.includes(metrics.ticker)) {\n const ctx = { newsSentiment: intRes.contextData?.newsSentiment };\n const task: TaskInput<{ ticker: string; userGoals: UserGoals; metrics: Partial; context?: any }> = {\n mandateId: this.mandateId, taskId: `TSK-Interpret-${metrics.ticker}-${Date.now()}`, senderRole: \"Orchestrator\", recipientRole: \"Responsible\",\n payload: { ticker: metrics.ticker, userGoals: this.userGoals!, metrics, context: ctx },\n };\n interpPromises.push(runTickerInterpretationAgent(task, this.log));\n }\n }\n const interpOuts = await Promise.all(interpPromises);\n intRes.interpretations = interpOuts.map(o => o.payload);\n await this.internalLog(\"INFO\", `Parallel Interpretation generation completed for ${interpOuts.length} tickers.`);\n interpOuts.forEach(o => this.auditAgentTaskResult(\"TickerInterpretationAgent\", o));\n const allInterps = [...intRes.interpretations];\n const allPreds = [...intRes.predictions];\n for (const ticker of intRes.suggestedTickers) {\n const quantResult = intRes.quantitativeMetrics.find(m => m.ticker === ticker);\n const interpResult = allInterps.find(i => i.ticker === ticker);\n const predResult = allPreds.find(p => p.ticker === ticker);\n if (!quantResult || quantResult.error) {\n const errorMsg = `Skipped due to ${quantResult ? 'Quant failure: ' + quantResult.error : 'Data fetch failure: ' + (intRes.contextData?.fetchErrors?.[ticker] || 'Unknown reason')}`;\n if (!interpResult) {\n allInterps.push({ ticker, error: `Interpretation ${errorMsg}`, summary: \"\", indicatorInterpretation: \"\", volatilityAssessment: \"\", alignmentWithGoals: \"\", confidence: \"Low\", newsContextSentiment: \"N/A\" });\n }\n if (!predResult) {\n allPreds.push({ ticker, error: `Prediction ${errorMsg}`, predictionPaths: [], predictionPeriodDays: 60 });\n }\n } else {\n if (!tickersForPred.includes(ticker) && !predResult) {\n allPreds.push({ ticker, error: \"Prediction skipped: Invalid inputs from Quant analysis (e.g., non-positive volatility).\", predictionPaths: [], predictionPeriodDays: 60 });\n }\n if (!tickersForInterp.includes(ticker) && !interpResult) {\n allInterps.push({ ticker, error: \"Interpretation skipped: Quant analysis succeeded but lacked essential metrics for LLM.\", summary: \"\", indicatorInterpretation: \"\", volatilityAssessment: \"\", alignmentWithGoals: \"\", confidence: \"Low\", newsContextSentiment: \"N/A\" });\n }\n }\n }\n const synthTask: TaskInput = {\n mandateId: this.mandateId, taskId: `TSK-SynthChart-${Date.now()}`, senderRole: \"Orchestrator\", recipientRole: \"Responsible\",\n payload: {\n userGoals: this.userGoals,\n tickerInterpretations: allInterps,\n tickerPredictions: allPreds,\n historicalDataMap: intRes.contextData.tickerDataMap,\n pastPerformanceContext: \"N/A\",\n },\n };\n await this.internalLog(\"STEP\", `Requesting final synthesis and chart data preparation. Task ID: ${synthTask.taskId}`);\n const synthOut = await runSynthesisChartingDataAgent(synthTask, this.log);\n await this.auditAgentTaskResult(\"SynthesisChartingAgent\", synthOut);\n if (synthOut.error || !synthOut.payload || (synthOut.payload as any).error) {\n throw new Error(`Synthesis Failed: ${synthOut.error || (synthOut.payload as any).error || \"Invalid synthesis data returned\"}`);\n }\n finalRes = synthOut.payload as EnhancedActionSynthesis;\n await this.internalLog(\"SUCCESS\", \"Synthesis and Charting Preparation completed successfully.\");\n await this.internalLog(\"STEP\", \"Workflow Completed Successfully.\");\n } catch (error: any) {\n await this.internalLog(\"FATAL\", `Workflow terminated due to critical error: ${error.message}`, error);\n console.error(`[${this.mandateId}] Orchestrator CRITICAL FAILURE:`, error);\n workflowErr = \"Orchestrator workflow execution failed.\";\n errDetails = error.message;\n }\n if (finalRes && !workflowErr) {\n finalRes.intermediate_results = undefined;\n return { result: finalRes };\n } else {\n return {\n error: workflowErr || \"Workflow failed with unknown error.\",\n details: errDetails || \"No specific details available.\",\n intermediate_results: intRes,\n };\n }\n }\n getLogs(): any[] {\n return this.loggingAgent ? this.loggingAgent.getLogs().filter(log => log.mandateId === this.mandateId) : [];\n }\n}\n\nexport default async function(req: Request): Promise {\n const reqLogs: { timestamp: string; level: string; component: string; message: string; details?: string }[] = [];\n const log: LogFunction = (level, component, message, details) => {\n const ts = new Date().toISOString();\n let detStr: string | undefined;\n try { detStr = details !== undefined ? JSON.stringify(details) : undefined; }\n catch (e: any) { detStr = `[Unserializable: ${e.message}]`; }\n reqLogs.push({ timestamp: ts, level: level.toUpperCase(), component, message, details: detStr });\n console.log(`${ts} [${level.toUpperCase()}] [${component}] ${message}`, details ?? \"\");\n };\n let memoryAgent: SqliteMemoryAgent;\n let loggingAgent: MockLoggingAgent;\n let orchestrator: Orchestrator;\n try {\n loggingAgent = new MockLoggingAgent(log);\n memoryAgent = await SqliteMemoryAgent.create(log);\n orchestrator = new Orchestrator(log, memoryAgent, loggingAgent);\n } catch (initErr: any) {\n log(\"FATAL\", \"Handler\", `Core service initialization failed: ${initErr.message}`, initErr);\n const errResp = {\n error: \"Service Initialization Failed.\",\n details: `Failed to initialize core agents: ${initErr.message}`,\n debugLog: loggingAgent! ? loggingAgent!.getLogs() : reqLogs,\n };\n return new Response(JSON.stringify(errResp), {\n status: 500,\n headers: { \"Content-Type\": \"application/json\", \"Access-Control-Allow-Origin\": \"*\" },\n });\n }\n const url = new URL(req.url);\n const format = url.searchParams.get(\"format\");\n const action = url.searchParams.get(\"action\");\n if (format === \"json\" && action === \"analyze_goals\" && req.method === \"POST\") {\n log(\"INFO\", \"Handler\", `API Request Received: ${req.method} ${url.pathname}${url.search}`);\n let userGoals: UserGoals;\n try {\n const body = await req.text();\n if (!body) throw new Error(\"Request body is empty.\");\n userGoals = JSON.parse(body);\n if (!userGoals?.riskTolerance || !userGoals?.timeHorizon || !userGoals?.sectorsOfInterest) {\n throw new Error(\"Incomplete goals provided. Required: riskTolerance, timeHorizon, sectorsOfInterest.\");\n }\n log(\"INFO\", \"Handler\", `Successfully parsed user goals: Risk=${userGoals.riskTolerance}, Horizon=${userGoals.timeHorizon}, Sectors='${userGoals.sectorsOfInterest}'`);\n } catch (e: any) {\n log(\"ERROR\", \"Handler\", `Failed to parse user goals from request body: ${e.message}`);\n const errResp = {\n error: \"Invalid Request Body.\",\n details: `Failed to parse user goals JSON: ${e.message}`,\n debugLog: orchestrator.getLogs(),\n };\n return new Response(JSON.stringify(errResp), {\n status: 400,\n headers: { \"Content-Type\": \"application/json\", \"Access-Control-Allow-Origin\": \"*\" },\n });\n }\n let wfResult: any;\n try {\n wfResult = await orchestrator.runAnalysisWorkflow(userGoals);\n } catch (wfErr: any) {\n log(\"FATAL\", \"Handler\", `Unhandled orchestrator workflow error: ${wfErr.message}`, wfErr);\n wfResult = {\n error: \"Workflow Execution Failed Unexpectedly.\",\n details: wfErr.message,\n intermediate_results: (wfErr as any).intermediate_results,\n };\n }\n const finalPayload = {\n ...(wfResult.result\n ? { ...wfResult.result }\n : {\n error: wfResult.error || \"Workflow completed without a result.\",\n details: wfResult.details,\n ...(wfResult.error && { intermediate_results: wfResult.intermediate_results }),\n }),\n debugLog: orchestrator.getLogs(),\n };\n const status = wfResult.error ? 500 : 200;\n log(\"INFO\", \"Handler\", `Workflow execution finished. Returning status: ${status}`);\n return new Response(JSON.stringify(finalPayload), {\n status,\n headers: { \"Content-Type\": \"application/json\", \"Access-Control-Allow-Origin\": \"*\" },\n });\n } else if (req.method === \"GET\") {\n log(\"INFO\", \"Handler\", \"GET request received. Serving HTML user interface.\");\n try {\n const html = generateHtmlShell(null);\n return new Response(html, { status: 200, headers: { \"Content-Type\": \"text/html\" } });\n } catch (htmlErr: any) {\n log(\"ERROR\", \"Handler\", `Failed to generate HTML shell: ${htmlErr.message}`, htmlErr);\n return new Response(\"Internal Server Error: Failed to generate HTML.\", { status: 500 });\n }\n } else {\n log(\"WARN\", \"Handler\", `Unsupported request received: ${req.method} ${url.pathname}${url.search}`);\n const errResp = {\n error: \"Method or Action Not Allowed\",\n details: `Unsupported request. Use GET for HTML UI or POST /?action=analyze_goals&format=json to analyze.`,\n debugLog: orchestrator.getLogs(),\n };\n return new Response(JSON.stringify(errResp), {\n status: 405,\n headers: { \"Content-Type\": \"application/json\", \"Access-Control-Allow-Origin\": \"*\" },\n });\n }\n}","deleted","label",[99],"permalink","https://www.val.town/x/salon/Future/code/main.tsx","extension","actionData","errors"]