salmon-loop 0.2.3 → 0.2.16

package/dist/core/protocols/shared/flow-mode-mapping.js

@@ -0,0 +1,23 @@
+import { FLOW_MODE_PUBLIC_METADATA } from '../../public-capabilities/flow-mode-metadata.js';
+import { FLOW_MODES, parseFlowMode } from '../../types/flow-mode.js';
+export const SUPPORTED_PROTOCOL_FLOW_MODES = FLOW_MODES;
+export function parseAcpFlowMode(value) {
+    const normalized = String(value ?? '')
+        .trim()
+        .toLowerCase();
+    if (normalized === 'interactive' || normalized === 'yolo') {
+        return 'autopilot';
+    }
+    return parseFlowMode(normalized);
+}
+export function parseA2ASkillFlowMode(value) {
+    return parseFlowMode(value);
+}
+export function buildA2AFlowSkills() {
+    return SUPPORTED_PROTOCOL_FLOW_MODES.map((mode) => ({
+        id: mode,
+        title: FLOW_MODE_PUBLIC_METADATA[mode].a2aTitle,
+        description: FLOW_MODE_PUBLIC_METADATA[mode].description,
+    }));
+}
+//# sourceMappingURL=flow-mode-mapping.js.map

package/dist/core/public-capabilities/flow-mode-metadata.js

@@ -0,0 +1,39 @@
+export const FLOW_MODE_PUBLIC_METADATA = {
+    autopilot: {
+        publicTitle: 'Autopilot',
+        a2aTitle: 'Autopilot',
+        acpName: 'Autopilot',
+        description: 'Let the agent decide which actions and tools to use.',
+    },
+    patch: {
+        publicTitle: 'Patch code',
+        a2aTitle: 'Patch code',
+        acpName: 'Patch',
+        description: 'Apply code changes with verification.',
+    },
+    review: {
+        publicTitle: 'Review code',
+        a2aTitle: 'Review code',
+        acpName: 'Review',
+        description: 'Inspect code and report findings without mutating files.',
+    },
+    debug: {
+        publicTitle: 'Debug issue',
+        a2aTitle: 'Debug issue',
+        acpName: 'Debug',
+        description: 'Investigate issues and make targeted fixes when needed.',
+    },
+    research: {
+        publicTitle: 'Research request',
+        a2aTitle: 'Research request',
+        acpName: 'Research',
+        description: 'Explore the codebase and summarize relevant findings.',
+    },
+    answer: {
+        publicTitle: 'Answer question',
+        a2aTitle: 'Answer question',
+        acpName: 'Answer',
+        description: 'Answer questions directly without editing files.',
+    },
+};
+//# sourceMappingURL=flow-mode-metadata.js.map

package/dist/core/public-capabilities/projections.js

@@ -0,0 +1,29 @@
+import { FLOW_MODE_PUBLIC_METADATA } from './flow-mode-metadata.js';
+import { buildPublicCapabilityRegistry } from './registry.js';
+export function selectPublicCapabilitiesForSurface(surface, entries = buildPublicCapabilityRegistry()) {
+    return entries.filter((entry) => entry.reachability === 'reachable' && entry.surfaces[surface]);
+}
+function isFlowModeCapability(entry) {
+    return entry.kind === 'flow_mode';
+}
+export function toAcpPublicModes(entries = buildPublicCapabilityRegistry()) {
+    return selectPublicCapabilitiesForSurface('acp', entries)
+        .filter(isFlowModeCapability)
+        .map((entry) => ({
+        id: entry.target,
+        name: FLOW_MODE_PUBLIC_METADATA[entry.target].acpName,
+        description: entry.description,
+    }));
+}
+export function toA2APublicSkills(entries = buildPublicCapabilityRegistry()) {
+    return selectPublicCapabilitiesForSurface('a2a', entries).map((entry) => ({
+        id: entry.id,
+        title: entry.title,
+        description: entry.description,
+        tags: entry.tags,
+        examples: entry.examples,
+        inputModes: entry.inputModes,
+        outputModes: entry.outputModes,
+    }));
+}
+//# sourceMappingURL=projections.js.map

package/dist/core/public-capabilities/registry.js

