salmon-loop 0.3.1 → 0.4.1

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

@@ -8,6 +8,7 @@ import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
 import { SalmonError } from '../../types/errors.js';
 import { Phase } from '../../types/runtime.js';
 import { ensureInSandbox, isSafeRelativePath, normalizePath } from '../../utils/path.js';
+import { isRecord } from '../../utils/serialize.js';
 import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
 import { ContextValidator } from '../validation/ContextValidator.js';
 import { buildPhaseRequestEnvelope } from './request-assembly.js';
@@ -103,7 +104,11 @@ export const exploreCodebase = async (ctx) => {
                     // Intercept tools with READ intent
                     if (intent === 'READ' && result.status === 'ok') {
                         const output = result.output;
-                        const content = typeof output === 'string' ? output : output?.content;
+                        const content = typeof output === 'string'
+                            ? output
+                            : isRecord(output) && typeof output.content === 'string'
+                                ? output.content
+                                : undefined;
                         if (typeof content === 'string') {
                             try {
                                 // Attempt to parse arguments to get the file path
@@ -199,7 +204,9 @@ export const exploreCodebase = async (ctx) => {
     // Validation: Check for exploration consistency using ContextValidator on LOCAL audit
     const validation = ContextValidator.validateExploration(localAudit, capturedFiles.size);
     if (!validation.isValid) {
-        const msg = text.grizzco.validation[validation.errorCode] || validation.errorCode;
+        const validationMessages = text.grizzco.validation;
+        const raw = validation.errorCode ? validationMessages[validation.errorCode] : undefined;
+        const msg = typeof raw === 'string' ? raw : (validation.errorCode ?? 'unknown');
         ctx.emit({
             type: 'log',
             level: 'error',

package/dist/core/grizzco/steps/patch/prompt-input.js

@@ -5,9 +5,12 @@ import { Phase } from '../../../types/runtime.js';
 import { buildPhaseRequestEnvelope } from '../request-assembly.js';
 export async function buildPatchPromptInput(args) {
     const planStr = JSON.stringify(args.plan, null, 2);
-    const systemPrompt = await getPatchSystemPrompt(args.promptVisibleTools, {
+    const baseSystemPrompt = await getPatchSystemPrompt(args.promptVisibleTools, {
         plan: args.planRuntime,
     });
+    const systemPrompt = args.subAgentSystemPrompt
+        ? [baseSystemPrompt, args.subAgentSystemPrompt]
+        : baseSystemPrompt;
     const requestEnvelope = await buildPhaseRequestEnvelope({
         phase: args.phase ?? Phase.PATCH,
         defaultNamespace: 'patch',

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

@@ -95,6 +95,7 @@ export const generatePatch = async (ctx) => {
         artifactHints: ctx.artifactHints,
         replacementState: ctx.replacementState,
         toolCallingAudit: ctx.toolCallingAudit,
+        subAgentSystemPrompt: ctx.options.subAgentSystemPrompt,
     });
     const { cacheSurface, envelope, baseMessages } = patchPromptInput;
     const supportsStreaming = supportsLlmStreaming(ctx.options.llm, Phase.PATCH);

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/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/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/llm/ai-sdk/message-mapper.js

@@ -2,11 +2,12 @@ import { jsonSchema, tool } from 'ai';
 import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 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 {
@@ -46,9 +47,7 @@ function deepCloneJson(value, fallback) {
         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 +92,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';
@@ -143,7 +144,7 @@ export function toAiSdkMessages(messages) {
                     content = JSON.stringify(content);
                 }
                 return {
-                    role: m.role,
+                    role: 'assistant',
                     content: content,
                 };
             }
@@ -191,6 +192,7 @@ export function toAiSdkMessages(messages) {
             content: content,
         };
     });
+    return result;
 }
 export function toAiSdkToolSet(openAiTools, toolSpecs) {
     const tools = {};
@@ -199,12 +201,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 +219,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;

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' ||

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,7 +32,7 @@ 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;
@@ -39,7 +40,7 @@ function findNetworkCode(err) {
 function isAbortLikeError(err) {
     const unwrapped = unwrapRetryError(err);
     const name = unwrapped instanceof Error ? unwrapped.name : '';
-    const msg = String(unwrapped?.message ?? unwrapped).toLowerCase();
+    const msg = String((isRecord(unwrapped) ? unwrapped.message : undefined) ?? unwrapped).toLowerCase();
     return name === 'AbortError' || msg.includes('aborted');
 }
 export function classifyRetryableApiError(err) {
@@ -47,7 +48,8 @@ export function classifyRetryableApiError(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)

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,6 @@
 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;
@@ -88,9 +89,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 +124,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 +150,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,

package/dist/core/llm/output-policy.js

@@ -147,6 +147,14 @@ export function emitLlmStreamDelta(params) {
         timestamp,
     });
 }
+/**
+ * Clean up stream state without emitting end events.
+ * Call this when a stream errors and emitLlmStreamEnd won't be reached.
+ */
+export function cleanupLlmStream(streamId) {
+    STREAM_CANONICAL_EMITTERS.delete(streamId);
+    STREAM_SANITIZATION_STATE.delete(streamId);
+}
 export function emitLlmStreamEnd(params) {
     const { emit, policy, kind, step, streamId, finishReason } = params;
     if (!emit)

package/dist/core/llm/redact.js

@@ -1,3 +1,4 @@
+import { isRecord } from '../utils/serialize.js';
 const SECRET_KEY_REGEX = /(api[-_]?key|authorization|token|secret|password|cookie)/i;
 const STRING_SECRET_PATTERNS = [
     {
@@ -17,9 +18,6 @@ const STRING_SECRET_PATTERNS = [
         replacement: '$1=[REDACTED]',
     },
 ];
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
 function truncate(value, max = 500) {
     if (value.length <= max)
         return value;

package/dist/core/llm/sub-agent-factory.js

@@ -0,0 +1,48 @@
+import { AiSdkLLM } from './ai-sdk.js';
+import { StubLLM } from './openai.js';
+/**
+ * Model alias → concrete model ID mapping.
+ *
+ * These follow the Anthropic model naming conventions.
+ * Providers that don't support these IDs will fall back to StubLLM.
+ */
+const MODEL_ALIAS_MAP = {
+    haiku: 'claude-3-5-haiku-20241022',
+    sonnet: 'claude-sonnet-4-20250514',
+    opus: 'claude-opus-4-20250514',
+};
+function resolveModelId(alias) {
+    return MODEL_ALIAS_MAP[alias] ?? alias;
+}
+/**
+ * Create a SubAgentLlmFactory that produces model-specific LLM instances
+ * from a base provider configuration.
+ *
+ * The factory reuses the parent provider's connection settings (API key,
+ * base URL, headers) and only overrides the model ID.
+ */
+export function createSubAgentLlmFactory(baseProvider) {
+    return (modelAlias) => {
+        const modelId = resolveModelId(modelAlias);
+        if (baseProvider.type === 'openai-compatible' || baseProvider.type === 'openai') {
+            const clientPackage = baseProvider.clientPackage === '@ai-sdk/openai'
+                ? '@ai-sdk/openai'
+                : '@ai-sdk/openai-compatible';
+            if (!baseProvider.api.apiKey) {
+                return new StubLLM();
+            }
+            return new AiSdkLLM({
+                clientPackage,
+                providerName: baseProvider.id,
+                apiKey: baseProvider.api.apiKey,
+                baseUrl: baseProvider.api.baseUrl,
+                modelId,
+                headers: baseProvider.api.headers,
+                timeoutMs: baseProvider.api.timeoutMs,
+                capabilities: baseProvider.capabilities,
+            });
+        }
+        return undefined;
+    };
+}
+//# sourceMappingURL=sub-agent-factory.js.map

package/dist/core/llm/tool-calling-stub.js

@@ -0,0 +1,48 @@
+/**
+ * ToolCallingStubLLM — A deterministic LLM stub that emits tool_calls
+ * to drive the chatWithTools loop in tests and evaluation harnesses.
+ *
+ * Unlike StubLLM (toolCalling: false, no tool_calls), this stub populates
+ * the assistant.tool_calls field so that chatWithTools executes tools and
+ * continues the loop.
+ */
+export class ToolCallingStubLLM {
+    toolCalling = true;
+    turns;
+    callCount = 0;
+    constructor(turns) {
+        this.turns = turns;
+    }
+    getCapabilities() {
+        return {
+            toolCalling: true,
+            responseFormatJsonObject: false,
+            streaming: false,
+        };
+    }
+    async chat(_messages) {
+        const idx = this.callCount;
+        const turn = this.turns[idx] ?? { content: '[stub: no more turns]' };
+        this.callCount++;
+        return {
+            role: 'assistant',
+            content: turn.content ?? '',
+            tool_calls: turn.toolCalls,
+        };
+    }
+    getCallCount() {
+        return this.callCount;
+    }
+    async createPlan(_context, instruction) {
+        return {
+            goal: `Stub plan for: ${instruction}`,
+            files: [],
+            changes: [],
+            verify: 'echo ok',
+        };
+    }
+    async createPatch() {
+        return '';
+    }
+}
+//# sourceMappingURL=tool-calling-stub.js.map

package/dist/core/llm/utils.js

@@ -13,21 +13,32 @@ export function formatContextForPrompt(context, options = {}) {
 export function parsePlanFromLLMContent(content) {
     const trimmed = String(content ?? '').trim();
     if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
-        throw new Error(text.llm.planInvalidJson);
+        const preview = trimmed.slice(0, 80);
+        throw new Error(`${text.llm.planInvalidJson} — Content must start with { and end with }. Got: ${preview}${trimmed.length > 80 ? '…' : ''}`);
     }
     let parsed;
     try {
         parsed = JSON.parse(trimmed);
     }
-    catch {
-        throw new Error(text.llm.planInvalidJson);
+    catch (jsonError) {
+        const errorMsg = jsonError instanceof Error ? jsonError.message : String(jsonError);
+        throw new Error(`${text.llm.planInvalidJson} — JSON parse error: ${errorMsg}`);
     }
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(text.llm.planInvalidJson);
+        throw new Error(`${text.llm.planInvalidJson} — Expected object, got ${Array.isArray(parsed) ? 'array' : typeof parsed}`);
     }
     const plan = parsed;
-    if (!plan.goal || !Array.isArray(plan.files) || !Array.isArray(plan.changes) || !plan.verify) {
-        throw new Error(text.llm.planInvalid);
+    const missingKeys = [];
+    if (!plan.goal)
+        missingKeys.push('goal');
+    if (!Array.isArray(plan.files))
+        missingKeys.push('files (must be array)');
+    if (!Array.isArray(plan.changes))
+        missingKeys.push('changes (must be array)');
+    if (!plan.verify)
+        missingKeys.push('verify');
+    if (missingKeys.length > 0) {
+        throw new Error(`${text.llm.planInvalid} — Missing or invalid keys: ${missingKeys.join(', ')}`);
     }
     return plan;
 }