salmon-loop 0.2.3

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

@@ -0,0 +1,240 @@
+import { jsonSchema, tool } from 'ai';
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { toolToOpenAI } from '../../tools/mapper.js';
+function formatOutputSchema(schema) {
+    if (!schema)
+        return 'any (dynamic)';
+    const def = schema._def;
+    if (def?.description) {
+        return def.description;
+    }
+    try {
+        const jsonSchemaObj = zodToJsonSchema(schema, {
+            target: 'openApi3',
+            $refStrategy: 'none',
+        });
+        if (jsonSchemaObj && typeof jsonSchemaObj === 'object') {
+            const { $schema: _$schema, ...cleanSchema } = jsonSchemaObj;
+            return JSON.stringify(cleanSchema);
+        }
+    }
+    catch {
+        // Fallback to generic description for invalid/unsupported schema.
+    }
+    return 'complex object';
+}
+function safeParseJsonObject(textValue) {
+    try {
+        const parsed = JSON.parse(textValue);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+            return parsed;
+    }
+    catch {
+        // ignored
+    }
+    return {};
+}
+function deepCloneJson(value, fallback) {
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized === undefined)
+            return fallback;
+        return JSON.parse(serialized);
+    }
+    catch {
+        return fallback;
+    }
+}
+function isObjectRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function extractUsageFromAiSdkResult(result) {
+    if (!isObjectRecord(result))
+        return null;
+    const usage = result.usage;
+    if (!isObjectRecord(usage))
+        return null;
+    const promptTokens = usage.promptTokens ?? usage.prompt_tokens;
+    const completionTokens = usage.completionTokens ?? usage.completion_tokens;
+    if (typeof promptTokens !== 'number' || typeof completionTokens !== 'number')
+        return null;
+    if (!Number.isFinite(promptTokens) || !Number.isFinite(completionTokens))
+        return null;
+    return { promptTokens, completionTokens };
+}
+function isToolApprovalResponse(value) {
+    return (isObjectRecord(value) &&
+        typeof value.approvalId === 'string' &&
+        typeof value.approved === 'boolean');
+}
+function isToolResultOutput(value) {
+    if (!isObjectRecord(value) || typeof value.type !== 'string')
+        return false;
+    return ['text', 'json', 'execution-denied', 'error-text', 'error-json', 'content'].includes(value.type);
+}
+function toAiSdkToolResultOutput(value) {
+    if (isToolResultOutput(value)) {
+        return deepCloneJson(value, { type: 'json', value: null });
+    }
+    if (typeof value === 'string') {
+        return { type: 'text', value };
+    }
+    if (isObjectRecord(value) && typeof value.status === 'string') {
+        const outputType = value.status === 'ok' ? 'json' : 'error-json';
+        return {
+            type: outputType,
+            value: deepCloneJson(value, {}),
+        };
+    }
+    return {
+        type: 'json',
+        value: deepCloneJson(value, null),
+    };
+}
+export function toAiSdkMessages(messages) {
+    return messages.map((m) => {
+        if (m.role === 'tool') {
+            const toolCallId = m.tool_call_id || 'unknown';
+            const toolName = m.name || 'unknown';
+            let parsedContent;
+            try {
+                parsedContent = JSON.parse(m.content);
+            }
+            catch {
+                parsedContent = m.content;
+            }
+            if (isToolApprovalResponse(parsedContent)) {
+                return {
+                    role: 'tool',
+                    content: [
+                        {
+                            type: 'tool-approval-response',
+                            approvalId: parsedContent.approvalId,
+                            approved: parsedContent.approved,
+                            ...(typeof parsedContent.reason === 'string' ? { reason: parsedContent.reason } : {}),
+                        },
+                    ],
+                };
+            }
+            return {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId,
+                        toolName,
+                        output: toAiSdkToolResultOutput(parsedContent),
+                    },
+                ],
+            };
+        }
+        if (m.role === 'assistant' && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+            const parts = [];
+            if (m.content && typeof m.content === 'string') {
+                parts.push({ type: 'text', text: m.content });
+            }
+            for (const call of m.tool_calls) {
+                const toolCallId = call?.id || 'unknown';
+                const toolName = call?.function?.name || call?.name || 'unknown';
+                const rawArgs = call?.function?.arguments;
+                const input = typeof rawArgs === 'string'
+                    ? rawArgs.trim()
+                        ? safeParseJsonObject(rawArgs)
+                        : {}
+                    : (call?.input ?? call?.args ?? {});
+                parts.push({
+                    type: 'tool-call',
+                    toolCallId,
+                    toolName,
+                    input: deepCloneJson(input, {}),
+                });
+            }
+            return {
+                role: 'assistant',
+                content: parts,
+            };
+        }
+        let content = m.content;
+        if (content === undefined || content === null) {
+            content = '';
+        }
+        if (typeof content !== 'string') {
+            content = JSON.stringify(content);
+        }
+        return {
+            role: m.role,
+            content: content,
+        };
+    });
+}
+export function toAiSdkToolSet(openAiTools, toolSpecs) {
+    const tools = {};
+    if (Array.isArray(toolSpecs)) {
+        for (const spec of 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();
+        }
+    }
+    if (Array.isArray(openAiTools)) {
+        for (const t of openAiTools) {
+            const fn = t?.function;
+            const name = fn?.name;
+            if (!name || typeof name !== 'string' || tools[name])
+                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();
+        }
+    }
+    return Object.keys(tools).length > 0 ? tools : undefined;
+}
+export function toOpenAiToolCalls(toolCalls) {
+    if (!Array.isArray(toolCalls) || toolCalls.length === 0)
+        return undefined;
+    const normalizeToolInput = (raw) => {
+        if (typeof raw !== 'string')
+            return raw;
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return {};
+        try {
+            let parsed = JSON.parse(trimmed);
+            if (typeof parsed === 'string') {
+                const nested = parsed.trim();
+                if (nested.startsWith('{') || nested.startsWith('[')) {
+                    try {
+                        parsed = JSON.parse(nested);
+                    }
+                    catch {
+                        // ignored
+                    }
+                }
+            }
+            return parsed;
+        }
+        catch {
+            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 ?? {})),
+        },
+    }));
+}
+//# sourceMappingURL=message-mapper.js.map

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