@@ -0,0 +1,26 @@
+import { FLOW_MODES } from '../types/flow-mode.js';
+import { FLOW_MODE_PUBLIC_METADATA } from './flow-mode-metadata.js';
+function getFlowModeSurfaces(mode) {
+    if (mode === 'autopilot') {
+        return {
+            a2a: true,
+            acp: true,
+        };
+    }
+    return {
+        a2a: false,
+        acp: true,
+    };
+}
+export function buildPublicCapabilityRegistry() {
+    return FLOW_MODES.map((mode) => ({
+        id: mode,
+        kind: 'flow_mode',
+        target: mode,
+        title: FLOW_MODE_PUBLIC_METADATA[mode].publicTitle,
+        description: FLOW_MODE_PUBLIC_METADATA[mode].description,
+        surfaces: getFlowModeSurfaces(mode),
+        reachability: 'reachable',
+    }));
+}
+//# sourceMappingURL=registry.js.map

package/dist/core/public-capabilities/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/runtime/agent-server-runtime.js

@@ -3,7 +3,6 @@ import { createTaskEventBus } from '../interaction/events/bus.js';
 import { createInteractionFacade } from '../interaction/orchestration/facade.js';
 import { createA2AInteractionExecutor } from '../protocols/a2a/sdk/executor.js';
 import { createA2ASdkExpressApp } from '../protocols/a2a/sdk/server.js';
-import { createSidecarFastifyPlugin, } from './sidecar-fastify-plugin.js';
 export function createAgentServerRuntime(deps) {
     const eventBus = deps.a2a.eventBus ?? createTaskEventBus();
     const taskStore = deps.a2a.taskStore ?? new InMemoryTaskStore();
@@ -20,67 +19,72 @@ export function createAgentServerRuntime(deps) {
         taskEventBus: eventBus,
         taskStore,
     });
