salmon-loop 0.2.13 → 0.2.16

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

@@ -1,59 +1,101 @@
 import { randomUUID } from 'crypto';
-import { LIMITS } from '../config/limits.js';
-import { getPatchPrompt, getPlanPrompt } from '../prompts/runtime.js';
 import { executeAiSdkChatRequest, executeAiSdkChatStreamRequest } from './ai-sdk/chat-executor.js';
+import { HIGH_LEVEL_PHASE_SPECS, } from './ai-sdk/high-level-phase-specs.js';
 import { toAiSdkMessages, toAiSdkToolSet } from './ai-sdk/message-mapper.js';
 import { withAuditObservationName } from './ai-sdk/observation-context.js';
-import { createAiSdkChatModel, resolveAiSdkModelId } from './ai-sdk/provider-factory.js';
-import { wrapPlanEmpty, sanitizeError, LlmError } from './errors.js';
-import { extractUnifiedDiffFromLLMContent, formatContextForPrompt, parsePlanFromLLMContent, } from './utils.js';
+import { createAiSdkChatModel, resolveAiSdkModelId, resolveAiSdkProviderOptionsKey, } from './ai-sdk/provider-factory.js';
+import { repairToJsonObject } from './contracts/repair.js';
+import { buildSharedRequestEnvelope } from './shared-request-assembly.js';
+import { formatContextForPrompt } from './utils.js';
 export class AiSdkLLM {
     cfg;
     model;
     modelId;
+    providerOptionsKey;
     timeoutMs;
     constructor(cfg) {
         this.cfg = cfg;
         this.modelId = resolveAiSdkModelId(cfg.modelId);
+        this.providerOptionsKey = resolveAiSdkProviderOptionsKey(cfg);
         this.timeoutMs = cfg.timeoutMs;
         this.model = createAiSdkChatModel(cfg, this.modelId);
     }
     getModelId() {
         return this.modelId;
     }
-    getCapabilities() {
+    getCapabilities(_options) {
         return {
             toolCalling: true,
             responseFormatJsonObject: true,
             streaming: true,
+            ...this.cfg.capabilities,
         };
     }
+    applyCapabilityOptions(options = {}) {
+        const capabilities = this.getCapabilities({ phase: options.phase });
+        const requestOptions = {
+            ...options,
+            responseFormatJsonObjectSupported: capabilities.responseFormatJsonObject !== false,
+        };
+        if (capabilities.toolCalling === false) {
+            requestOptions.tools = undefined;
+            requestOptions.toolSpecs = undefined;
+            requestOptions.toolChoice = 'none';
+        }
+        return requestOptions;
+    }
+    async *chatStreamFromChat(messages, options = {}) {
+        const response = await this.chat(messages, options);
+        if (response.reasoning_content) {
+            yield {
+                role: 'assistant',
+                source: 'synthesized',
+                reasoningDelta: response.reasoning_content,
+            };
+        }
+        if (response.content) {
+            yield { role: 'assistant', source: 'synthesized', contentDelta: response.content };
+        }
+        if (Array.isArray(response.tool_calls) && response.tool_calls.length > 0) {
+            yield { role: 'assistant', source: 'synthesized', tool_calls: response.tool_calls };
+        }
+        yield { role: 'assistant', source: 'synthesized', done: true, finishReason: 'stop' };
+    }
     async chat(messages, options = {}) {
         const aiMessages = toAiSdkMessages(messages);
-        const tools = toAiSdkToolSet(options.tools, options.toolSpecs);
+        const requestOptions = this.applyCapabilityOptions(options);
+        const tools = toAiSdkToolSet(requestOptions.tools, requestOptions.toolSpecs);
         return executeAiSdkChatRequest({
             model: this.model,
             modelId: this.modelId,
+            providerOptionsKey: this.providerOptionsKey,
             timeoutMs: this.timeoutMs,
             langfuseEnabled: Boolean(this.cfg.langfuseEnabled),
             requestId: randomUUID(),
             messages: aiMessages,
             tools,
-            options,
+            options: requestOptions,
         });
     }
     async *chatStream(messages, options = {}) {
+        const requestOptions = this.applyCapabilityOptions(options);
+        const capabilities = this.getCapabilities({ phase: requestOptions.phase });
+        if (capabilities.streaming === false) {
+            yield* this.chatStreamFromChat(messages, requestOptions);
+            return;
+        }
         const aiMessages = toAiSdkMessages(messages);
-        const tools = toAiSdkToolSet(options.tools, options.toolSpecs);
+        const tools = toAiSdkToolSet(requestOptions.tools, requestOptions.toolSpecs);
         yield* executeAiSdkChatStreamRequest({
             model: this.model,
             modelId: this.modelId,
+            providerOptionsKey: this.providerOptionsKey,
             timeoutMs: this.timeoutMs,
             langfuseEnabled: Boolean(this.cfg.langfuseEnabled),
             requestId: randomUUID(),
             messages: aiMessages,
             tools,
-            options,
+            options: requestOptions,
         });
     }
     /**
@@ -66,27 +108,70 @@ export class AiSdkLLM {
         yield* this.chatStream(messages, options);
     }
     async createPlan(context, instruction, lastError, signal) {
-        const prompt = await getPlanPrompt(formatContextForPrompt(context), instruction, LIMITS.maxFilesChanged, lastError);
-        const response = await withAuditObservationName('PLAN:plan-json', async () => this.chat([{ role: 'user', content: prompt }], { signal }));
-        const content = response.content;
-        if (!content) {
-            throw wrapPlanEmpty();
+        return this.runHighLevelPhase(HIGH_LEVEL_PHASE_SPECS.plan, {
+            context,
+            instruction,
+            lastError,
+            signal,
+        });
+    }
+    async createPatch(context, plan, lastError, signal) {
+        const planStr = JSON.stringify(plan, null, 2);
+        return this.runHighLevelPhase(HIGH_LEVEL_PHASE_SPECS.patch, {
+            context,
+            planStr,
+            lastError,
+            signal,
+        });
+    }
+    async runHighLevelPhase(spec, input) {
+        const contextPrompt = formatContextForPrompt(input.context);
+        const userPrompt = await spec.buildPrompt({ ...input, contextPrompt });
+        const attachments = spec.buildAttachments({ ...input, contextPrompt });
+        const content = await this.executeHighLevelPrompt({
+            phase: spec.name,
+            defaultNamespace: spec.namespace,
+            contextHash: input.context.contextHash,
+            userPrompt,
+            attachments,
+            observationName: spec.observationName,
+            signal: input.signal,
+        });
+        return spec.parseResult(content);
+    }
+    async executeHighLevelPrompt(params) {
+        const sharedEnvelope = buildSharedRequestEnvelope({
+            defaultNamespace: params.defaultNamespace,
+            contextHash: params.contextHash,
+            systemPrompt: '',
+            userPrompt: params.userPrompt,
+            attachments: params.attachments,
+        });
+        const response = await withAuditObservationName(params.observationName, async () => this.chat(sharedEnvelope.baseMessages, {
+            providerHints: sharedEnvelope.envelope.providerHints,
+            responseFormat: params.phase === 'plan' ? 'json_object' : undefined,
+            signal: params.signal,
+        }));
+        if (params.phase !== 'plan') {
+            return response.content;
         }
         try {
-            return parsePlanFromLLMContent(content);
+            HIGH_LEVEL_PHASE_SPECS.plan.parseResult(response.content);
+            return response.content;
         }
-        catch (e) {
-            throw new LlmError('LLM plan parsing failed', 'LLM_PLAN_INVALID_JSON', {
-                causeMessage: sanitizeError(e),
-            });
+        catch (error) {
+            const repair = await withAuditObservationName('PLAN:plan-json-repair', async () => repairToJsonObject({
+                llm: this,
+                baseMessages: sharedEnvelope.baseMessages,
+                chatOptions: {
+                    providerHints: sharedEnvelope.envelope.providerHints,
+                    signal: params.signal,
+                },
+                badContent: response.content ?? '',
+                reason: error instanceof Error ? error.message : String(error),
+            }));
+            return repair.content;
         }
     }
-    async createPatch(context, plan, lastError, signal) {
-        const planStr = JSON.stringify(plan, null, 2);
-        const formattedContext = formatContextForPrompt(context);
-        const prompt = await getPatchPrompt(planStr, formattedContext, LIMITS.maxFilesChanged, LIMITS.maxDiffLines, lastError);
-        const response = await withAuditObservationName('PATCH:unified-diff', async () => this.chat([{ role: 'user', content: prompt }], { signal }));
-        return extractUnifiedDiffFromLLMContent(response.content || '');
-    }
 }
 //# sourceMappingURL=ai-sdk.js.map

package/dist/core/llm/capabilities.js

@@ -0,0 +1,12 @@
+export function resolveLlmCapabilities(llm, phase) {
+    return llm.getCapabilities?.({ phase }) ?? {};
+}
+export function supportsLlmStreaming(llm, phase) {
+    const capabilities = resolveLlmCapabilities(llm, phase);
+    if (capabilities.streaming === false)
+        return false;
+    if (capabilities.streaming === true)
+        return typeof llm.chatStream === 'function';
+    return typeof llm.chatStream === 'function';
+}
+//# sourceMappingURL=capabilities.js.map

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

@@ -13,10 +13,11 @@ export async function repairToJsonObject(args) {
         'Your previous response did not satisfy the contract.',
         `Reason: ${reason}`,
         '',
-        'Return ONLY a single JSON object.',
-        '- No Markdown fences.',
-        '- No commentary.',
-        '- No leading/trailing text.',
+        'Return exactly one JSON object and nothing else.',
+        'The first non-whitespace character must be {.',
+        'The last non-whitespace character must be }.',
+        '',
+        'Forbidden: Markdown fences, commentary, labels, multiple objects, or any leading/trailing text.',
         '',
         'The JSON object MUST include keys: goal, files, changes, verify.',
         '',
@@ -38,31 +39,36 @@ export async function repairToJsonObject(args) {
     });
 }
 export async function repairToUnifiedDiff(args) {
-    const { llm, baseMessages, chatOptions, badContent, reason } = args;
-    const prompt = [
-        'Your previous response did not satisfy the contract.',
-        `Reason: ${reason}`,
-        '',
-        'Return ONLY a standard git unified diff patch.',
-        '- It MUST start with `diff --git`.',
-        '- No Markdown fences.',
-        '- No commentary.',
-        '- Exactly one final patch block (no multiple alternatives).',
-        '',
-        'Previous response (truncated):',
-        truncateForPrompt(badContent, Math.min(1200, Math.max(400, LIMITS.maxContextChars / 100))),
-    ].join('\n');
-    return llm.chat([
-        ...baseMessages,
-        { role: 'assistant', content: badContent || '' },
-        { role: 'user', content: prompt },
-    ], {
-        ...chatOptions,
-        responseFormat: 'text',
-        tools: undefined,
-        toolSpecs: undefined,
-        toolChoice: undefined,
-        temperature: 0,
-    });
+    const { badContent } = args;
+    const extractCanonicalDiff = (input) => {
+        if (!input)
+            return '';
+        const fromText = (value) => {
+            const start = value.search(/^\s*diff --git /m);
+            if (start === -1)
+                return '';
+            const section = value.slice(start).trim();
+            const fenceClose = section.search(/\n```/);
+            if (fenceClose !== -1)
+                return section.slice(0, fenceClose).trim();
+            return section;
+        };
+        const fencedBlocks = [];
+        const fenceRegex = /```(?:diff)?\s*\n([\s\S]*?)\n```/gi;
+        let match = null;
+        while ((match = fenceRegex.exec(input)) !== null) {
+            const block = match[1];
+            const extracted = fromText(block);
+            if (extracted)
+                fencedBlocks.push(extracted);
+        }
+        if (fencedBlocks.length > 0)
+            return fencedBlocks[fencedBlocks.length - 1];
+        return fromText(input);
+    };
+    return {
+        role: 'assistant',
+        content: extractCanonicalDiff(badContent || ''),
+    };
 }
 //# sourceMappingURL=repair.js.map

package/dist/core/llm/errors.js

@@ -26,6 +26,11 @@ function extractProviderDetails(err) {
         if (typeof candidate.statusCode === 'number') {
             details.statusCode = candidate.statusCode;
         }
+        // Align with AI SDK error shapes that store HTTP status in response.status
+        const response = candidate.response;
+        if (typeof details.statusCode !== 'number' && response && typeof response.status === 'number') {
+            details.statusCode = response.status;
+        }
         if (typeof candidate.responseBody === 'string') {
             // Apply sanitization to responseBody immediately after truncation
             details.responseBody = sanitizeError(truncate(candidate.responseBody));
@@ -75,6 +80,42 @@ function extractProviderDetails(err) {
     }
     return details;
 }
+function extractNetworkCode(err) {
+    if (!err || typeof err !== 'object')
+        return undefined;
+    const candidate = err;
+    const direct = candidate.code;
+    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;
+    }
+    return undefined;
+}
+function isAuthenticationFailure(input) {
+    if (input.statusCode === 401)
+        return true;
+    const lower = `${input.message} ${input.providerMessage ?? ''} ${input.sanitizedMessage}`.toLowerCase();
+    const authHints = [
+        'unauthorized',
+        'forbidden',
+        'authentication failed',
+        'auth failed',
+        'invalid api key',
+        'invalid api-key',
+        'access denied',
+        'permission denied',
+        'credential',
+        'appidnoautherror',
+        'noautherror',
+    ];
+    if (authHints.some((hint) => lower.includes(hint))) {
+        return true;
+    }
+    return input.statusCode === 403 && /auth|access|permission|credential|forbidden/i.test(lower);
+}
 /**
  * Sanitizes an error message using the shared utility to prevent leakage
  * of sensitive technical data.
@@ -83,8 +124,16 @@ export function sanitizeError(err) {
     return sanitizeErrorMessage(err);
 }
 export function toLlmError(err, provider) {
-    let name = err instanceof Error ? err.name : 'UnknownError';
-    let message = err instanceof Error ? err.message : String(err);
+    let name = err instanceof Error
+        ? err.name
+        : typeof err?.name === 'string'
+            ? String(err.name)
+            : 'UnknownError';
+    let message = err instanceof Error
+        ? err.message
+        : typeof err?.message === 'string'
+            ? String(err.message)
+            : String(err);
     // Unwrap RetryError to get the last error's message if available
     if (name === 'AI_RetryError' || err?.lastError) {
         const lastError = err.lastError;
@@ -137,6 +186,38 @@ export function toLlmError(err, provider) {
     })) {
         return new LlmError('LLM context length exceeded', 'LLM_CONTEXT_LENGTH_EXCEEDED', meta);
     }
+    const lower = `${message} ${meta.providerMessage ?? ''} ${sanitizedMessage}`.toLowerCase();
+    const statusCode = meta.statusCode;
+    const networkCode = extractNetworkCode(err)?.toUpperCase();
+    if (isAuthenticationFailure({
+        statusCode,
+        message,
+        providerMessage: meta.providerMessage,
+        sanitizedMessage,
+    })) {
+        return new LlmError('LLM authentication failed', 'LLM_AUTHENTICATION_FAILED', meta);
+    }
+    if (statusCode === 429 || lower.includes('rate limit') || lower.includes('too many requests')) {
+        return new LlmError('LLM rate limited', 'LLM_RATE_LIMITED', meta);
+    }
+    if (statusCode === 408 || lower.includes('timeout') || networkCode === 'ETIMEDOUT') {
+        return new LlmError('LLM request timed out', 'LLM_REQUEST_TIMEOUT', meta);
+    }
+    if (typeof statusCode === 'number' && statusCode >= 500 && statusCode < 600) {
+        return new LlmError('LLM upstream server error', 'LLM_UPSTREAM_5XX', meta);
+    }
+    if (typeof networkCode === 'string') {
+        const unreachable = new Set([
+            'ECONNRESET',
+            'ETIMEDOUT',
+            'EAI_AGAIN',
+            'ENOTFOUND',
+            'ECONNREFUSED',
+        ]);
+        if (unreachable.has(networkCode)) {
+            return new LlmError('LLM network request failed', 'LLM_NETWORK_UNREACHABLE', meta);
+        }
+    }
     return new LlmError('LLM request failed', 'LLM_HTTP_REQUEST_FAILED', meta);
 }
 function isContextLengthExceeded(input) {

package/dist/core/llm/message-composition.js

@@ -1,25 +1,10 @@
-function toSafeConversationMessage(msg) {
-    if (!msg || typeof msg !== 'object')
-        return null;
-    if (msg.role !== 'user' && msg.role !== 'assistant')
-        return null;
-    if (typeof msg.content !== 'string')
-        return null;
-    const content = msg.content.trimEnd();
-    if (!content)
-        return null;
-    return { role: msg.role, content };
-}
+import { buildSharedRequestEnvelope } from './shared-request-assembly.js';
 export function composeChatMessages(params) {
-    const out = [{ role: 'system', content: String(params.system ?? '') }];
-    if (Array.isArray(params.conversationContext)) {
-        for (const msg of params.conversationContext) {
-            const safe = toSafeConversationMessage(msg);
-            if (safe)
-                out.push(safe);
-        }
-    }
-    out.push({ role: 'user', content: String(params.user ?? '') });
-    return out;
+    return buildSharedRequestEnvelope({
+        defaultNamespace: 'chat',
+        systemPrompt: params.system,
+        userPrompt: params.user,
+        conversationContext: params.conversationContext,
+    }).baseMessages;
 }
 //# sourceMappingURL=message-composition.js.map

package/dist/core/llm/phase-router.js

@@ -12,16 +12,9 @@ export function createPhaseRoutingLlm(params) {
         chat(messages, options) {
             return resolve(options?.phase).chat(messages, options);
         },
-        getCapabilities() {
-            const base = defaultLlm.getCapabilities?.() ?? {};
-            const hasToolCalling = Object.values(phaseLlms).some((llm) => llm?.getCapabilities?.().toolCalling);
-            const hasStreaming = Object.values(phaseLlms).some((llm) => llm?.getCapabilities?.().streaming);
-            const hasJsonMode = Object.values(phaseLlms).some((llm) => llm?.getCapabilities?.().responseFormatJsonObject);
-            return {
-                toolCalling: base.toolCalling || hasToolCalling,
-                streaming: base.streaming || hasStreaming,
-                responseFormatJsonObject: base.responseFormatJsonObject || hasJsonMode,
-            };
+        getCapabilities(options) {
+            const selected = resolve(options?.phase);
+            return selected.getCapabilities?.(options) ?? {};
         },
         createPlan(context, instruction, lastError, signal) {
             return resolve(Phase.PLAN).createPlan(context, instruction, lastError, signal);
@@ -33,11 +26,37 @@ export function createPhaseRoutingLlm(params) {
     if (hasAnyStreaming) {
         routed.chatStream = async function* (messages, options) {
             const selected = resolve(options?.phase);
+            const capabilities = selected.getCapabilities?.(options) ?? {};
+            if (capabilities.streaming === false) {
+                const fallback = await selected.chat(messages, options);
+                if (fallback.reasoning_content) {
+                    yield {
+                        role: 'assistant',
+                        source: 'synthesized',
+                        reasoningDelta: fallback.reasoning_content,
+                    };
+                }
+                if (fallback.content) {
+                    yield { role: 'assistant', source: 'synthesized', contentDelta: fallback.content };
+                }
+                if (Array.isArray(fallback.tool_calls) && fallback.tool_calls.length > 0) {
+                    yield { role: 'assistant', source: 'synthesized', tool_calls: fallback.tool_calls };
+                }
+                yield { role: 'assistant', source: 'synthesized', done: true, finishReason: 'stop' };
+                return;
+            }
             if (selected.chatStream) {
                 yield* selected.chatStream(messages, options);
                 return;
             }
             const fallback = await selected.chat(messages, options);
+            if (fallback.reasoning_content) {
+                yield {
+                    role: 'assistant',
+                    source: 'synthesized',
+                    reasoningDelta: fallback.reasoning_content,
+                };
+            }
             if (fallback.content) {
                 yield { role: 'assistant', source: 'synthesized', contentDelta: fallback.content };
             }

package/dist/core/llm/redact.js

@@ -1,4 +1,22 @@
 const SECRET_KEY_REGEX = /(api[-_]?key|authorization|token|secret|password|cookie)/i;
+const STRING_SECRET_PATTERNS = [
+    {
+        pattern: /(authorization\s*:\s*bearer\s+)[^\s'",`]+/gi,
+        replacement: '$1[REDACTED]',
+    },
+    {
+        pattern: /\bbearer\s+[a-z0-9._~+/=-]{16,}\b/gi,
+        replacement: 'Bearer [REDACTED]',
+    },
+    {
+        pattern: /\bsk-[a-z0-9_-]{16,}\b/gi,
+        replacement: '[REDACTED]',
+    },
+    {
+        pattern: /\b(api[-_]?key|token|secret|password|cookie)\s*[:=]\s*("[^"]*"|'[^']*'|[^\s'",`]+)/gi,
+        replacement: '$1=[REDACTED]',
+    },
+];
 function isRecord(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
@@ -7,9 +25,16 @@ function truncate(value, max = 500) {
         return value;
     return value.slice(0, max) + '...';
 }
+function redactString(value) {
+    let redacted = value;
+    for (const { pattern, replacement } of STRING_SECRET_PATTERNS) {
+        redacted = redacted.replace(pattern, replacement);
+    }
+    return truncate(redacted, 500);
+}
 export function redactValue(value) {
     if (typeof value === 'string')
-        return truncate(value, 500);
+        return redactString(value);
     if (typeof value === 'number' || typeof value === 'boolean' || value === null)
         return value;
     if (Array.isArray(value))
@@ -29,9 +54,9 @@ export function redactValue(value) {
     return '[Unserializable]';
 }
 export function redactJsonString(raw) {
-    return truncate(raw, 500);
+    return redactString(raw);
 }
 export function redactErrorMessage(raw) {
-    return truncate(raw, 500);
+    return redactString(raw);
 }
 //# sourceMappingURL=redact.js.map

package/dist/core/llm/registry.js

@@ -39,6 +39,7 @@ export function createDefaultLlmRegistry() {
                     headers: resolved.api.headers,
                     timeoutMs: resolved.api.timeoutMs,
                     langfuseEnabled: options?.langfuseEnabled,
+                    capabilities: resolved.capabilities,
                 }),
                 backend: 'ai-sdk',
                 warnings,
@@ -73,6 +74,7 @@ export function createDefaultOpenAiFallback(resolved, options) {
             headers: resolved.api.headers,
             timeoutMs: resolved.api.timeoutMs,
             langfuseEnabled: options?.langfuseEnabled,
+            capabilities: resolved.capabilities,
         }),
         backend: 'ai-sdk',
         warnings,

package/dist/core/llm/request-augmentation.js

@@ -0,0 +1,55 @@
+const MEMORY_HEADER = '[Relevant memory]';
+function defaultCountTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function normalizeEntry(entry) {
+    return {
+        path: String(entry.path),
+        title: String(entry.title),
+        summary: String(entry.summary),
+        tags: entry.tags,
+    };
+}
+function formatRelevantMemoryEntry(entry) {
+    return `- ${entry.path} | ${entry.title}\n  ${entry.summary}`;
+}
+export function augmentPromptWithRelevantMemory(args) {
+    const basePrompt = String(args.basePrompt ?? '').trimEnd();
+    const selectedEntries = Array.isArray(args.selectedEntries)
+        ? args.selectedEntries.map(normalizeEntry)
+        : [];
+    if (selectedEntries.length === 0) {
+        return { prompt: basePrompt, injectedEntries: [] };
+    }
+    const countTokens = args.countTokens ?? defaultCountTokens;
+    const budgetTokens = typeof args.budgetTokens === 'number'
+        ? Math.max(0, Math.floor(args.budgetTokens))
+        : Number.MAX_SAFE_INTEGER;
+    const headerTokens = Math.max(0, Math.floor(countTokens(MEMORY_HEADER)));
+    if (headerTokens > budgetTokens) {
+        return { prompt: basePrompt, injectedEntries: [] };
+    }
+    let remainingBudget = budgetTokens - headerTokens;
+    const injectedEntries = [];
+    const renderedEntries = [];
+    for (const entry of selectedEntries) {
+        const rendered = formatRelevantMemoryEntry(entry);
+        const entryTokens = Math.max(0, Math.floor(countTokens(rendered)));
+        if (entryTokens > remainingBudget) {
+            break;
+        }
+        injectedEntries.push(entry);
+        renderedEntries.push(rendered);
+        remainingBudget -= entryTokens;
+    }
+    if (renderedEntries.length === 0) {
+        return { prompt: basePrompt, injectedEntries: [] };
+    }
+    const memoryBlock = [MEMORY_HEADER, ...renderedEntries].join('\n');
+    return {
+        prompt: basePrompt ? `${basePrompt}\n\n${memoryBlock}` : memoryBlock,
+        injectedEntries,
+        memoryBlock,
+    };
+}
+//# sourceMappingURL=request-augmentation.js.map