@@ -0,0 +1,16 @@
+import { getAuditContext, setAuditContext } from '../../observability/audit-trail.js';
+/**
+ * Temporarily overrides audit observationName for the given async operation,
+ * and always restores the previous value.
+ */
+export async function withAuditObservationName(observationName, operation) {
+    const previousObservationName = getAuditContext().observationName;
+    setAuditContext({ observationName });
+    try {
+        return await operation();
+    }
+    finally {
+        setAuditContext({ observationName: previousObservationName });
+    }
+}
+//# sourceMappingURL=observation-context.js.map

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

@@ -0,0 +1,29 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { resolveBaseUrl } from '../base-url.js';
+export function resolveAiSdkModelId(modelId) {
+    return modelId || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL || 'gpt-4o';
+}
+export function createAiSdkChatModel(cfg, modelId) {
+    if (cfg.clientPackage === '@ai-sdk/openai') {
+        const provider = createOpenAI({
+            apiKey: cfg.apiKey ?? process.env.SALMONLOOP_API_KEY ?? process.env.S8P_API_KEY,
+            baseURL: resolveBaseUrl(cfg.baseUrl),
+            headers: cfg.headers,
+        });
+        // Prefer chat API to preserve existing tool-call loop semantics.
+        return provider.chat(modelId);
+    }
+    const headers = { ...(cfg.headers || {}) };
+    const apiKey = cfg.apiKey ?? process.env.SALMONLOOP_API_KEY ?? process.env.S8P_API_KEY;
+    if (apiKey && !headers.Authorization) {
+        headers.Authorization = `Bearer ${apiKey}`;
+    }
+    const provider = createOpenAICompatible({
+        name: cfg.providerName || 'openai-compatible',
+        baseURL: resolveBaseUrl(cfg.baseUrl) ?? '',
+        headers,
+    });
+    return provider.chatModel(modelId);
+}
+//# sourceMappingURL=provider-factory.js.map

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

