salmon-loop 0.2.3

package/dist/core/interaction/orchestration/facade.js

@@ -0,0 +1,190 @@
+import { createTaskTransitionPolicy, } from '../model/index.js';
+import { InMemoryTaskStore } from './store.js';
+export function createInteractionFacade(deps) {
+    const store = new InMemoryTaskStore();
+    const transitionPolicy = createTaskTransitionPolicy();
+    const taskControllers = new Map();
+    function updateTask(id, nextState, mutate) {
+        const task = store.get(id);
+        if (!task)
+            return null;
+        if (!transitionPolicy.allows(task.state, nextState))
+            return null;
+        return store.update(mutate(task));
+    }
+    return {
+        async createTask(input) {
+            const controller = new AbortController();
+            const task = {
+                // Use provided taskId (from A2A SDK) or generate one for standalone usage
+                id: input.taskId ?? `task_${Date.now()}`,
+                capability: input.capability,
+                state: 'accepted',
+                request: input.request,
+                createdAt: new Date().toISOString(),
+                attempt: 1,
+            };
+            store.save(task);
+            taskControllers.set(task.id, controller);
+            deps.eventBus?.publish({ type: 'task.accepted', taskId: task.id });
+            void deps
+                .executeTask(task, {
+                onEvent: input.onEvent,
+                signal: controller.signal,
+                authorizationProvider: input.authorizationProvider,
+                authorizationMode: input.authorizationMode,
+                commandRunner: input.commandRunner,
+                fileSystemOverride: input.fileSystemOverride,
+            })
+                .then((result) => {
+                taskControllers.delete(task.id);
+                store.update(result);
+                if (result.state === 'completed') {
+                    deps.eventBus?.publish({ type: 'task.completed', taskId: result.id });
+                }
+                else if (result.state === 'failed') {
+                    deps.eventBus?.publish({ type: 'task.failed', taskId: result.id });
+                }
+                else if (result.state === 'awaiting_input') {
+                    deps.eventBus?.publish({ type: 'task.awaiting_input', taskId: result.id });
+                }
+            });
+            return { task, signal: controller.signal };
+        },
+        async getTask(id) {
+            return store.get(id);
+        },
+        async cancelTask(id) {
+            const controller = taskControllers.get(id);
+            if (controller) {
+                controller.abort();
+            }
+            const cancelled = updateTask(id, 'cancelled', (task) => ({
+                ...task,
+                state: 'cancelled',
+            }));
+            if (!cancelled)
+                return null;
+            deps.eventBus?.publish({
+                type: 'task.cancelled',
+                taskId: cancelled.id,
+                state: cancelled.state,
+                attempt: cancelled.attempt,
+            });
+            return cancelled;
+        },
+        async resumeTask(id) {
+            const resumed = updateTask(id, 'running', (task) => ({
+                ...task,
+                state: 'running',
+                statusMessage: 'Task resumed',
+                inputRequired: undefined,
+            }));
+            if (!resumed)
+                return null;
+            deps.eventBus?.publish({
+                type: 'task.resumed',
+                taskId: resumed.id,
+                state: resumed.state,
+                attempt: resumed.attempt,
+            });
+            return resumed;
+        },
+        async failTask(id, failure) {
+            const failed = updateTask(id, 'failed', (task) => ({
+                ...task,
+                state: 'failed',
+                statusMessage: failure.message,
+                failure,
+            }));
+            if (!failed)
+                return null;
+            deps.eventBus?.publish({
+                type: 'task.failed',
+                taskId: failed.id,
+                state: failed.state,
+                attempt: failed.attempt,
+                failure: { category: failed.failure?.category, code: failed.failure?.code },
+            });
+            return failed;
+        },
+        async retryTask(id) {
+            const current = store.get(id);
+            if (!current)
+                return null;
+            if (!transitionPolicy.canRetry(current))
+                return null;
+            const retried = updateTask(id, 'accepted', (task) => ({
+                ...task,
+                state: 'accepted',
+                attempt: (task.attempt ?? 1) + 1,
+                statusMessage: 'Task retried',
+                failure: undefined,
+                inputRequired: undefined,
+            }));
+            if (!retried)
+                return null;
+            deps.eventBus?.publish({
+                type: 'task.retried',
+                taskId: retried.id,
+                state: retried.state,
+                attempt: retried.attempt,
+            });
+            return retried;
+        },
+        async reopenTask(id, action) {
+            const current = store.get(id);
+            if (!current)
+                return null;
+            if (!transitionPolicy.canReopen(current))
+                return null;
+            const reopened = updateTask(id, 'awaiting_input', (task) => ({
+                ...task,
+                state: 'awaiting_input',
+                inputRequired: action,
+                statusMessage: 'Task reopened',
+            }));
+            if (!reopened)
+                return null;
+            deps.eventBus?.publish({
+                type: 'task.reopened',
+                taskId: reopened.id,
+                state: reopened.state,
+                attempt: reopened.attempt,
+                requiredAction: { type: action.type, reason: action.reason },
+            });
+            return reopened;
+        },
+        async listTasks(query) {
+            return store.list(query);
+        },
+        async submitInput(id, input) {
+            const task = store.get(id);
+            if (!task)
+                return null;
+            if (task.state !== 'awaiting_input')
+                return null;
+            if (task.inputRequired && task.inputRequired.type !== input.type)
+                return null;
+            return store.update({
+                ...task,
+                state: 'running',
+                statusMessage: `Input received: ${input.value}`,
+                inputRequired: undefined,
+            });
+        },
+        async getArtifact(id, artifactId) {
+            const task = store.get(id);
+            if (!task)
+                return null;
+            const artifact = task.artifacts?.find((candidate) => candidate.id === artifactId);
+            if (!artifact)
+                return null;
+            return {
+                ...task,
+                artifacts: [artifact],
+            };
+        },
+    };
+}
+//# sourceMappingURL=facade.js.map

