salmon-loop 0.2.3 → 0.2.16

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

@@ -129,12 +129,32 @@ export function toAiSdkMessages(messages) {
                 ],
             };
         }
-        if (m.role === 'assistant' && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+        if (m.role === 'assistant') {
+            const hasToolCalls = Array.isArray(m.tool_calls) && m.tool_calls.length > 0;
+            const reasoningContent = typeof m.reasoning_content === 'string' && m.reasoning_content.length > 0
+                ? m.reasoning_content
+                : undefined;
+            if (!hasToolCalls && !reasoningContent) {
+                let content = m.content;
+                if (content === undefined || content === null) {
+                    content = '';
+                }
+                if (typeof content !== 'string') {
+                    content = JSON.stringify(content);
+                }
+                return {
+                    role: m.role,
+                    content: content,
+                };
+            }
             const parts = [];
+            if (reasoningContent) {
+                parts.push({ type: 'reasoning', text: reasoningContent });
+            }
             if (m.content && typeof m.content === 'string') {
                 parts.push({ type: 'text', text: m.content });
             }
-            for (const call of m.tool_calls) {
+            for (const call of hasToolCalls ? m.tool_calls || [] : []) {
                 const toolCallId = call?.id || 'unknown';
                 const toolName = call?.function?.name || call?.name || 'unknown';
                 const rawArgs = call?.function?.arguments;
@@ -143,11 +163,15 @@ export function toAiSdkMessages(messages) {
                         ? safeParseJsonObject(rawArgs)
                         : {}
                     : (call?.input ?? call?.args ?? {});
+                const providerOptions = isObjectRecord(call?.providerMetadata)
+                    ? deepCloneJson(call.providerMetadata, {})
+                    : undefined;
                 parts.push({
                     type: 'tool-call',
                     toolCallId,
                     toolName,
                     input: deepCloneJson(input, {}),
+                    ...(providerOptions ? { providerOptions } : {}),
                 });
             }
             return {
@@ -228,13 +252,19 @@ export function toOpenAiToolCalls(toolCalls) {
             return raw;
         }
     };
-    return toolCalls.map((c) => ({
-        id: c?.toolCallId || c?.id || 'unknown',
-        type: 'function',
-        function: {
-            name: c?.toolName || c?.name || 'unknown',
-            arguments: JSON.stringify(normalizeToolInput(c?.input ?? c?.args ?? {})),
-        },
-    }));
+    return toolCalls.map((c) => {
+        const providerMetadata = isObjectRecord(c?.providerMetadata)
+            ? deepCloneJson(c.providerMetadata, {})
+            : undefined;
+        return {
+            id: c?.toolCallId || c?.id || 'unknown',
+            type: 'function',
+            function: {
+                name: c?.toolName || c?.name || 'unknown',
+                arguments: JSON.stringify(normalizeToolInput(c?.input ?? c?.args ?? {})),
+            },
+            ...(providerMetadata ? { providerMetadata } : {}),
+        };
+    });
 }
 //# sourceMappingURL=message-mapper.js.map

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

@@ -1,9 +1,23 @@
 import { createOpenAI } from '@ai-sdk/openai';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import { resolveBaseUrl } from '../base-url.js';
+function toProviderOptionsKey(value) {
+    const normalized = value.trim();
+    if (!normalized)
+        return 'openaiCompatible';
+    return normalized
+        .replace(/[-_\s]+(.)?/g, (_, char) => (char ? char.toUpperCase() : ''))
+        .replace(/^[A-Z]/, (char) => char.toLowerCase());
+}
 export function resolveAiSdkModelId(modelId) {
     return modelId || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL || 'gpt-4o';
 }
+export function resolveAiSdkProviderOptionsKey(cfg) {
+    if (cfg.clientPackage === '@ai-sdk/openai') {
+        return 'openai';
+    }
+    return toProviderOptionsKey(cfg.providerName || 'openaiCompatible');
+}
 export function createAiSdkChatModel(cfg, modelId) {
     if (cfg.clientPackage === '@ai-sdk/openai') {
         const provider = createOpenAI({

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

@@ -1,16 +1,89 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isJsonValue(value) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.every((item) => isJsonValue(item));
+    }
+    if (!isRecord(value)) {
+        return false;
+    }
+    return Object.values(value).every((item) => isJsonValue(item));
+}
+function toJsonObject(value) {
+    if (!isRecord(value))
+        return undefined;
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (!isJsonValue(entry))
+            return undefined;
+        out[key] = entry;
+    }
+    return out;
+}
+function buildOpenAICacheHintFromPolicy(policy) {
+    if (!policy || policy.eligibility !== 'eligible')
+        return undefined;
+    if (!policy.contextHash || !policy.cacheSafeFingerprint)
+        return undefined;
+    const namespace = typeof policy.namespace === 'string' && policy.namespace.trim()
+        ? policy.namespace
+        : 'request-envelope';
+    const components = [policy.contextHash, `stable:${policy.cacheSafeFingerprint}`];
+    if (policy.mode === 'strict_full_prompt' && policy.lateInjectionFingerprint) {
+        components.push(`late:${policy.lateInjectionFingerprint}`);
+    }
+    return `cache:${JSON.stringify({ namespace, components })}`;
+}
+function mergeProviderOptions(params) {
+    const merged = isRecord(params.providerOptions)
+        ? { ...params.providerOptions }
+        : {};
+    const cacheHint = params.providerHints?.openAICacheHint ??
+        buildOpenAICacheHintFromPolicy(params.providerHints?.openAICachePolicy);
+    if (cacheHint) {
+        const existing = toJsonObject(merged[params.providerOptionsKey]) ?? {};
+        if (typeof existing.user !== 'string' || !existing.user.trim()) {
+            existing.user = cacheHint;
+        }
+        merged[params.providerOptionsKey] = existing;
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function resolveResponseFormat(options) {
+    if (options.responseFormat === 'json_object') {
+        return options.responseFormatJsonObjectSupported === false ? undefined : { type: 'json' };
+    }
+    if (options.responseFormat === 'text') {
+        return { type: 'text' };
+    }
+    return undefined;
+}
 export function buildAiSdkRequestParams(params) {
     return {
         model: params.model,
         messages: params.messages,
         tools: params.tools,
         temperature: params.options.temperature,
-        maxOutputTokens: params.options.maxTokens,
+        maxOutputTokens: params.options.maxTokens != null ? Number(params.options.maxTokens) : undefined,
         stopSequences: params.options.stop,
+        responseFormat: resolveResponseFormat(params.options),
         toolChoice: (params.options.toolChoice === 'none'
             ? 'none'
             : params.tools
                 ? 'auto'
                 : undefined),
+        providerOptions: mergeProviderOptions({
+            providerOptions: params.options.providerOptions,
+            providerHints: params.options.providerHints,
+            providerOptionsKey: params.providerOptionsKey,
+        }),
         headers: params.headers,
         abortSignal: params.abortSignal,
     };

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

@@ -1,9 +1,25 @@
 import { mapAiSdkStreamPartToChunk } from '../stream-utils.js';
 import { toOpenAiToolCalls } from './message-mapper.js';
+function extractReasoningContent(result) {
+    if (typeof result?.reasoningText === 'string' && result.reasoningText.length > 0) {
+        return result.reasoningText;
+    }
+    const reasoningParts = Array.isArray(result?.reasoning)
+        ? result.reasoning
+        : Array.isArray(result?.content)
+            ? result.content.filter((part) => part?.type === 'reasoning')
+            : [];
+    const text = reasoningParts
+        .map((part) => (typeof part?.text === 'string' ? part.text : ''))
+        .join('');
+    return text.length > 0 ? text : undefined;
+}
 export function mapAiSdkGenerateResultToMessage(result) {
+    const reasoningContent = extractReasoningContent(result);
     return {
         role: 'assistant',
         content: result?.text || '',
+        ...(reasoningContent ? { reasoning_content: reasoningContent } : {}),
         tool_calls: toOpenAiToolCalls(result?.toolCalls),
     };
 }

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