@@ -0,0 +1,18 @@
+export function buildAiSdkRequestParams(params) {
+    return {
+        model: params.model,
+        messages: params.messages,
+        tools: params.tools,
+        temperature: params.options.temperature,
+        maxOutputTokens: params.options.maxTokens,
+        stopSequences: params.options.stop,
+        toolChoice: (params.options.toolChoice === 'none'
+            ? 'none'
+            : params.tools
+                ? 'auto'
+                : undefined),
+        headers: params.headers,
+        abortSignal: params.abortSignal,
+    };
+}
+//# sourceMappingURL=request-params.js.map

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

@@ -0,0 +1,168 @@
+import { getAuditContext, recordAuditEvent, } from '../../observability/audit-trail.js';
+import { buildLangfuseHeaders } from './langfuse-headers.js';
+import { classifyRetryableApiError } from './retry-classifier.js';
+export function createAbortRuntime(params) {
+    const abortController = new AbortController();
+    const timeoutHandle = typeof params.timeoutMs === 'number' && params.timeoutMs > 0
+        ? setTimeout(() => abortController.abort(), params.timeoutMs)
+        : undefined;
+    const onExternalAbort = () => abortController.abort();
+    if (params.externalSignal) {
+        if (params.externalSignal.aborted) {
+            abortController.abort();
+        }
+        else {
+            params.externalSignal.addEventListener('abort', onExternalAbort, { once: true });
+        }
+    }
+    const cleanup = () => {
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+        if (params.externalSignal) {
+            params.externalSignal.removeEventListener('abort', onExternalAbort);
+        }
+    };
+    return { signal: abortController.signal, cleanup };
+}
+export function prepareAiSdkAttempt(params) {
+    const startedAt = Date.now();
+    const auditCtx = getAuditContext();
+    const { signal: abortSignal, cleanup } = createAbortRuntime({
+        timeoutMs: params.timeoutMs,
+        externalSignal: params.externalSignal,
+    });
+    const langfuseHeaders = buildLangfuseHeaders(params.langfuseEnabled, {
+        runId: auditCtx.correlationId,
+        phase: auditCtx.phase,
+        observationName: auditCtx.observationName,
+        observationId: `${params.requestId}-a${params.attempt}`,
+        sessionId: auditCtx.sessionId,
+        userId: auditCtx.userId,
+    });
+    const toolCount = params.tools ? Object.keys(params.tools).length : 0;
+    return {
+        startedAt,
+        auditCtx,
+        abortSignal,
+        cleanup,
+        langfuseHeaders,
+        toolCount,
+    };
+}
+export function recordAiSdkRequestSuccess(input) {
+    recordAuditEvent('llm.request', {
+        requestId: input.requestId,
+        runId: input.auditCtx.correlationId,
+        phase: input.auditCtx.phase,
+        provider: 'ai-sdk',
+        streamed: input.streamed,
+        modelId: input.modelId,
+        attempt: input.attempt,
+        durationMs: Date.now() - input.startedAt,
+        toolCount: input.toolCount,
+        status: 'ok',
+    }, { source: 'llm', severity: 'low', scope: 'session' });
+}
+export function recordAiSdkRequestError(input) {
+    const cls = classifyRetryableApiError(input.error);
+    recordAuditEvent('llm.request', {
+        requestId: input.requestId,
+        runId: input.auditCtx.correlationId,
+        phase: input.auditCtx.phase,
+        provider: 'ai-sdk',
+        streamed: input.streamed,
+        modelId: input.modelId,
+        attempt: input.attempt,
+        durationMs: Date.now() - input.startedAt,
+        toolCount: input.toolCount,
+        status: 'error',
+        statusCode: cls.statusCode,
+        networkCode: cls.networkCode,
+        retryable: cls.retryable,
+        retryReason: cls.reason,
+    }, { source: 'llm', severity: 'low', scope: 'session' });
+}
+export function createAiSdkRetryLogger(params) {
+    return ({ attempt, delayMs, error }) => {
+        const cls = classifyRetryableApiError(error);
+        recordAuditEvent('llm.retry', {
+            provider: 'ai-sdk',
+            modelId: params.modelId,
+            streamed: params.streamed,
+            attempt,
+            delayMs,
+            reason: cls.reason,
+            statusCode: cls.statusCode,
+            networkCode: cls.networkCode,
+        }, { source: 'llm', severity: 'low', scope: 'session' });
+    };
+}
+export function isRetryableAiSdkError(error) {
+    return classifyRetryableApiError(error).retryable;
+}
+export async function executeAiSdkAttempt(input) {
+    const attemptCtx = input.prepare();
+    try {
+        const result = await input.run(attemptCtx);
+        recordAiSdkRequestSuccess({
+            requestId: input.requestId,
+            modelId: input.modelId,
+            attempt: input.attempt,
+            startedAt: attemptCtx.startedAt,
+            toolCount: attemptCtx.toolCount,
+            streamed: input.streamed,
+            auditCtx: attemptCtx.auditCtx,
+        });
+        return result;
+    }
+    catch (error) {
+        recordAiSdkRequestError({
+            requestId: input.requestId,
+            modelId: input.modelId,
+            attempt: input.attempt,
+            startedAt: attemptCtx.startedAt,
+            toolCount: attemptCtx.toolCount,
+            streamed: input.streamed,
+            auditCtx: attemptCtx.auditCtx,
+            error,
+        });
+        throw error;
+    }
+    finally {
+        attemptCtx.cleanup();
+    }
+}
+export async function* executeAiSdkStreamAttempt(input) {
+    const attemptCtx = input.prepare();
+    try {
+        for await (const item of input.run(attemptCtx)) {
+            yield item;
+        }
+        recordAiSdkRequestSuccess({
+            requestId: input.requestId,
+            modelId: input.modelId,
+            attempt: input.attempt,
+            startedAt: attemptCtx.startedAt,
+            toolCount: attemptCtx.toolCount,
+            streamed: input.streamed,
+            auditCtx: attemptCtx.auditCtx,
+        });
+    }
+    catch (error) {
+        recordAiSdkRequestError({
+            requestId: input.requestId,
+            modelId: input.modelId,
+            attempt: input.attempt,
+            startedAt: attemptCtx.startedAt,
+            toolCount: attemptCtx.toolCount,
+            streamed: input.streamed,
+            auditCtx: attemptCtx.auditCtx,
+            error,
+        });
+        throw error;
+    }
+    finally {
+        attemptCtx.cleanup();
+    }
+}
+//# sourceMappingURL=request-runtime.js.map

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