package/dist/core/interaction/orchestration/index.js

@@ -0,0 +1,2 @@
+export { createInteractionFacade } from './facade.js';
+//# sourceMappingURL=index.js.map

package/dist/core/interaction/orchestration/store.js

@@ -0,0 +1,32 @@
+export class InMemoryTaskStore {
+    tasks = new Map();
+    save(task) {
+        this.tasks.set(task.id, task);
+    }
+    get(id) {
+        return this.tasks.get(id) ?? null;
+    }
+    update(task) {
+        this.tasks.set(task.id, task);
+        return task;
+    }
+    list(query) {
+        let tasks = [...this.tasks.values()];
+        if (query?.cursor) {
+            const cursorIndex = tasks.findIndex((task) => task.id === query.cursor);
+            tasks = cursorIndex >= 0 ? tasks.slice(cursorIndex + 1) : tasks;
+        }
+        if (query?.capability) {
+            tasks = tasks.filter((task) => task.capability === query.capability);
+        }
+        if (query?.state) {
+            tasks = tasks.filter((task) => task.state === query.state);
+        }
+        const items = typeof query?.limit === 'number' ? tasks.slice(0, query.limit) : tasks;
+        const nextCursor = typeof query?.limit === 'number' && tasks.length > items.length && items.length > 0
+            ? items[items.length - 1]?.id
+            : undefined;
+        return { items, nextCursor };
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/core/interaction/sync/task-sync-engine.js

@@ -0,0 +1,57 @@
+export function createTaskSyncEngine() {
+    const tasks = new Map();
+    const allowedFailureCategories = new Set([
+        'verification',
+        'runtime',
+        'policy',
+        'infrastructure',
+    ]);
+    function coerceFailureCategory(value) {
+        if (typeof value === 'string' && allowedFailureCategories.has(value)) {
+            return value;
+        }
+        return undefined;
+    }
+    function applySnapshot(task) {
+        tasks.set(task.id, task);
+        return task;
+    }
+    function applyEvent(event) {
+        const existing = tasks.get(event.taskId);
+        const base = existing ??
+            {
+                id: event.taskId,
+                capability: 'patch',
+                state: 'accepted',
+                request: { instruction: '' },
+                createdAt: new Date().toISOString(),
+            };
+        const updated = {
+            ...base,
+            state: (event.state ?? base.state),
+            attempt: event.attempt ?? base.attempt,
+            failure: event.failure
+                ? {
+                    code: event.failure.code ?? base.failure?.code ?? 'UNKNOWN',
+                    category: coerceFailureCategory(event.failure.category) ?? base.failure?.category,
+                    message: base.failure?.message ?? '',
+                    retryable: base.failure?.retryable,
+                }
+                : base.failure,
+            inputRequired: event.requiredAction
+                ? {
+                    type: event.requiredAction.type,
+                    reason: event.requiredAction.reason,
+                    prompt: base.inputRequired?.prompt ?? '',
+                }
+                : base.inputRequired,
+        };
+        tasks.set(updated.id, updated);
+        return updated;
+    }
+    function get(taskId) {
+        return tasks.get(taskId) ?? null;
+    }
+    return { applySnapshot, applyEvent, get };
+}
+//# sourceMappingURL=task-sync-engine.js.map

package/dist/core/interaction/turn-stop-reason.js

@@ -0,0 +1,27 @@
+const MAX_TOKENS_FAILURE_CODES = new Set([
+    'LLM_CONTEXT_LENGTH_EXCEEDED',
+    'LLM_MAX_TOKENS',
+    'LLM_TOKEN_LIMIT_EXCEEDED',
+]);
+const MAX_TURN_REQUESTS_FAILURE_CODES = new Set([
+    'MAX_TURN_REQUESTS_EXCEEDED',
+    'LLM_MAX_TURN_REQUESTS_EXCEEDED',
+]);
+export function inferTurnStopReasonFromFailure(failure) {
+    if (!failure)
+        return null;
+    if (failure.category === 'policy') {
+        return 'refusal';
+    }
+    if (MAX_TOKENS_FAILURE_CODES.has(failure.code)) {
+        return 'max_tokens';
+    }
+    if (MAX_TURN_REQUESTS_FAILURE_CODES.has(failure.code)) {
+        return 'max_turn_requests';
+    }
+    if (failure.code === 'LLM_HTTP_ABORTED') {
+        return 'cancelled';
+    }
+    return null;
+}
+//# sourceMappingURL=turn-stop-reason.js.map

package/dist/core/language-support/index.js

@@ -0,0 +1,3 @@
+export * from './orchestrator.js';
+export * from './strategies/index.js';
+//# sourceMappingURL=index.js.map

package/dist/core/language-support/orchestrator.js

@@ -0,0 +1,37 @@
+import { MicroTaskRunner } from '../grizzco/dsl/MicroTaskRunner.js';
+import { extensionCandidateStrategy, resolveExtensionData, } from './strategies/extension-candidate-strategy.js';
+import { languageQueryStrategy, resolveQueryData, } from './strategies/language-query-strategy.js';
+export class LanguageSupportOrchestrator {
+    queryRunner = new MicroTaskRunner({
+        strategy: languageQueryStrategy,
+        resolveData: resolveQueryData,
+        maxRounds: 5,
+        debugLabel: 'language-query',
+    });
+    extensionRunner = new MicroTaskRunner({
+        strategy: extensionCandidateStrategy,
+        resolveData: resolveExtensionData,
+        maxRounds: 3,
+        debugLabel: 'extension-candidate',
+    });
+    async getASTQuery(lang, queryType) {
+        const result = await this.queryRunner.decide({
+            lang,
+            queryType,
+            data: {},
+        });
+        return result.context.data?.pluginQuery ?? null;
+    }
+    async getExtensionCandidates(importPath, basePath) {
+        const result = await this.extensionRunner.decide({
+            importPath,
+            basePath,
+            data: {},
+        });
+        return result.context.data?.extensions ?? [];
+    }
+}
+export function createLanguageSupportOrchestrator() {
+    return new LanguageSupportOrchestrator();
+}
+//# sourceMappingURL=orchestrator.js.map

package/dist/core/language-support/strategies/extension-candidate-strategy.js

@@ -0,0 +1,27 @@
+import { tryGetPluginRegistry } from '../../plugin/registry.js';
+export function extensionCandidateStrategy(engine) {
+    engine
+        .phase('collect')
+        .requireData('extensions', 'All registered extensions from plugins')
+        .phase('build')
+        .when((ctx) => (ctx.data?.extensions?.length ?? 0) > 0, (pb) => pb.addAction('BUILD_CANDIDATES', {
+        extensions: pb.ctx.data?.extensions,
+    }))
+        .phase('resolution')
+        .setWorker('extension-resolver');
+}
+export async function resolveExtensionData(ctx, key) {
+    if (key === 'extensions') {
+        const allPlugins = tryGetPluginRegistry()?.getAll() ?? [];
+        const extensions = new Set();
+        for (const plugin of allPlugins) {
+            for (const ext of plugin.meta.extensions) {
+                const normalized = ext.startsWith('.') ? ext : `.${ext}`;
+                extensions.add(normalized);
+            }
+        }
+        return Array.from(extensions);
+    }
+    return undefined;
+}
+//# sourceMappingURL=extension-candidate-strategy.js.map

package/dist/core/language-support/strategies/index.js

@@ -0,0 +1,3 @@
+export * from './language-query-strategy.js';
+export * from './extension-candidate-strategy.js';
+//# sourceMappingURL=index.js.map

package/dist/core/language-support/strategies/language-query-strategy.js

@@ -0,0 +1,26 @@
+import { tryGetPluginRegistry } from '../../plugin/registry.js';
+export function languageQueryStrategy(engine) {
+    engine
+        .phase('discovery')
+        .requireData('pluginQuery', 'Tree-sitter query from plugin registry')
+        .phase('validation')
+        .require((ctx) => ctx.data?.pluginQuery !== undefined, 'Plugin must provide query')
+        .when((ctx) => !ctx.data?.pluginQuery, (pb) => pb.addAction('LOAD_FALLBACK_QUERY', {
+        reason: 'No plugin query available',
+        lang: pb.ctx.lang,
+    }))
+        .phase('resolution')
+        .setWorker('query-provider');
+}
+export async function resolveQueryData(ctx, key) {
+    if (key === 'pluginQuery') {
+        const plugin = tryGetPluginRegistry()?.getById(ctx.lang);
+        if (!plugin)
+            return null;
+        return ctx.queryType === 'definitions'
+            ? plugin.parsing.queries.definitions
+            : plugin.parsing.queries.references;
+    }
+    return undefined;
+}
+//# sourceMappingURL=language-query-strategy.js.map

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

@@ -0,0 +1,88 @@
+import { generateText, streamText } from 'ai';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { extractUsageFromAiSdkResult } from './message-mapper.js';
+import { buildAiSdkRequestParams } from './request-params.js';
+import { executeAiSdkAttempt, executeAiSdkStreamAttempt, prepareAiSdkAttempt, } from './request-runtime.js';
+import { mapAiSdkGenerateResultToMessage, mapAiSdkStreamResultToChunks } from './result-mapper.js';
+import { executeWithAiSdkRetry, executeWithAiSdkStreamRetry } from './retry-executor.js';
+export async function executeAiSdkChatRequest(input) {
+    let attempt = 0;
+    return executeWithAiSdkRetry({
+        signal: input.options.signal,
+        modelId: input.modelId,
+        streamed: false,
+        run: async () => {
+            attempt += 1;
+            return executeAiSdkAttempt({
+                requestId: input.requestId,
+                modelId: input.modelId,
+                attempt,
+                streamed: false,
+                prepare: () => prepareAiSdkAttempt({
+                    timeoutMs: input.timeoutMs,
+                    externalSignal: input.options.signal,
+                    langfuseEnabled: input.langfuseEnabled,
+                    requestId: input.requestId,
+                    attempt,
+                    tools: input.tools,
+                }),
+                run: async (attemptCtx) => {
+                    const result = await generateText(buildAiSdkRequestParams({
+                        model: input.model,
+                        messages: input.messages,
+                        tools: input.tools,
+                        options: input.options,
+                        headers: attemptCtx.langfuseHeaders,
+                        abortSignal: attemptCtx.abortSignal,
+                    }));
+                    const usage = extractUsageFromAiSdkResult(result);
+                    if (usage) {
+                        recordAuditEvent('llm.usage', usage, {
+                            source: 'llm',
+                            severity: 'low',
+                            scope: 'session',
+                        });
+                    }
+                    return mapAiSdkGenerateResultToMessage(result);
+                },
+            });
+        },
+    });
+}
+export async function* executeAiSdkChatStreamRequest(input) {
+    let attempt = 0;
+    const streamFactory = () => {
+        attempt += 1;
+        return executeAiSdkStreamAttempt({
+            requestId: input.requestId,
+            modelId: input.modelId,
+            attempt,
+            streamed: true,
+            prepare: () => prepareAiSdkAttempt({
+                timeoutMs: input.timeoutMs,
+                externalSignal: input.options.signal,
+                langfuseEnabled: input.langfuseEnabled,
+                requestId: input.requestId,
+                attempt,
+                tools: input.tools,
+            }),
+            run: async function* (attemptCtx) {
+                const result = await streamText(buildAiSdkRequestParams({
+                    model: input.model,
+                    messages: input.messages,
+                    tools: input.tools,
+                    options: input.options,
+                    headers: attemptCtx.langfuseHeaders,
+                    abortSignal: attemptCtx.abortSignal,
+                }));
+                yield* mapAiSdkStreamResultToChunks(result.fullStream);
+            },
+        });
+    };
+    yield* executeWithAiSdkStreamRetry({
+        run: streamFactory,
+        signal: input.options.signal,
+        modelId: input.modelId,
+    });
+}
+//# sourceMappingURL=chat-executor.js.map

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

@@ -0,0 +1,28 @@
+export function buildLangfuseHeaders(enabled, input) {
+    if (!enabled)
+        return {};
+    if (!input.runId)
+        return {};
+    const headers = {
+        langfuse_trace_id: input.runId,
+        langfuse_trace_name: 'salmonloop.run',
+    };
+    if (input.sessionId) {
+        headers.langfuse_session_id = input.sessionId;
+    }
+    if (input.userId) {
+        headers.langfuse_trace_user_id = input.userId;
+    }
+    const obsName = (input.observationName || input.phase || '').trim();
+    if (obsName)
+        headers.langfuse_observation_name = obsName;
+    if (input.observationId) {
+        headers.langfuse_observation_id = input.observationId;
+    }
+    const release = (process.env.SALMONLOOP_LANGFUSE_RELEASE || '').trim();
+    if (release) {
+        headers.langfuse_release = release;
+    }
+    return headers;
+}
+//# sourceMappingURL=langfuse-headers.js.map