-    const agentCard = deps.a2a.buildAgentCard();
-    const a2aApp = createA2ASdkExpressApp({
-        agentCard,
+    const a2aServer = (deps.createA2AServerApp ?? createA2ASdkExpressApp)({
+        agentCard: deps.a2a.buildAgentCard(),
         agentExecutor: executor,
         taskStore,
         userBuilder: deps.a2a.userBuilder,
         authMiddleware: deps.a2a.authMiddleware,
     });
-    const sidecarPlugin = createSidecarFastifyPlugin({
-        routes: deps.sidecar.routes,
-        scope: deps.listen.sidecar.type === 'tcp' ? 'tcp' : 'uds',
-        allowConditional: deps.sidecar.allowConditional,
-        authorize: deps.sidecar.authorize,
-        baseUrl: deps.sidecar.baseUrl,
-    });
-    const sidecarServer = deps.createFastify();
     let a2aServerInstance = null;
-    let sidecarServerInstance = null;
     let started = false;
+    let starting = false;
     async function start() {
-        if (started) {
+        if (started || starting) {
             throw new Error('Runtime already started');
         }
-        if (deps.configureA2A) {
-            await deps.configureA2A(a2aApp);
-        }
-        if (deps.configureSidecar) {
-            await deps.configureSidecar(sidecarServer);
-        }
-        await sidecarServer.register(sidecarPlugin);
-        a2aServerInstance = await new Promise((resolve, reject) => {
-            const server = a2aApp.listen(deps.listen.a2a.port, deps.listen.a2a.host ?? '0.0.0.0', (err) => {
-                if (err)
-                    reject(err);
-                else
+        starting = true;
+        try {
+            if (deps.configureA2A) {
+                await deps.configureA2A(a2aServer);
+            }
+            a2aServerInstance = await new Promise((resolve, reject) => {
+                const server = a2aServer.listen(deps.listen.a2a.port, deps.listen.a2a.host ?? '0.0.0.0');
+                const cleanup = () => {
+                    server.off('error', onError);
+                    server.off('listening', onListening);
+                };
+                const onError = (error) => {
+                    cleanup();
+                    reject(error);
+                };
+                const onListening = () => {
+                    cleanup();
                     resolve(server);
+                };
+                server.once('error', onError);
+                server.once('listening', onListening);
             });
-        });
-        const sidecarListenOpts = deps.listen.sidecar.type === 'tcp'
-            ? { port: deps.listen.sidecar.port, host: deps.listen.sidecar.host }
-            : { path: deps.listen.sidecar.path };
-        sidecarServerInstance = await sidecarServer.listen(sidecarListenOpts);
-        started = true;
-    }
-    async function close() {
-        if (a2aServerInstance) {
-            await new Promise((resolve) => {
-                a2aServerInstance.close(() => resolve());
-            });
+            started = true;
+        }
+        catch (error) {
             a2aServerInstance = null;
+            throw error;
+        }
+        finally {
+            starting = false;
         }
-        if (sidecarServerInstance) {
-            await sidecarServer.close();
-            sidecarServerInstance = null;
+    }
+    async function close() {
+        if (!a2aServerInstance) {
+            started = false;
+            return;
         }
+        await new Promise((resolve, reject) => {
+            a2aServerInstance.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+        a2aServerInstance = null;
         started = false;
     }
     return {
         eventBus,
-        a2aServer: a2aApp,
-        sidecarServer,
+        a2aServer,
         start,
         close,
     };

package/dist/core/runtime/execution-profile.js

@@ -0,0 +1,67 @@
+import { Phase } from '../types/runtime.js';
+const RECIPE_ENTRY_PHASE = Phase.PLAN;
+const RECIPE_PROFILES = {
+    patch: {
+        mode: 'patch',
+        driver: 'recipe',
+        readOnly: false,
+        ignoreDirtyPreflight: false,
+        failurePolicy: 'rollback',
+        verifyPolicy: 'required_before_success_if_mutated',
+        entryPhase: RECIPE_ENTRY_PHASE,
+    },
+    review: {
+        mode: 'review',
+        driver: 'recipe',
+        readOnly: true,
+        ignoreDirtyPreflight: true,
+        failurePolicy: 'rollback',
+        verifyPolicy: 'never',
+        entryPhase: RECIPE_ENTRY_PHASE,
+    },
+    debug: {
+        mode: 'debug',
+        driver: 'recipe',
+        readOnly: false,
+        ignoreDirtyPreflight: false,
+        failurePolicy: 'rollback',
+        verifyPolicy: 'required_before_success_if_mutated',
+        entryPhase: RECIPE_ENTRY_PHASE,
+    },
+    research: {
+        mode: 'research',
+        driver: 'recipe',
+        readOnly: true,
+        ignoreDirtyPreflight: true,
+        failurePolicy: 'rollback',
+        verifyPolicy: 'never',
+        entryPhase: RECIPE_ENTRY_PHASE,
+    },
+    answer: {
+        mode: 'answer',
+        driver: 'recipe',
+        readOnly: true,
+        ignoreDirtyPreflight: true,
+        failurePolicy: 'rollback',
+        verifyPolicy: 'never',
+        entryPhase: RECIPE_ENTRY_PHASE,
+    },
+};
+const AUTOPILOT_PROFILE = {
+    mode: 'autopilot',
+    driver: 'agent',
+    readOnly: false,
+    defaultPermissionMode: 'yolo',
+    defaultCheckpointStrategy: 'direct',
+    ignoreDirtyPreflight: true,
+    failurePolicy: 'preserve',
+    verifyPolicy: 'required_before_success_if_mutated',
+    entryPhase: Phase.AUTOPILOT,
+};
+export function resolveExecutionProfile(mode) {
+    if (mode === 'autopilot') {
+        return AUTOPILOT_PROFILE;
+    }
+    return RECIPE_PROFILES[mode];
+}
+//# sourceMappingURL=execution-profile.js.map

package/dist/core/session/artifact-state.js

@@ -0,0 +1,160 @@
+import { createToolResultIdentity, freezeToolResultReplacementDecision, } from './replacement-state.js';
+const MAX_SUBAGENT_ARTIFACTS = 4;
+const MAX_READ_ARTIFACTS = 6;
+const MAX_PREVIEW_ARTIFACTS = 6;
+function isArtifactHandle(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return (typeof candidate.handle === 'string' &&
+        typeof candidate.mimeType === 'string' &&
+        typeof candidate.sha256 === 'string' &&
+        typeof candidate.size === 'number');
+}
+function cloneArtifactHandle(artifact) {
+    if (!artifact)
+        return undefined;
+    return {
+        handle: artifact.handle,
+        mimeType: artifact.mimeType,
+        sha256: artifact.sha256,
+        size: artifact.size,
+    };
+}
+function normalizeArtifactHandles(artifacts, limit) {
+    if (!Array.isArray(artifacts) || artifacts.length === 0)
+        return undefined;
+    const unique = [];
+    const seen = new Set();
+    for (const artifact of artifacts) {
+        if (!isArtifactHandle(artifact))
+            continue;
+        if (seen.has(artifact.handle))
+            continue;
+        seen.add(artifact.handle);
+        unique.push(cloneArtifactHandle(artifact));
+    }
+    if (unique.length === 0)
+        return undefined;
+    return unique.slice(-limit);
+}
+function normalizeReadArtifacts(artifacts, limit) {
+    if (!Array.isArray(artifacts) || artifacts.length === 0)
+        return undefined;
+    const unique = [];
+    const seen = new Set();
+    for (const item of artifacts) {
+        const path = typeof item?.path === 'string' ? item.path.trim() : '';
+        if (!path || !isArtifactHandle(item?.artifact))
+            continue;
+        const key = `${path}::${item.artifact.handle}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push({
+            path,
+            artifact: cloneArtifactHandle(item.artifact),
+        });
+    }
+    if (unique.length === 0)
+        return undefined;
+    return unique.slice(-limit);
+}
+function normalizePreviewArtifacts(artifacts, limit) {
+    if (!Array.isArray(artifacts) || artifacts.length === 0)
+        return undefined;
+    const unique = [];
+    const seen = new Set();
+    for (const item of artifacts) {
+        const label = typeof item?.label === 'string' ? item.label.trim() : '';
+        if (!label || !isArtifactHandle(item?.artifact))
+            continue;
+        const key = `${label}::${item.artifact.handle}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push({
+            label,
+            artifact: cloneArtifactHandle(item.artifact),
+        });
+    }
+    if (unique.length === 0)
+        return undefined;
+    return unique.slice(-limit);
+}
+function hasAnyArtifactState(state) {
+    return Boolean(state.verifyArtifact ||
+        state.subAgentPatchArtifacts?.length ||
+        state.subAgentAuditArtifacts?.length ||
+        state.recentReadArtifacts?.length ||
+        state.toolResultPreviewArtifacts?.length);
+}
+export function normalizeSessionArtifactState(state) {
+    if (!state)
+        return undefined;
+    const normalized = {
+        verifyArtifact: isArtifactHandle(state.verifyArtifact)
+            ? cloneArtifactHandle(state.verifyArtifact)
+            : undefined,
+        subAgentPatchArtifacts: normalizeArtifactHandles(state.subAgentPatchArtifacts, MAX_SUBAGENT_ARTIFACTS),
+        subAgentAuditArtifacts: normalizeArtifactHandles(state.subAgentAuditArtifacts, MAX_SUBAGENT_ARTIFACTS),
+        recentReadArtifacts: normalizeReadArtifacts(state.recentReadArtifacts, MAX_READ_ARTIFACTS),
+        toolResultPreviewArtifacts: normalizePreviewArtifacts(state.toolResultPreviewArtifacts, MAX_PREVIEW_ARTIFACTS),
+    };
+    return hasAnyArtifactState(normalized) ? normalized : undefined;
+}
+export function mergeSessionArtifactState(existing, incoming) {
+    const base = normalizeSessionArtifactState(existing);
+    const next = normalizeSessionArtifactState(incoming);
+    if (!base)
+        return next;
+    if (!next)
+        return base;
+    return normalizeSessionArtifactState({
+        verifyArtifact: next.verifyArtifact ?? base.verifyArtifact,
+        subAgentPatchArtifacts: [
+            ...(base.subAgentPatchArtifacts ?? []),
+            ...(next.subAgentPatchArtifacts ?? []),
+        ],
+        subAgentAuditArtifacts: [
+            ...(base.subAgentAuditArtifacts ?? []),
+            ...(next.subAgentAuditArtifacts ?? []),
+        ],
+        recentReadArtifacts: [...(base.recentReadArtifacts ?? []), ...(next.recentReadArtifacts ?? [])],
+        toolResultPreviewArtifacts: [
+            ...(base.toolResultPreviewArtifacts ?? []),
+            ...(next.toolResultPreviewArtifacts ?? []),
+        ],
+    });
+}
+export function buildSessionArtifactStateFromLoopResult(result) {
+    const hints = result.artifactHints;
+    const withVerifyFallback = hints || result.verifyArtifact
+        ? {
+            ...hints,
+            verifyArtifact: hints?.verifyArtifact ?? result.verifyArtifact,
+        }
+        : undefined;
+    return normalizeSessionArtifactState(withVerifyFallback);
+}
+export function mergeReplacementStateFromArtifactHints(existing, artifactHints, now = () => Date.now()) {
+    let next = existing;
+    for (const item of artifactHints?.toolResultPreviewArtifacts ?? []) {
+        const toolResultId = createToolResultIdentity({
+            canonicalToolCallIdentity: item.label,
+            payload: {
+                label: item.label,
+                handle: item.artifact.handle,
+            },
+        });
+        next = freezeToolResultReplacementDecision(next, {
+            toolResultId,
+            decision: 'replaced',
+            preview: item.label,
+            sourceArtifactHandle: item.artifact.handle,
+            frozenAt: now(),
+        }, { maxEntries: 256 });
+    }
+    return next;
+}
+//# sourceMappingURL=artifact-state.js.map

package/dist/core/session/compaction/index.js

@@ -0,0 +1,183 @@
+import { getModelRecommendedBudget } from '../../context/token/adaptive-budget.js';
+import { LlmError } from '../../llm/errors.js';
+import { getLogger } from '../../observability/logger.js';
+import { refreshSessionSummary } from '../summary-sync.js';
+import { TokenTracker } from '../token-tracker.js';
+import { isCircuitBreakerTripped, onCompactionFailure, onCompactionSuccess } from './tracking.js';
+import { DEFAULT_AUTOCOMPACT_CONFIG } from './types.js';
+function isContextOverflowLike(error) {
+    if (error instanceof LlmError && error.llmCode === 'LLM_CONTEXT_LENGTH_EXCEEDED') {
+        return true;
+    }
+    const message = error instanceof Error
+        ? error.message
+        : error && typeof error === 'object' && typeof error.message === 'string'
+            ? String(error.message)
+            : '';
+    if (!message)
+        return false;
+    const lower = message.toLowerCase();
+    return (lower.includes('maximum context length') ||
+        lower.includes('context length') ||
+        lower.includes('too many tokens') ||
+        lower.includes('prompt is too long') ||
+        lower.includes('input is too long') ||
+        lower.includes('reduce the length') ||
+        lower.includes('please reduce'));
+}
+/**
+ * Autocompact (Level 1)
+ *
+ * Triggered when token count exceeds threshold.
+ * Uses existing summarization infrastructure to reduce context.
+ */
+export async function autocompact(params) {
+    const { sessionManager, llm, tracking, contextHash } = params;
+    const trigger = params.trigger ?? 'auto';
+    const modelId = llm.getModelId?.();
+    // Resolve dynamic threshold if not provided in config
+    let resolvedThreshold = params.config?.tokenThreshold;
+    if (resolvedThreshold === undefined) {
+        if (modelId) {
+            try {
+                resolvedThreshold = getModelRecommendedBudget(modelId);
+            }
+            catch (_error) {
+                // Fallback to default if resolution fails
+                resolvedThreshold = DEFAULT_AUTOCOMPACT_CONFIG.tokenThreshold;
+            }
+        }
+        else {
+            resolvedThreshold = DEFAULT_AUTOCOMPACT_CONFIG.tokenThreshold;
+        }
+    }
+    const config = {
+        ...DEFAULT_AUTOCOMPACT_CONFIG,
+        ...params.config,
+        tokenThreshold: resolvedThreshold,
+    };
+    // 1. Check circuit breaker
+    if (isCircuitBreakerTripped(tracking, config.maxFailures)) {
+        getLogger().audit('COMPACTION_SKIP', {
+            reason: 'circuit_breaker',
+            trigger,
+            modelId: modelId ?? 'unknown',
+            tokenThreshold: config.tokenThreshold,
+            consecutiveFailures: tracking.consecutiveFailures,
+            maxFailures: config.maxFailures,
+        }, {
+            source: 'session',
+            severity: 'low',
+            scope: 'session',
+            phase: 'COMPACTION',
+        });
+        return { performed: false, tracking };
+    }
+    // 2. Check threshold (only for auto trigger)
+    const messages = sessionManager.getMessages();
+    const totalTokens = TokenTracker.estimateMessagesTokens(messages);
+    if (trigger === 'auto' && totalTokens < config.tokenThreshold) {
+        getLogger().audit('COMPACTION_SKIP', {
+            reason: 'below_threshold',
+            trigger,
+            modelId: modelId ?? 'unknown',
+            preTokens: totalTokens,
+            tokenThreshold: config.tokenThreshold,
+        }, {
+            source: 'session',
+            severity: 'low',
+            scope: 'session',
+            phase: 'COMPACTION',
+        });
+        return { performed: false, tracking };
+    }
+    // 3. Perform summarization
+    try {
+        // Reuse existing refreshSessionSummary with 'force' strategy
+        // This will trigger the ConversationSummarizer logic
+        const summaryResult = await refreshSessionSummary({
+            sessionManager,
+            llm,
+            contextHash,
+            strategy: 'force',
+            strict: true,
+        });
+        if (!summaryResult.didSummarize) {
+            getLogger().audit('COMPACTION_SKIP', {
+                reason: 'no_op',
+                trigger,
+                modelId: modelId ?? 'unknown',
+                preTokens: totalTokens,
+                tokenThreshold: config.tokenThreshold,
+            }, {
+                source: 'session',
+                severity: 'low',
+                scope: 'session',
+                phase: 'COMPACTION',
+            });
+            return { performed: false, tracking };
+        }
+        const updatedSummary = sessionManager.getSummaryState();
+        getLogger().audit(`COMPACTION_${trigger.toUpperCase()}COMPACT`, {
+            trigger,
+            modelId: modelId ?? 'unknown',
+            preTokens: totalTokens,
+            tokenThreshold: config.tokenThreshold,
+            summaryTokens: updatedSummary?.summaryTokens,
+            hasRecoveryState: Boolean(updatedSummary?.recoveryState),
+            circuitBreakerState: { consecutiveFailures: 0 },
+        }, {
+            source: 'session',
+            severity: 'medium',
+            scope: 'session',
+            phase: 'COMPACTION',
+        });
+        return {
+            performed: true,
+            tracking: onCompactionSuccess(tracking),
+            preTokens: totalTokens,
+            trigger: trigger,
+        };
+    }
+    catch (error) {
+        const newTracking = onCompactionFailure(tracking);
+        getLogger().audit('COMPACTION_FAILURE', {
+            error: error instanceof Error ? error.message : String(error),
+            consecutiveFailures: newTracking.consecutiveFailures,
+            trigger,
+        }, {
+            source: 'session',
+            severity: 'medium',
+            scope: 'session',
+            phase: 'COMPACTION',
+        });
+        return {
+            performed: false,
+            tracking: newTracking,
+        };
+    }
+}
+/**
+ * Reactive Compact (Level 2)
+ *
+ * Emergency compaction when LLM returns prompt-too-long error.
+ */
+export async function reactiveCompact(params) {
+    if (!isContextOverflowLike(params.error)) {
+        return { performed: false, tracking: params.tracking };
+    }
+    return autocompact({
+        ...params,
+        trigger: 'reactive',
+    });
+}
+/**
+ * Main Compaction Pipeline entry point
+ */
+export async function runCompactionPipeline(params) {
+    // Level 0 (Microcompact) is already integrated into buildEffectiveConversationContext
+    // and refreshSessionSummary.
+    // Level 1: Autocompact
+    return autocompact(params);
+}
+//# sourceMappingURL=index.js.map