@@ -0,0 +1,31 @@
+import { mapAiSdkStreamPartToChunk } from '../stream-utils.js';
+import { toOpenAiToolCalls } from './message-mapper.js';
+export function mapAiSdkGenerateResultToMessage(result) {
+    return {
+        role: 'assistant',
+        content: result?.text || '',
+        tool_calls: toOpenAiToolCalls(result?.toolCalls),
+    };
+}
+export async function* mapAiSdkStreamResultToChunks(fullStream) {
+    let doneEmitted = false;
+    for await (const part of fullStream) {
+        if (!part)
+            continue;
+        if (part.type === 'error')
+            throw part.error;
+        if (part.type === 'abort')
+            throw new Error('Stream aborted');
+        const chunk = mapAiSdkStreamPartToChunk(part);
+        if (!chunk)
+            continue;
+        if (chunk.done) {
+            doneEmitted = true;
+        }
+        yield chunk;
+    }
+    if (!doneEmitted) {
+        yield { role: 'assistant', done: true, finishReason: 'unknown' };
+    }
+}
+//# sourceMappingURL=result-mapper.js.map

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

@@ -0,0 +1,82 @@
+function unwrapRetryError(err) {
+    if (!err || typeof err !== 'object')
+        return err;
+    const candidate = err;
+    if (candidate.lastError)
+        return candidate.lastError;
+    return err;
+}
+function findStatusCode(err) {
+    const unwrapped = unwrapRetryError(err);
+    if (!unwrapped || typeof unwrapped !== 'object')
+        return undefined;
+    const obj = unwrapped;
+    const direct = obj.statusCode;
+    if (typeof direct === 'number' && Number.isFinite(direct))
+        return direct;
+    const response = obj.response;
+    if (response && typeof response === 'object') {
+        const status = response.status;
+        if (typeof status === 'number' && Number.isFinite(status))
+            return status;
+    }
+    return undefined;
+}
+function findNetworkCode(err) {
+    const unwrapped = unwrapRetryError(err);
+    if (!unwrapped || typeof unwrapped !== 'object')
+        return undefined;
+    const obj = unwrapped;
+    const code = obj.code;
+    if (typeof code === 'string')
+        return code;
+    const cause = obj.cause;
+    if (cause && typeof cause === 'object' && typeof cause.code === 'string') {
+        return cause.code;
+    }
+    return undefined;
+}
+function isAbortLikeError(err) {
+    const unwrapped = unwrapRetryError(err);
+    const name = unwrapped instanceof Error ? unwrapped.name : '';
+    const msg = String(unwrapped?.message ?? unwrapped).toLowerCase();
+    return name === 'AbortError' || msg.includes('aborted');
+}
+export function classifyRetryableApiError(err) {
+    if (isAbortLikeError(err))
+        return { retryable: false, reason: 'aborted' };
+    const statusCode = findStatusCode(err);
+    const networkCode = findNetworkCode(err);
+    const msg = String(unwrapRetryError(err)?.message ?? err).toLowerCase();
+    if (statusCode === 408)
+        return { retryable: true, reason: 'timeout', statusCode, networkCode };
+    if (statusCode === 429)
+        return { retryable: true, reason: 'rate_limit', statusCode, networkCode };
+    if (typeof statusCode === 'number') {
+        const retryable5xx = new Set([502, 503, 504, 521, 522, 524, 529]);
+        if (retryable5xx.has(statusCode)) {
+            return { retryable: true, reason: 'server_error', statusCode, networkCode };
+        }
+    }
+    if (msg.includes('timeout')) {
+        return { retryable: true, reason: 'timeout', statusCode, networkCode };
+    }
+    if (msg.includes('rate limit')) {
+        return { retryable: true, reason: 'rate_limit', statusCode, networkCode };
+    }
+    if (msg.includes('overloaded')) {
+        return { retryable: true, reason: 'overloaded', statusCode, networkCode };
+    }
+    if (typeof networkCode === 'string') {
+        const normalized = networkCode.toUpperCase();
+        if (normalized === 'ECONNRESET' ||
+            normalized === 'ETIMEDOUT' ||
+            normalized === 'EAI_AGAIN' ||
+            normalized === 'ENOTFOUND' ||
+            normalized === 'ECONNREFUSED') {
+            return { retryable: true, reason: 'network', statusCode, networkCode: normalized };
+        }
+    }
+    return { retryable: false, reason: 'non_retryable', statusCode, networkCode };
+}
+//# sourceMappingURL=retry-classifier.js.map

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

