salmon-loop 0.2.13 → 0.2.16

package/dist/core/grizzco/steps/request-assembly.js

@@ -0,0 +1,78 @@
+import { augmentPromptWithRelevantMemory } from '../../llm/request-augmentation.js';
+import { buildSharedRequestEnvelope as buildSharedRequestEnvelopeCore, } from '../../llm/shared-request-assembly.js';
+import { formatContextForPrompt } from '../../llm/utils.js';
+import { buildRelevantMemoryCandidates, selectRelevantMemory, } from '../../memory/relevant-retrieval.js';
+import { resolveVisibleToolNames, } from '../../tools/tool-visibility.js';
+import { resolveCacheSharingSurface, } from './cache-sharing.js';
+export function buildSharedRequestEnvelope(args) {
+    return buildSharedRequestEnvelopeCore(args);
+}
+export async function buildAugmentedRequestEnvelope(args) {
+    const baseContextPrompt = args.baseContextPrompt ?? args.contextResult?.prompt ?? formatContextForPrompt(args.context);
+    const localContextHash = args.contextResult?.meta?.contextHash ?? args.context.contextHash;
+    const cacheSurface = resolveCacheSharingSurface({
+        phase: args.phase,
+        defaultNamespace: args.defaultNamespace,
+        localContextHash,
+        cacheSharing: args.cacheSharing,
+        mismatchPolicy: args.cacheMismatchPolicy,
+        onMismatch: args.onCacheMismatch,
+    });
+    const relevantMemory = selectRelevantMemory({
+        instruction: args.context.instruction,
+        candidates: args.relevantMemory?.entries ?? buildRelevantMemoryCandidates(args.context),
+        activeToolNames: resolveVisibleToolNames({
+            phase: args.phase,
+            toolstack: args.toolVisibility?.toolstack,
+            runtime: args.toolVisibility?.runtime,
+            worktreeRoot: args.toolVisibility?.worktreeRoot,
+            flowMode: args.toolVisibility?.flowMode,
+        }),
+        maxItems: args.relevantMemory?.maxItems,
+        alreadySurfacedText: [
+            baseContextPrompt,
+            ...(Array.isArray(args.systemPrompt) ? args.systemPrompt : [args.systemPrompt]),
+            ...(args.conversationContext ?? []).map((message) => message.content),
+        ],
+    });
+    const contextPrompt = augmentPromptWithRelevantMemory({
+        basePrompt: baseContextPrompt,
+        selectedEntries: relevantMemory,
+        budgetTokens: args.relevantMemory?.budgetTokens,
+        countTokens: args.relevantMemory?.countTokens,
+    }).prompt;
+    const userPrompt = await args.buildUserPrompt(contextPrompt);
+    const shared = buildSharedRequestEnvelope({
+        defaultNamespace: cacheSurface.namespace,
+        contextHash: cacheSurface.contextHash,
+        systemPrompt: args.systemPrompt,
+        userPrompt,
+        conversationContext: args.conversationContext,
+        artifactHints: args.artifactHints,
+        toolCallingAudit: args.toolCallingAudit,
+        previewProvider: args.previewProvider,
+        attachments: [
+            {
+                key: 'context-prompt',
+                kind: 'context',
+                label: 'Context prompt',
+                content: contextPrompt,
+                cacheSafe: true,
+            },
+            ...(args.extraAttachments ?? []),
+        ],
+        providerHints: args.providerHints,
+    });
+    return {
+        contextPrompt,
+        userPrompt,
+        cacheSurface,
+        resolvedArtifactHints: shared.resolvedArtifactHints,
+        envelope: shared.envelope,
+        baseMessages: shared.baseMessages,
+    };
+}
+export async function buildPhaseRequestEnvelope(args) {
+    return buildAugmentedRequestEnvelope(args);
+}
+//# sourceMappingURL=request-assembly.js.map

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

@@ -1,23 +1,14 @@
 import { text } from '../../../locales/index.js';
-import { composeChatMessages } from '../../llm/message-composition.js';
+import { supportsLlmStreaming } from '../../llm/capabilities.js';
 import { emitLlmOutput } from '../../llm/output-policy.js';
-import { formatContextForPrompt } from '../../llm/utils.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { getResearchPrompt, getResearchSystemPrompt } from '../../prompts/runtime.js';
+import { SessionReplacementPreviewProvider } from '../../session/replacement-preview-provider.js';
 import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
 import { Phase } from '../../types/runtime.js';
 import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
