salmon-loop 0.3.2 → 0.5.0

package/dist/core/grizzco/steps/plan.js

@@ -133,7 +133,10 @@ export const generatePlan = async (ctx) => {
         flowMode: ctx.mode,
         runtime: toolVisibility,
     });
-    const systemPrompt = await getPlanSystemPrompt(promptVisibleTools, toolVisibility);
+    const baseSystemPrompt = await getPlanSystemPrompt(promptVisibleTools, toolVisibility);
+    const systemPrompt = ctx.options.subAgentSystemPrompt
+        ? [baseSystemPrompt, ctx.options.subAgentSystemPrompt]
+        : baseSystemPrompt;
     const requestEnvelope = await buildPhaseRequestEnvelope({
         phase: Phase.PLAN,
         defaultNamespace: 'plan',
@@ -192,62 +195,68 @@ export const generatePlan = async (ctx) => {
     });
     const content = response.content;
     let finalContent = content || '';
+    // Codex-style self-healing: if plan JSON parsing fails, send the error back to the LLM
+    // and let it self-correct. Try up to MAX_REPAIR_ATTEMPTS times.
+    const MAX_REPAIR_ATTEMPTS = 2;
     let plan;
-    try {
-        if (!finalContent) {
-            throw new Error(text.llm.planEmpty);
-        }
-        plan = parsePlanFromLLMContent(finalContent);
-    }
-    catch (e) {
-        recordPlanRepairAttempt({
-            reason: sanitizeError(e),
-            badContentLength: finalContent.length,
-        });
-        let repaired;
-        try {
-            repaired = await repairToJsonObject({
-                llm: ctx.options.llm,
-                baseMessages,
-                chatOptions: { signal: ctx.options.signal },
-                badContent: finalContent,
-                reason: sanitizeError(e),
-            });
-        }
-        catch (repairError) {
-            recordPlanRepairResult({
-                ok: false,
-                contentLength: 0,
-                error: sanitizeError(repairError).slice(0, 400),
-            });
-            throw new Error(text.llm.planParseFailed(finalContent, sanitizeError(repairError)));
-        }
-        finalContent = repaired.content || '';
-        emitLlmOutput({
-            emit: ctx.emit,
-            policy: ctx.options.llmOutput,
-            kind: 'plan',
-            step: 'PLAN',
-            content: finalContent,
-        });
+    for (let attempt = 0; attempt <= MAX_REPAIR_ATTEMPTS; attempt++) {
         try {
-            if (!finalContent)
+            if (!finalContent) {
                 throw new Error(text.llm.planEmpty);
+            }
             plan = parsePlanFromLLMContent(finalContent);
+            break; // Success
         }
-        catch (e2) {
-            recordPlanRepairResult({
-                ok: false,
-                contentLength: finalContent.length,
-                error: sanitizeError(e2).slice(0, 400),
+        catch (parseError) {
+            // On last attempt, throw
+            if (attempt >= MAX_REPAIR_ATTEMPTS) {
+                recordPlanRepairResult({
+                    ok: false,
+                    contentLength: finalContent.length,
+                    error: sanitizeError(parseError).slice(0, 400),
+                });
+                throw new Error(text.llm.planParseFailed(finalContent, sanitizeError(parseError)));
+            }
+            // Repair attempt: send error feedback to LLM and let it self-correct
+            recordPlanRepairAttempt({
+                reason: sanitizeError(parseError),
+                badContentLength: finalContent.length,
+            });
+            let repaired;
+            try {
+                repaired = await repairToJsonObject({
+                    llm: ctx.options.llm,
+                    baseMessages,
+                    chatOptions: { signal: ctx.options.signal },
+                    badContent: finalContent,
+                    reason: sanitizeError(parseError),
+                });
+            }
+            catch (repairError) {
+                recordPlanRepairResult({
+                    ok: false,
+                    contentLength: 0,
+                    error: sanitizeError(repairError).slice(0, 400),
+                });
+                throw new Error(text.llm.planParseFailed(finalContent, sanitizeError(repairError)));
+            }
+            finalContent = repaired.content || '';
+            emitLlmOutput({
+                emit: ctx.emit,
+                policy: ctx.options.llmOutput,
+                kind: 'plan',
+                step: 'PLAN',
+                content: finalContent,
             });
-            throw new Error(text.llm.planParseFailed(finalContent, sanitizeError(e2)));
         }
-        recordPlanRepairResult({
-            ok: true,
-            contentLength: finalContent.length,
-        });
     }
+    if (!plan) {
+        throw new Error(text.llm.planParseFailed(finalContent, 'Plan was not parsed successfully'));
+    }
+    recordPlanRepairResult({
+        ok: true,
+        contentLength: finalContent.length,
+    });
     ctx.emit({
         type: 'log',
         level: 'debug',

package/dist/core/grizzco/steps/research.js

@@ -2,6 +2,7 @@ import { text } from '../../../locales/index.js';
 import { supportsLlmStreaming } from '../../llm/capabilities.js';
 import { emitLlmOutput } from '../../llm/output-policy.js';
 import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { getLogger } from '../../observability/logger.js';
 import { getResearchPrompt, getResearchSystemPrompt } from '../../prompts/runtime.js';
 import { SessionReplacementPreviewProvider } from '../../session/replacement-preview-provider.js';
 import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
@@ -50,7 +51,8 @@ function parseResearchResponse(content, fallbackSources) {
     try {
         parsed = JSON.parse(content);
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[Research] Failed to parse research response as JSON: ${error instanceof Error ? error.message : String(error)}`);
         parsed = undefined;
     }
     const researchText = String(parsed?.researchText ?? content ?? text.grizzco.research.empty ?? '');

package/dist/core/grizzco/steps/tool-runtime.js

@@ -14,6 +14,9 @@ export function buildPhaseToolRuntimeContext(ctx, phase, cacheSurface) {
         agentKind: ctx.options.agentKind ?? 'primary',
         languagePlugins: ctx.options.languagePlugins,
         subAgentController: ctx.options.subAgentController,
+        llmFactory: ctx.options.llmFactory,
+        onSubAgentComplete: ctx.options.onSubAgentComplete,
+        agentId: ctx.options.agentId,
         phase,
         contextSnapshot: {
             conversationContext: ctx.options.conversationContext,

package/dist/core/grizzco/steps/verify.js

@@ -1,5 +1,6 @@
 import { text } from '../../../locales/index.js';
 import { collectBudgetMetrics, evaluateBudgetAlert, getGlobalAdjuster, recordBudgetAlert, } from '../../context/budget/integration.js';
+import { getEffectivenessTracker } from '../../context/effectiveness/tracker.js';
 import { recordAuditEvent } from '../../observability/audit-trail.js';
 import { executeVerifyForWorkspace } from './verify-shared.js';
 function extractCommandProgram(command) {
@@ -32,7 +33,12 @@ export const runVerify = async (ctx) => {
         scope: 'session',
         phase: 'VERIFY',
     });
-    // Collect budget metrics after verification
+    // Collect budget metrics and effectiveness data after verification
+    const effectivenessTracker = getEffectivenessTracker();
+    effectivenessTracker.recordExecution(verifyResult.ok, 0);
+    if (!verifyResult.ok) {
+        effectivenessTracker.recordFailure('missing_context', `Verification failed: ${verifyResult.output?.slice(0, 200) ?? 'unknown'}`);
+    }
     if (ctx.contextResult) {
         const metrics = collectBudgetMetrics({
             contextResult: ctx.contextResult,

package/dist/core/grizzco/validation/AstValidationService.js

@@ -4,6 +4,7 @@ import path from 'path';
 import { readFile, rm } from '../../adapters/fs/node-fs.js';
 import { GitAdapter } from '../../adapters/git/git-adapter.js';
 import { AstParser } from '../../ast/index.js';
+import { getLogger } from '../../observability/logger.js';
 import { convertDiffToShadowOperations } from '../../patch/diff.js';
 import { tryGetPluginRegistry } from '../../plugin/registry.js';
 import { OpType } from '../domain/grizzco-types.js';
@@ -70,7 +71,8 @@ async function defaultBuildProposedSource(workPath, operation) {
             return null;
         return showResult.stdout.toString('utf8');
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[AstValidationService] Failed to build proposed source for "${operation.path}": ${error instanceof Error ? error.message : String(error)}`);
         return null;
     }
     finally {

package/dist/core/grizzco/workers/strata-sync-worker.js

@@ -44,7 +44,8 @@ export class StrataSyncWorker {
             const aiContent = op.content;
             // Invoke legacy merge logic
             // private method: async mergeFileContents(repoPath, base, user, ai, options?)
-            const result = await engine.mergeFileContents(this.git.repoPath, baseContent, userContent, aiContent);
+            const engineMethods = engine;
+            const result = await engineMethods.mergeFileContents(this.git.repoPath, baseContent, userContent, aiContent);
             return {
                 path: state.path,
                 success: !result.conflict,

package/dist/core/history/input-history.js

@@ -1,5 +1,6 @@
 import { join } from 'path';
 import { FileAdapter } from '../adapters/fs/index.js';
+import { getLogger } from '../observability/logger.js';
 /**
  * Manages persistence of user input history isolated by Session.
  * Storage path: .salmonloop/ui-history/{sessionId}.json
@@ -26,7 +27,8 @@ export class InputHistoryManager {
             const data = await this.fileAdapter.readFile(filePath);
             return JSON.parse(data);
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[InputHistory] Failed to load history for session "${sessionId}": ${error instanceof Error ? error.message : String(error)}`);
             return [];
         }
     }

package/dist/core/intent/chat-intent.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { getLogger } from '../observability/logger.js';
 const LlmDecisionSchema = z
     .object({
     intent: z.enum(['answer', 'review', 'patch', 'debug', 'research']),
@@ -165,8 +166,9 @@ async function routeByLlm(input, options) {
         try {
             return JSON.parse(candidate);
         }
-        catch {
+        catch (error) {
             // Best-effort: extract the first JSON object from mixed output.
+            getLogger().debug(`[ChatIntent] Primary JSON parse failed, attempting extraction: ${error instanceof Error ? error.message : String(error)}`);
             const start = candidate.indexOf('{');
             const end = candidate.lastIndexOf('}');
             if (start >= 0 && end > start) {

package/dist/core/llm/ai-sdk/message-mapper.js

@@ -1,12 +1,14 @@
 import { jsonSchema, tool } from 'ai';
 import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
+import { getLogger } from '../../observability/logger.js';
 import { toolToOpenAI } from '../../tools/mapper.js';
+import { isRecord } from '../../utils/serialize.js';
 function formatOutputSchema(schema) {
     if (!schema)
         return 'any (dynamic)';
-    const def = schema._def;
-    if (def?.description) {
+    const def = schema.def;
+    if (typeof def?.description === 'string') {
         return def.description;
     }
     try {
@@ -19,8 +21,9 @@ function formatOutputSchema(schema) {
             return JSON.stringify(cleanSchema);
         }
     }
-    catch {
+    catch (error) {
         // Fallback to generic description for invalid/unsupported schema.
+        getLogger().debug(`[MessageMapper] Failed to format output schema to JSON: ${error instanceof Error ? error.message : String(error)}`);
     }
     return 'complex object';
 }
@@ -30,8 +33,8 @@ function safeParseJsonObject(textValue) {
         if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
             return parsed;
     }
-    catch {
-        // ignored
+    catch (error) {
+        getLogger().debug(`[MessageMapper] Failed to parse JSON object: ${error instanceof Error ? error.message : String(error)}`);
     }
     return {};
 }
@@ -42,13 +45,12 @@ function deepCloneJson(value, fallback) {
             return fallback;
         return JSON.parse(serialized);
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[MessageMapper] deepCloneJson failed: ${error instanceof Error ? error.message : String(error)}`);
         return fallback;
     }
 }
-function isObjectRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
+const isObjectRecord = isRecord;
 export function extractUsageFromAiSdkResult(result) {
     if (!isObjectRecord(result))
         return null;
@@ -93,7 +95,9 @@ function toAiSdkToolResultOutput(value) {
     };
 }
 export function toAiSdkMessages(messages) {
-    return messages.map((m) => {
+    // Each branch returns a structurally valid ModelMessage; the union is too
+    // complex for TS to verify inline, so we assert the array at the end.
+    const result = messages.map((m) => {
         if (m.role === 'tool') {
             const toolCallId = m.tool_call_id || 'unknown';
             const toolName = m.name || 'unknown';
@@ -101,7 +105,8 @@ export function toAiSdkMessages(messages) {
             try {
                 parsedContent = JSON.parse(m.content);
             }
-            catch {
+            catch (error) {
+                getLogger().debug(`[MessageMapper] Failed to parse tool message content as JSON: ${error instanceof Error ? error.message : String(error)}`);
                 parsedContent = m.content;
             }
             if (isToolApprovalResponse(parsedContent)) {
@@ -143,7 +148,7 @@ export function toAiSdkMessages(messages) {
                     content = JSON.stringify(content);
                 }
                 return {
-                    role: m.role,
+                    role: 'assistant',
                     content: content,
                 };
             }
@@ -191,6 +196,7 @@ export function toAiSdkMessages(messages) {
             content: content,
         };
     });
+    return result;
 }
 export function toAiSdkToolSet(openAiTools, toolSpecs) {
     const tools = {};
@@ -199,12 +205,14 @@ export function toAiSdkToolSet(openAiTools, toolSpecs) {
             const outputDesc = formatOutputSchema(spec.outputSchema);
             const description = `${spec.description}\n\nReturns: ${outputDesc}`;
             const openAiDef = toolToOpenAI(spec);
-            const parameters = jsonSchema(openAiDef.function?.parameters || {});
-            tools[spec.name] = tool({
-                description,
-                parameters,
-            });
-            tools[spec.name].outputSchema = spec.outputSchema || z.any();
+            const parameters = jsonSchema(openAiDef.function?.parameters ?? {});
+            tools[spec.name] = {
+                ...tool({
+                    description,
+                    inputSchema: parameters,
+                }),
+                outputSchema: spec.outputSchema ?? z.any(),
+            };
         }
     }
     if (Array.isArray(openAiTools)) {
@@ -215,11 +223,13 @@ export function toAiSdkToolSet(openAiTools, toolSpecs) {
                 continue;
             const rawDesc = typeof fn?.description === 'string' ? fn.description : '';
             const description = `${rawDesc}\n\nReturns: any (dynamic)`.trim();
-            tools[name] = tool({
-                description,
-                parameters: jsonSchema(fn?.parameters || { type: 'object', properties: {} }),
-            });
-            tools[name].outputSchema = z.any();
+            tools[name] = {
+                ...tool({
+                    description,
+                    inputSchema: jsonSchema(fn?.parameters ?? { type: 'object', properties: {} }),
+                }),
+                outputSchema: z.any(),
+            };
         }
     }
     return Object.keys(tools).length > 0 ? tools : undefined;
@@ -241,14 +251,15 @@ export function toOpenAiToolCalls(toolCalls) {
                     try {
                         parsed = JSON.parse(nested);
                     }
-                    catch {
-                        // ignored
+                    catch (error) {
+                        getLogger().debug(`[MessageMapper] Failed to parse nested JSON string: ${error instanceof Error ? error.message : String(error)}`);
                     }
                 }
             }
             return parsed;
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[MessageMapper] Failed to normalize tool input JSON: ${error instanceof Error ? error.message : String(error)}`);
             return raw;
         }
     };

package/dist/core/llm/ai-sdk/request-params.js

@@ -1,6 +1,4 @@
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
+import { isRecord } from '../../utils/serialize.js';
 function isJsonValue(value) {
     if (value === null ||
         typeof value === 'string' ||
@@ -115,9 +113,7 @@ export function buildAiSdkRequestParams(params) {
         responseFormat: resolveResponseFormat(params.options),
         toolChoice: (params.options.toolChoice === 'none'
             ? 'none'
-            : params.tools
-                ? 'auto'
-                : undefined),
+            : (params.options.toolChoice ?? (params.tools ? 'auto' : undefined))),
         providerOptions: mergeProviderOptions({
             providerOptions: params.options.providerOptions,
             providerHints: params.options.providerHints,

package/dist/core/llm/ai-sdk/result-mapper.js

@@ -1,32 +1,38 @@
+import { isRecord } from '../../utils/serialize.js';
 import { mapAiSdkStreamPartToChunk } from '../stream-utils.js';
 import { toOpenAiToolCalls } from './message-mapper.js';
 function extractReasoningContent(result) {
-    if (typeof result?.reasoningText === 'string' && result.reasoningText.length > 0) {
+    if (!isRecord(result))
+        return undefined;
+    if (typeof result.reasoningText === 'string' && result.reasoningText.length > 0) {
         return result.reasoningText;
     }
-    const reasoningParts = Array.isArray(result?.reasoning)
+    const reasoningParts = Array.isArray(result.reasoning)
         ? result.reasoning
-        : Array.isArray(result?.content)
-            ? result.content.filter((part) => part?.type === 'reasoning')
+        : Array.isArray(result.content)
+            ? result.content.filter((part) => isRecord(part) && part.type === 'reasoning')
             : [];
     const text = reasoningParts
-        .map((part) => (typeof part?.text === 'string' ? part.text : ''))
+        .map((part) => (typeof part.text === 'string' ? part.text : ''))
         .join('');
     return text.length > 0 ? text : undefined;
 }
 export function mapAiSdkGenerateResultToMessage(result) {
     const reasoningContent = extractReasoningContent(result);
+    const r = isRecord(result) ? result : {};
     return {
         role: 'assistant',
-        content: result?.text || '',
+        content: typeof r.text === 'string' ? r.text : '',
         ...(reasoningContent ? { reasoning_content: reasoningContent } : {}),
-        tool_calls: toOpenAiToolCalls(result?.toolCalls),
+        tool_calls: toOpenAiToolCalls(Array.isArray(r.toolCalls)
+            ? r.toolCalls
+            : undefined),
     };
 }
 export async function* mapAiSdkStreamResultToChunks(fullStream) {
     let doneEmitted = false;
     for await (const part of fullStream) {
-        if (!part)
+        if (!part || !isRecord(part))
             continue;
         if (part.type === 'error')
             throw part.error;

package/dist/core/llm/ai-sdk/retry-classifier.js

@@ -1,3 +1,4 @@
+import { isRecord } from '../../utils/serialize.js';
 function unwrapRetryError(err) {
     if (!err || typeof err !== 'object')
         return err;
@@ -15,7 +16,7 @@ function findStatusCode(err) {
     if (typeof direct === 'number' && Number.isFinite(direct))
         return direct;
     const response = obj.response;
-    if (response && typeof response === 'object') {
+    if (isRecord(response)) {
         const status = response.status;
         if (typeof status === 'number' && Number.isFinite(status))
             return status;
@@ -31,23 +32,25 @@ function findNetworkCode(err) {
     if (typeof code === 'string')
         return code;
     const cause = obj.cause;
-    if (cause && typeof cause === 'object' && typeof cause.code === 'string') {
+    if (isRecord(cause) && typeof cause.code === 'string') {
         return cause.code;
     }
     return undefined;
 }
-function isAbortLikeError(err) {
+function isUserAbortError(err) {
     const unwrapped = unwrapRetryError(err);
     const name = unwrapped instanceof Error ? unwrapped.name : '';
-    const msg = String(unwrapped?.message ?? unwrapped).toLowerCase();
-    return name === 'AbortError' || msg.includes('aborted');
+    // Only treat as user abort if the error name is AbortError (from AbortController).
+    // Provider-side "aborted" messages are transient and should be retried.
+    return name === 'AbortError';
 }
 export function classifyRetryableApiError(err) {
-    if (isAbortLikeError(err))
+    if (isUserAbortError(err))
         return { retryable: false, reason: 'aborted' };
     const statusCode = findStatusCode(err);
     const networkCode = findNetworkCode(err);
-    const msg = String(unwrapRetryError(err)?.message ?? err).toLowerCase();
+    const unwrapped = unwrapRetryError(err);
+    const msg = String((isRecord(unwrapped) ? unwrapped.message : undefined) ?? err).toLowerCase();
     if (statusCode === 408)
         return { retryable: true, reason: 'timeout', statusCode, networkCode };
     if (statusCode === 429)
@@ -67,6 +70,13 @@ export function classifyRetryableApiError(err) {
     if (msg.includes('overloaded')) {
         return { retryable: true, reason: 'overloaded', statusCode, networkCode };
     }
+    // Provider-side aborts and unexpected errors are transient — retry them.
+    if (msg.includes('aborted')) {
+        return { retryable: true, reason: 'provider_abort', statusCode, networkCode };
+    }
+    if (msg.includes('unexpected error')) {
+        return { retryable: true, reason: 'unexpected', statusCode, networkCode };
+    }
     if (typeof networkCode === 'string') {
         const normalized = networkCode.toUpperCase();
         if (normalized === 'ECONNRESET' ||

package/dist/core/llm/ai-sdk/retry-executor.js

@@ -2,7 +2,7 @@ import { toLlmError } from '../errors.js';
 import { withRetry, withStreamRetry } from '../retry-utils.js';
 import { createAiSdkRetryLogger, isRetryableAiSdkError } from './request-runtime.js';
 const DEFAULT_AI_SDK_RETRY_OPTIONS = {
-    maxRetries: 2,
+    maxRetries: 3,
     jitterRatio: 0.2,
 };
 export async function executeWithAiSdkRetry(params) {

package/dist/core/llm/contracts/repair.js

@@ -10,18 +10,26 @@ function truncateForPrompt(text, maxChars) {
 export async function repairToJsonObject(args) {
     const { llm, baseMessages, chatOptions, badContent, reason } = args;
     const prompt = [
-        'Your previous response did not satisfy the contract.',
-        `Reason: ${reason}`,
+        'Your previous response failed to parse as a valid plan JSON object.',
         '',
-        'Return exactly one JSON object and nothing else.',
-        'The first non-whitespace character must be {.',
-        'The last non-whitespace character must be }.',
+        `Specific error: ${reason}`,
         '',
-        'Forbidden: Markdown fences, commentary, labels, multiple objects, or any leading/trailing text.',
+        'To fix this, return EXACTLY one JSON object with these keys:',
+        '  - goal: string (what this plan accomplishes)',
+        '  - files: string[] (list of file paths to modify)',
+        '  - changes: string[] (list of change descriptions)',
+        '  - verify: string (command to verify the changes)',
         '',
-        'The JSON object MUST include keys: goal, files, changes, verify.',
+        'Example of a valid response:',
+        '{"goal":"Add error handling","files":["src/index.ts"],"changes":["Add try-catch to main"],"verify":"npm test"}',
         '',
-        'Previous response (truncated):',
+        'Rules:',
+        '- The first non-whitespace character must be {',
+        '- The last non-whitespace character must be }',
+        '- No markdown fences, commentary, or leading/trailing text',
+        '- All four keys (goal, files, changes, verify) are REQUIRED',
+        '',
+        'Your previous invalid response (truncated):',
         truncateForPrompt(badContent, Math.min(1200, Math.max(400, LIMITS.maxContextChars / 100))),
     ].join('\n');
     return llm.chat([

package/dist/core/llm/errors.js

@@ -1,5 +1,7 @@
+import { getLogger } from '../observability/logger.js';
 import { SalmonError } from '../types/errors.js';
 import { sanitizeErrorMessage } from '../utils/sanitizer.js';
+import { isRecord } from '../utils/serialize.js';
 export class LlmError extends SalmonError {
     llmCode;
     meta;
@@ -44,8 +46,8 @@ function extractProviderDetails(err) {
                     details.providerMessage = sanitizeError(parsed.message);
                 }
             }
-            catch {
-                // ignore
+            catch (error) {
+                getLogger().debug(`[LlmErrors] Failed to parse responseBody as JSON: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
         else if (candidate.responseBody) {
@@ -72,8 +74,8 @@ function extractProviderDetails(err) {
                         details.providerMessage = sanitizeError(parsed.error.message);
                     }
                 }
-                catch {
-                    // ignore
+                catch (error) {
+                    getLogger().debug(`[LlmErrors] Failed to parse embedded JSON in message: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
         }
@@ -88,9 +90,8 @@ function extractNetworkCode(err) {
     if (typeof direct === 'string' && direct.trim())
         return direct;
     const cause = candidate.cause;
-    if (cause && typeof cause === 'object' && typeof cause.code === 'string') {
-        const code = String(cause.code);
-        return code.trim() ? code : undefined;
+    if (isRecord(cause) && typeof cause.code === 'string') {
+        return cause.code.trim() || undefined;
     }
     return undefined;
 }
@@ -124,19 +125,20 @@ export function sanitizeError(err) {
     return sanitizeErrorMessage(err);
 }
 export function toLlmError(err, provider) {
+    const errObj = isRecord(err) ? err : null;
     let name = err instanceof Error
         ? err.name
-        : typeof err?.name === 'string'
-            ? String(err.name)
+        : typeof errObj?.name === 'string'
+            ? errObj.name
             : 'UnknownError';
     let message = err instanceof Error
         ? err.message
-        : typeof err?.message === 'string'
-            ? String(err.message)
+        : typeof errObj?.message === 'string'
+            ? errObj.message
             : String(err);
     // Unwrap RetryError to get the last error's message if available
-    if (name === 'AI_RetryError' || err?.lastError) {
-        const lastError = err.lastError;
+    if (name === 'AI_RetryError' || errObj?.lastError) {
+        const lastError = errObj?.lastError;
         // Update the error reference so subsequent checks work on the actual cause
         err = lastError;
         if (lastError instanceof Error) {
@@ -149,7 +151,9 @@ export function toLlmError(err, provider) {
         name === 'ZodError' ||
         name.includes('TypeValidationError') ||
         message.includes('TypeValidationError') ||
-        err?.[Symbol.for('vercel.ai.error.AI_TypeValidationError')]) {
+        (err != null &&
+            typeof err === 'object' &&
+            Symbol.for('vercel.ai.error.AI_TypeValidationError') in err)) {
         return new LlmError('LLM validation failed', 'LLM_VALIDATION_FAILED', {
             provider,
             causeName: name,