@@ -0,0 +1,38 @@
+import { toLlmError } from '../errors.js';
+import { withRetry, withStreamRetry } from '../retry-utils.js';
+import { createAiSdkRetryLogger, isRetryableAiSdkError } from './request-runtime.js';
+const DEFAULT_AI_SDK_RETRY_OPTIONS = {
+    maxRetries: 2,
+    jitterRatio: 0.2,
+};
+export async function executeWithAiSdkRetry(params) {
+    const options = {
+        ...DEFAULT_AI_SDK_RETRY_OPTIONS,
+        ...params.retryOptions,
+        signal: params.signal,
+        retryableErrors: isRetryableAiSdkError,
+        onRetry: createAiSdkRetryLogger({ modelId: params.modelId, streamed: params.streamed }),
+    };
+    try {
+        return await withRetry(params.run, options);
+    }
+    catch (error) {
+        throw toLlmError(error, 'ai-sdk');
+    }
+}
+export async function* executeWithAiSdkStreamRetry(params) {
+    const options = {
+        ...DEFAULT_AI_SDK_RETRY_OPTIONS,
+        ...params.retryOptions,
+        signal: params.signal,
+        retryableErrors: isRetryableAiSdkError,
+        onRetry: createAiSdkRetryLogger({ modelId: params.modelId, streamed: true }),
+    };
+    try {
+        yield* withStreamRetry(params.run, options);
+    }
+    catch (error) {
+        throw toLlmError(error, 'ai-sdk');
+    }
+}
+//# sourceMappingURL=retry-executor.js.map