-function buildResearchPrompt(contextText, instruction) {
-    return [
-        'You are running in deep research mode.',
-        'Use available tools to gather external information as needed.',
-        'Return JSON with keys: researchNotes, researchFindings, sources, researchText.',
-        'Each researchFinding should include: summary, confidence (0-1), uncertainty (string).',
-        'Each source should include: toolName, summary, ok, timestamp (epoch ms).',
-        '',
-        `Instruction:\n${instruction}`,
-        '',
-        `Context:\n${contextText}`,
-    ].join('\n');
-}
+import { buildPhaseRequestEnvelope } from './request-assembly.js';
+import { buildPhaseToolRuntimeContext, buildToolVisibilityRuntime } from './tool-runtime.js';
 function normalizeFindings(value) {
     if (!value)
         return [];
@@ -88,20 +79,43 @@ function buildSourcesFromAudit(entries) {
     }));
 }
 export async function generateResearch(ctx) {
-    const contextText = formatContextForPrompt(ctx.context);
-    const prompt = buildResearchPrompt(contextText, ctx.options.instruction);
-    const systemPrompt = 'You are a research assistant. Prefer evidence-backed claims.';
-    const baseMessages = composeChatMessages({
-        system: systemPrompt,
-        user: prompt,
+    const systemPrompt = await getResearchSystemPrompt();
+    const toolVisibility = buildToolVisibilityRuntime(ctx);
+    const requestEnvelope = await buildPhaseRequestEnvelope({
+        phase: Phase.RESEARCH,
+        defaultNamespace: 'research',
+        context: ctx.context,
+        contextResult: ctx.contextResult,
+        cacheSharing: ctx.cacheSharing,
+        onCacheMismatch: (mismatch) => {
+            recordAuditEvent('request.cache_sharing_hash_mismatch', mismatch, {
+                source: 'llm',
+                severity: 'low',
+                scope: 'session',
+                phase: Phase.RESEARCH,
+            });
+        },
+        systemPrompt,
+        buildUserPrompt: async (contextText) => await getResearchPrompt(contextText, ctx.options.instruction),
         conversationContext: ctx.options.conversationContext,
+        artifactHints: ctx.artifactHints,
+        toolCallingAudit: ctx.toolCallingAudit,
+        previewProvider: new SessionReplacementPreviewProvider(ctx.replacementState),
+        toolVisibility: {
+            toolstack: ctx.toolstack,
+            runtime: toolVisibility,
+            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+            flowMode: ctx.mode,
+        },
     });
+    const { cacheSurface, envelope, baseMessages } = requestEnvelope;
     const toolPolicy = resolveLlmToolCallingPolicy(Phase.RESEARCH, ctx.options.llm);
-    const supportsStreaming = typeof ctx.options.llm.chatStream === 'function';
+    const supportsStreaming = supportsLlmStreaming(ctx.options.llm, Phase.RESEARCH);
     const localAudit = [];
     const sourcesFromAudit = () => buildSourcesFromAudit(localAudit);
     if (!ctx.toolstack || !toolPolicy.enabled) {
         const response = await ctx.options.llm.chat(baseMessages, {
+            providerHints: envelope.providerHints,
             signal: ctx.options.signal,
             phase: Phase.RESEARCH,
         });
@@ -133,22 +147,11 @@ export async function generateResearch(ctx) {
         kind: 'research',
         step: 'RESEARCH',
     };
-    const response = await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(baseMessages, { signal: ctx.options.signal }, {
+    const response = await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(baseMessages, { providerHints: envelope.providerHints, signal: ctx.options.signal }, {
         phase: Phase.RESEARCH,
         llm: ctx.options.llm,
-        runtime: {
-            repoRoot: ctx.workspace.workPath,
-            persistenceRoot: ctx.workspace.baseRepoPath || ctx.workspace.workPath,
-            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
-            attemptId: ctx.attempt ?? 1,
-            dryRun: Boolean(ctx.options?.dryRun),
-            llm: ctx.options.llm,
-            model: ctx.options.llm.getModelId?.() || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL,
-            userInputProvider: ctx.options.userInputProvider,
-            agentKind: ctx.options.agentKind ?? 'primary',
-            languagePlugins: ctx.options.languagePlugins,
-            subAgentController: ctx.options.subAgentController,
-        },
+        runtime: buildPhaseToolRuntimeContext(ctx, Phase.RESEARCH, cacheSurface),
+        toolVisibility,
         toolstack: ctx.toolstack,
         eventPayload: ctx.options.eventPayload,
         toolCallingAudit: {

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

@@ -0,0 +1,47 @@
+import { buildSystemPrefixDigest, buildToolSchemaHash, } from '../../sub-agent/prefix-consistency.js';
+export function buildPhaseToolRuntimeContext(ctx, phase, cacheSurface) {
+    return {
+        repoRoot: ctx.workspace.workPath,
+        persistenceRoot: ctx.workspace.baseRepoPath || ctx.workspace.workPath,
+        worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+        flowMode: ctx.mode,
+        attemptId: ctx.attempt ?? 1,
+        dryRun: Boolean(ctx.options?.dryRun),
+        llm: ctx.options.llm,
+        model: ctx.options.llm.getModelId?.() || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL,
+        userInputProvider: ctx.options.userInputProvider,
+        agentKind: ctx.options.agentKind ?? 'primary',
+        languagePlugins: ctx.options.languagePlugins,
+        subAgentController: ctx.options.subAgentController,
+        phase,
+        contextSnapshot: {
+            conversationContext: ctx.options.conversationContext,
+            artifactHints: ctx.artifactHints,
+            toolCallingAudit: ctx.toolCallingAudit,
+            replacementState: ctx.replacementState,
+            planRuntime: ctx.planRuntime,
+            cacheSharing: {
+                namespace: cacheSurface.namespace,
+                contextHash: cacheSurface.contextHash,
+                toolSchemaHash: buildToolSchemaHash({
+                    phase,
+                    allowedToolNames: ctx.options.allowedToolNames,
+                }),
+                systemPrefixDigest: buildSystemPrefixDigest({
+                    phase,
+                    namespace: cacheSurface.namespace,
+                    contextHash: cacheSurface.contextHash,
+                }),
+            },
+        },
+    };
+}
+export function buildToolVisibilityRuntime(ctx) {
+    if (!ctx.planRuntime) {
+        return undefined;
+    }
+    return {
+        plan: ctx.planRuntime,
+    };
+}
+//# sourceMappingURL=tool-runtime.js.map

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

@@ -0,0 +1,23 @@
+import { ArtifactStore } from '../../sub-agent/artifacts/store.js';
+import { runVerify as runVerifyCommand } from '../../verification/runner.js';
+export async function executeVerifyForWorkspace(params) {
+    const verifyResult = await runVerifyCommand(params.workspacePath, params.verify, undefined, params.signal);
+    let verifyArtifact;
+    if (!verifyResult.ok && verifyResult.output) {
+        try {
+            verifyArtifact = await ArtifactStore.saveText({
+                content: verifyResult.output,
+                mimeType: 'text/plain',
+                fileExt: 'log',
+            });
+        }
+        catch {
+            // Best-effort only; keep verifyResult.output in-memory for shrink/error classification.
+        }
+    }
+    return {
+        verifyResult,
+        ...(verifyArtifact ? { verifyArtifact } : {}),
+    };
+}
+//# sourceMappingURL=verify-shared.js.map

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

@@ -1,8 +1,7 @@
 import { text } from '../../../locales/index.js';
 import { collectBudgetMetrics, evaluateBudgetAlert, getGlobalAdjuster, recordBudgetAlert, } from '../../context/budget/integration.js';
 import { recordAuditEvent } from '../../observability/audit-trail.js';
-import { ArtifactStore } from '../../sub-agent/artifacts/store.js';
-import { runVerify as runVerifyCommand } from '../../verification/runner.js';
+import { executeVerifyForWorkspace } from './verify-shared.js';
 function extractCommandProgram(command) {
     const trimmed = command.trim();
     if (!trimmed)
@@ -16,8 +15,11 @@ export const runVerify = async (ctx) => {
             verifyResult: { ok: true, output: text.loop.verificationSkipped, exitCode: null },
         };
     }
-    const verifyResult = await runVerifyCommand(ctx.workspace.workPath, ctx.options.verify, undefined, ctx.options.signal);
-    let verifyArtifact;
+    const { verifyResult, verifyArtifact } = await executeVerifyForWorkspace({
+        workspacePath: ctx.workspace.workPath,
+        verify: ctx.options.verify,
+        signal: ctx.options.signal,
+    });
     recordAuditEvent('verify.summary', {
         ok: verifyResult.ok,
         exitCode: verifyResult.exitCode,
@@ -92,23 +94,13 @@ export const runVerify = async (ctx) => {
             message: text.loop.verificationFailedSummary,
             timestamp: new Date(),
         });
-        if (verifyResult.output) {
-            try {
-                verifyArtifact = await ArtifactStore.saveText({
-                    content: verifyResult.output,
-                    mimeType: 'text/plain',
-                    fileExt: 'log',
-                });
-                ctx.emit({
-                    type: 'log',
-                    level: 'debug',
-                    message: text.loop.verificationOutputStored(verifyArtifact.handle),
-                    timestamp: new Date(),
-                });
-            }
-            catch {
-                // Best-effort only; keep verifyResult.output in-memory for shrink/error classification.
-            }
+        if (verifyArtifact) {
+            ctx.emit({
+                type: 'log',
+                level: 'debug',
+                message: text.loop.verificationOutputStored(verifyArtifact.handle),
+                timestamp: new Date(),
+            });
         }
         // We don't throw here, because we want to trigger rollback/shrink in the pipeline
         // But wait, the Pipeline abstraction propagates errors immediately.

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

@@ -34,6 +34,7 @@ export async function executeAiSdkChatRequest(input) {
                         options: input.options,
                         headers: attemptCtx.langfuseHeaders,
                         abortSignal: attemptCtx.abortSignal,
+                        providerOptionsKey: input.providerOptionsKey,
                     }));
                     const usage = extractUsageFromAiSdkResult(result);
                     if (usage) {
@@ -74,6 +75,7 @@ export async function* executeAiSdkChatStreamRequest(input) {
                     options: input.options,
                     headers: attemptCtx.langfuseHeaders,
                     abortSignal: attemptCtx.abortSignal,
+                    providerOptionsKey: input.providerOptionsKey,
                 }));
                 yield* mapAiSdkStreamResultToChunks(result.fullStream);
             },

package/dist/core/llm/ai-sdk/high-level-phase-specs.js

@@ -0,0 +1,63 @@
+import { LIMITS } from '../../config/limits.js';
+import { getPatchPrompt, getPlanPrompt } from '../../prompts/runtime.js';
+import { wrapPlanEmpty, sanitizeError, LlmError } from '../errors.js';
+import { extractUnifiedDiffFromLLMContent, parsePlanFromLLMContent } from '../utils.js';
+export const HIGH_LEVEL_PHASE_NAMES = [
+    'plan',
+    'patch',
+];
+function buildContextPromptAttachment(contextPrompt) {
+    return {
+        key: 'context-prompt',
+        kind: 'context',
+        label: 'Context prompt',
+        content: contextPrompt,
+        cacheSafe: true,
+    };
+}
+function buildPatchAttachments(contextPrompt, planStr) {
+    return [
+        buildContextPromptAttachment(contextPrompt),
+        {
+            key: 'plan-json',
+            kind: 'plan',
+            label: 'Plan JSON',
+            content: planStr,
+        },
+    ];
+}
+function parsePlanResult(content) {
+    if (!content) {
+        throw wrapPlanEmpty();
+    }
+    try {
+        return parsePlanFromLLMContent(content);
+    }
+    catch (e) {
+        throw new LlmError('LLM plan parsing failed', 'LLM_PLAN_INVALID_JSON', {
+            causeMessage: sanitizeError(e),
+        });
+    }
+}
+function parsePatchResult(content) {
+    return extractUnifiedDiffFromLLMContent(content ?? '');
+}
+export const HIGH_LEVEL_PHASE_SPECS = {
+    plan: {
+        name: 'plan',
+        namespace: 'plan',
+        observationName: 'PLAN:plan-json',
+        buildPrompt: async ({ contextPrompt, instruction, lastError }) => getPlanPrompt(contextPrompt, instruction, LIMITS.maxFilesChanged, lastError),
+        buildAttachments: ({ contextPrompt }) => [buildContextPromptAttachment(contextPrompt)],
+        parseResult: (content) => parsePlanResult(content),
+    },
+    patch: {
+        name: 'patch',
+        namespace: 'patch',
+        observationName: 'PATCH:unified-diff',
+        buildPrompt: async ({ planStr, contextPrompt, lastError }) => getPatchPrompt(planStr, contextPrompt, LIMITS.maxFilesChanged, LIMITS.maxDiffLines, lastError),
+        buildAttachments: ({ contextPrompt, planStr }) => buildPatchAttachments(contextPrompt, planStr),
+        parseResult: (content) => parsePatchResult(content),
+    },
+};
+//# sourceMappingURL=high-level-phase-specs.js.map

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,3 +1,70 @@
+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,
@@ -6,11 +73,17 @@ export function buildAiSdkRequestParams(params) {
         temperature: params.options.temperature,
         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),
     };
 }