@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/runtime/store/helpers/reducers/lifecycle.js

@@ -0,0 +1,393 @@
+import { now, uniq, updateDomainMetadata } from './shared.js';
+function permissionMachineStateForEvent(event) {
+    switch (event.type) {
+        case 'PERMISSION_REQUESTED':
+            return 'collect_rules';
+        case 'RULES_COLLECTED':
+            return 'normalize_input';
+        case 'INPUT_NORMALIZED':
+            return 'evaluate_policy';
+        case 'POLICY_EVALUATED':
+            return 'evaluate_runtime_mode';
+        case 'MODE_EVALUATED':
+            return 'evaluate_session_override';
+        case 'SESSION_OVERRIDE_EVALUATED':
+            return 'final_safety_checks';
+        case 'SAFETY_CHECKED':
+        case 'DECISION_EMITTED':
+            return 'decision_emitted';
+    }
+}
+function inferPermissionCategory(toolName) {
+    if (toolName === 'agent' || toolName === 'delegate')
+        return 'delegate';
+    if (toolName === 'write' || toolName === 'edit' || toolName === 'apply_patch')
+        return 'write';
+    if (toolName === 'exec' || toolName === 'precision_exec' || toolName === 'bash')
+        return 'execute';
+    return 'read';
+}
+export function updateSessionState(domain, event) {
+    const base = updateDomainMetadata(domain, event.type);
+    switch (event.type) {
+        case 'COMPACTION_CHECK':
+            return { ...base, compactionState: 'checking_threshold' };
+        case 'COMPACTION_MICROCOMPACT':
+            return { ...base, compactionState: 'microcompact' };
+        case 'COMPACTION_COLLAPSE':
+            return { ...base, compactionState: 'collapse', compactionMessageCount: event.messageCount };
+        case 'COMPACTION_AUTOCOMPACT':
+            return { ...base, compactionState: 'autocompact' };
+        case 'COMPACTION_REACTIVE':
+            return { ...base, compactionState: 'reactive_compact' };
+        case 'COMPACTION_BOUNDARY_COMMIT':
+            return { ...base, compactionState: 'boundary_commit' };
+        case 'COMPACTION_DONE':
+            return { ...base, compactionState: 'done', lastCompactedAt: now() };
+        case 'COMPACTION_FAILED':
+            return { ...base, compactionState: 'failed', recoveryError: event.error };
+        case 'COMPACTION_RESUME_REPAIR':
+            return { ...base, wasRepaired: event.repaired, recoveryState: event.safeToResume ? 'ready' : domain.recoveryState };
+        case 'COMPACTION_QUALITY_SCORE':
+        case 'COMPACTION_STRATEGY_SWITCH':
+            return base;
+    }
+}
+export function updatePermissionState(domain, event) {
+    const base = updateDomainMetadata(domain, event.type);
+    switch (event.type) {
+        case 'PERMISSION_REQUESTED':
+            return { ...base, awaitingDecision: true, decisionMachineState: permissionMachineStateForEvent(event), totalChecks: domain.totalChecks + 1 };
+        case 'RULES_COLLECTED':
+        case 'INPUT_NORMALIZED':
+        case 'POLICY_EVALUATED':
+        case 'MODE_EVALUATED':
+        case 'SESSION_OVERRIDE_EVALUATED':
+        case 'SAFETY_CHECKED':
+            return { ...base, awaitingDecision: true, decisionMachineState: permissionMachineStateForEvent(event) };
+        case 'DECISION_EMITTED':
+            return {
+                ...base,
+                awaitingDecision: false,
+                decisionMachineState: permissionMachineStateForEvent(event),
+                approvalCount: domain.approvalCount + (event.approved ? 1 : 0),
+                denialCount: domain.denialCount + (event.approved ? 0 : 1),
+                lastDecision: {
+                    callId: event.callId,
+                    toolName: event.tool,
+                    category: inferPermissionCategory(event.tool),
+                    machineState: 'decision_emitted',
+                    outcome: event.approved ? 'approved' : 'denied',
+                    reason: event.reasonCode ?? (event.approved ? 'user_approved' : 'user_denied'),
+                    sourceLayer: event.sourceLayer ?? event.source ?? 'config_policy',
+                    persisted: event.persisted ?? false,
+                    classification: event.classification,
+                    riskLevel: event.riskLevel,
+                    summary: event.summary,
+                    decidedAt: now(),
+                },
+            };
+    }
+}
+function updateTaskIndexes(tasks) {
+    const queuedIds = [];
+    const runningIds = [];
+    const blockedIds = [];
+    for (const [taskId, task] of tasks.entries()) {
+        if (task.status === 'queued')
+            queuedIds.push(taskId);
+        if (task.status === 'running')
+            runningIds.push(taskId);
+        if (task.status === 'blocked')
+            blockedIds.push(taskId);
+    }
+    return { queuedIds, runningIds, blockedIds };
+}
+export function updateTaskState(domain, event) {
+    const tasks = new Map(domain.tasks);
+    const existing = tasks.get(event.taskId);
+    const timestamp = now();
+    const task = existing ??
+        {
+            id: event.taskId,
+            kind: 'agentId' in event && event.agentId ? 'agent' : 'exec',
+            title: 'description' in event ? event.description : `task:${event.taskId}`,
+            status: 'queued',
+            owner: event.agentId ?? 'runtime',
+            cancellable: true,
+            childTaskIds: [],
+            queuedAt: timestamp,
+        };
+    switch (event.type) {
+        case 'TASK_CREATED':
+            tasks.set(event.taskId, task);
+            break;
+        case 'TASK_STARTED':
+            tasks.set(event.taskId, { ...task, status: 'running', startedAt: task.startedAt ?? timestamp });
+            break;
+        case 'TASK_BLOCKED':
+            tasks.set(event.taskId, { ...task, status: 'blocked', error: event.reason });
+            break;
+        case 'TASK_PROGRESS':
+            tasks.set(event.taskId, { ...task, description: event.message ?? task.description });
+            break;
+        case 'TASK_COMPLETED':
+            tasks.set(event.taskId, { ...task, status: 'completed', endedAt: timestamp, result: { durationMs: event.durationMs } });
+            break;
+        case 'TASK_FAILED':
+            tasks.set(event.taskId, { ...task, status: 'failed', endedAt: timestamp, error: event.error });
+            break;
+        case 'TASK_CANCELLED':
+            tasks.set(event.taskId, { ...task, status: 'cancelled', endedAt: timestamp, error: event.reason });
+            break;
+    }
+    const indexes = updateTaskIndexes(tasks);
+    return {
+        ...updateDomainMetadata(domain, event.type),
+        tasks,
+        ...indexes,
+        totalCreated: domain.totalCreated + (event.type === 'TASK_CREATED' ? 1 : 0),
+        totalCompleted: domain.totalCompleted + (event.type === 'TASK_COMPLETED' ? 1 : 0),
+        totalFailed: domain.totalFailed + (event.type === 'TASK_FAILED' ? 1 : 0),
+        totalCancelled: domain.totalCancelled + (event.type === 'TASK_CANCELLED' ? 1 : 0),
+    };
+}
+function updateTaskDomainFromRecord(domain, task, source) {
+    const tasks = new Map(domain.tasks);
+    const previous = tasks.get(task.id);
+    tasks.set(task.id, task);
+    const indexes = updateTaskIndexes(tasks);
+    let { totalCreated, totalCompleted, totalFailed, totalCancelled } = domain;
+    if (!previous)
+        totalCreated += 1;
+    if (previous?.status !== task.status) {
+        if (task.status === 'completed')
+            totalCompleted += 1;
+        else if (task.status === 'failed')
+            totalFailed += 1;
+        else if (task.status === 'cancelled')
+            totalCancelled += 1;
+    }
+    return { ...updateDomainMetadata(domain, source), tasks, ...indexes, totalCreated, totalCompleted, totalFailed, totalCancelled };
+}
+function transitionTaskDomainRecord(domain, taskId, status, patch, source) {
+    const existing = domain.tasks.get(taskId);
+    if (!existing)
+        return domain;
+    return updateTaskDomainFromRecord(domain, { ...existing, ...patch, status }, source);
+}
+export function updateAgentState(domain, event) {
+    const agents = new Map(domain.agents);
+    const timestamp = now();
+    const existing = agents.get(event.agentId);
+    const statusMap = {
+        AGENT_SPAWNING: 'spawning',
+        AGENT_RUNNING: 'running',
+        AGENT_PROGRESS: 'running',
+        AGENT_STREAM_DELTA: 'running',
+        AGENT_AWAITING_MESSAGE: 'awaiting_message',
+        AGENT_AWAITING_TOOL: 'awaiting_tool',
+        AGENT_FINALIZING: 'finalizing',
+        AGENT_COMPLETED: 'completed',
+        AGENT_FAILED: 'failed',
+        AGENT_CANCELLED: 'cancelled',
+    };
+    const agent = existing ??
+        {
+            id: event.agentId,
+            label: 'task' in event ? event.task : event.agentId,
+            role: 'subagent',
+            status: statusMap[event.type] ?? 'running',
+            providerId: 'unknown',
+            modelId: 'unknown',
+            childAgentIds: [],
+            taskId: event.taskId,
+            turnCount: 0,
+            toolCallCount: 0,
+            latestOutput: '',
+            spawnedAt: timestamp,
+        };
+    agents.set(event.agentId, {
+        ...agent,
+        status: statusMap[event.type] ?? agent.status,
+        taskId: event.taskId ?? agent.taskId,
+        latestProgress: event.type === 'AGENT_PROGRESS'
+            ? event.progress
+            : event.type === 'AGENT_AWAITING_TOOL'
+                ? `${event.tool}:${event.callId}`
+                : agent.latestProgress,
+        latestOutput: event.type === 'AGENT_STREAM_DELTA'
+            ? event.accumulated
+            : event.type === 'AGENT_COMPLETED' && event.output !== undefined
+                ? event.output
+                : agent.latestOutput,
+        endedAt: event.type === 'AGENT_COMPLETED' || event.type === 'AGENT_FAILED' || event.type === 'AGENT_CANCELLED'
+            ? timestamp
+            : agent.endedAt,
+        error: event.type === 'AGENT_FAILED' ? event.error : agent.error,
+        toolCallCount: event.type === 'AGENT_COMPLETED' && event.toolCallsMade !== undefined
+            ? event.toolCallsMade
+            : agent.toolCallCount,
+        result: event.type === 'AGENT_COMPLETED'
+            ? {
+                durationMs: event.durationMs,
+                ...(event.output !== undefined ? { output: event.output } : {}),
+                ...(event.toolCallsMade !== undefined ? { toolCallsMade: event.toolCallsMade } : {}),
+            }
+            : agent.result,
+    });
+    const activeAgentIds = [...agents.values()].filter((value) => !['completed', 'failed', 'cancelled'].includes(value.status)).map((value) => value.id);
+    return {
+        ...updateDomainMetadata(domain, event.type),
+        agents,
+        activeAgentIds,
+        totalSpawned: domain.totalSpawned + (event.type === 'AGENT_SPAWNING' ? 1 : 0),
+        totalCompleted: domain.totalCompleted + (event.type === 'AGENT_COMPLETED' ? 1 : 0),
+        totalFailed: domain.totalFailed + (event.type === 'AGENT_FAILED' ? 1 : 0),
+        peakConcurrency: Math.max(domain.peakConcurrency, activeAgentIds.length),
+    };
+}
+function transitionAgentDomainRecord(domain, agentId, status, patch, source) {
+    const existing = domain.agents.get(agentId);
+    if (!existing)
+        return domain;
+    const agents = new Map(domain.agents);
+    agents.set(agentId, { ...existing, ...patch, status });
+    const activeAgentIds = [...agents.values()].filter((value) => !['completed', 'failed', 'cancelled'].includes(value.status)).map((value) => value.id);
+    return {
+        ...updateDomainMetadata(domain, source),
+        agents,
+        activeAgentIds,
+        totalCompleted: domain.totalCompleted + (existing.status !== 'completed' && status === 'completed' ? 1 : 0),
+        totalFailed: domain.totalFailed + (existing.status !== 'failed' && status === 'failed' ? 1 : 0),
+        peakConcurrency: Math.max(domain.peakConcurrency, activeAgentIds.length),
+    };
+}
+function orchestrationGraphStatus(graph) {
+    const nodes = [...graph.nodes.values()];
+    if (nodes.length === 0)
+        return 'planning';
+    if (nodes.some((node) => node.status === 'failed'))
+        return 'failed';
+    if (nodes.some((node) => node.status === 'blocked'))
+        return 'blocked';
+    if (nodes.some((node) => node.status === 'running'))
+        return 'running';
+    if (nodes.every((node) => node.status === 'cancelled'))
+        return 'cancelled';
+    if (nodes.every((node) => node.status === 'completed'))
+        return 'completed';
+    if (nodes.every((node) => node.status === 'pending' || node.status === 'ready')) {
+        return nodes.some((node) => node.status === 'ready') ? 'ready' : 'planning';
+    }
+    return 'running';
+}
+export function updateOrchestrationState(domain, event) {
+    const graphs = new Map(domain.graphs);
+    const timestamp = now();
+    const existing = 'graphId' in event ? graphs.get(event.graphId) : undefined;
+    switch (event.type) {
+        case 'ORCHESTRATION_GRAPH_CREATED':
+            graphs.set(event.graphId, {
+                id: event.graphId,
+                title: event.title,
+                mode: event.mode,
+                status: 'planning',
+                nodeOrder: [],
+                nodes: new Map(),
+                createdAt: timestamp,
+            });
+            break;
+        case 'ORCHESTRATION_NODE_ADDED': {
+            if (!existing)
+                return domain;
+            const nodes = new Map(existing.nodes);
+            const previousParent = event.parentNodeId ? nodes.get(event.parentNodeId) : undefined;
+            const nextNode = {
+                id: event.nodeId,
+                title: event.title,
+                role: event.role,
+                status: 'pending',
+                parentNodeId: event.parentNodeId,
+                childNodeIds: [],
+                dependencyNodeIds: event.dependsOn ?? [],
+                ...(event.taskId !== undefined ? { taskId: event.taskId } : {}),
+                ...(event.agentId !== undefined ? { agentId: event.agentId } : {}),
+                ...(event.contract !== undefined ? { contract: event.contract } : {}),
+            };
+            nodes.set(event.nodeId, nextNode);
+            if (previousParent) {
+                nodes.set(event.parentNodeId, { ...previousParent, childNodeIds: uniq([...previousParent.childNodeIds, event.nodeId]) });
+            }
+            const graph = { ...existing, nodeOrder: uniq([...existing.nodeOrder, event.nodeId]), nodes };
+            graph.status = orchestrationGraphStatus(graph);
+            graphs.set(event.graphId, graph);
+            break;
+        }
+        case 'ORCHESTRATION_NODE_READY':
+        case 'ORCHESTRATION_NODE_STARTED':
+        case 'ORCHESTRATION_NODE_PROGRESS':
+        case 'ORCHESTRATION_NODE_BLOCKED':
+        case 'ORCHESTRATION_NODE_COMPLETED':
+        case 'ORCHESTRATION_NODE_FAILED':
+        case 'ORCHESTRATION_NODE_CANCELLED':
+        case 'ORCHESTRATION_RECURSION_GUARD_TRIGGERED': {
+            if (!existing)
+                return domain;
+            const nodes = new Map(existing.nodes);
+            const nodeId = 'nodeId' in event ? event.nodeId : undefined;
+            if (nodeId) {
+                const node = nodes.get(nodeId);
+                if (!node)
+                    return domain;
+                const updatedNode = event.type === 'ORCHESTRATION_NODE_READY'
+                    ? { ...node, status: 'ready' }
+                    : event.type === 'ORCHESTRATION_NODE_STARTED'
+                        ? { ...node, status: 'running', startedAt: node.startedAt ?? timestamp, ...(event.taskId !== undefined ? { taskId: event.taskId } : {}), ...(event.agentId !== undefined ? { agentId: event.agentId } : {}) }
+                        : event.type === 'ORCHESTRATION_NODE_PROGRESS'
+                            ? { ...node, latestMessage: event.message }
+                            : event.type === 'ORCHESTRATION_NODE_BLOCKED'
+                                ? { ...node, status: 'blocked', error: event.reason }
+                                : event.type === 'ORCHESTRATION_NODE_COMPLETED'
+                                    ? { ...node, status: 'completed', endedAt: timestamp, latestMessage: event.summary ?? node.latestMessage }
+                                    : event.type === 'ORCHESTRATION_NODE_FAILED'
+                                        ? { ...node, status: 'failed', endedAt: timestamp, error: event.error }
+                                        : { ...node, status: 'cancelled', endedAt: timestamp, error: event.reason };
+                nodes.set(nodeId, updatedNode);
+            }
+            const graph = {
+                ...existing,
+                nodes,
+                ...(event.type === 'ORCHESTRATION_NODE_STARTED' ? { startedAt: existing.startedAt ?? timestamp } : {}),
+                ...(event.type === 'ORCHESTRATION_RECURSION_GUARD_TRIGGERED'
+                    ? {
+                        lastRecursionGuard: {
+                            depth: event.depth,
+                            activeAgents: event.activeAgents,
+                            reason: event.reason,
+                            ...(event.nodeId !== undefined ? { nodeId: event.nodeId } : {}),
+                            triggeredAt: timestamp,
+                        },
+                    }
+                    : {}),
+            };
+            graph.status = orchestrationGraphStatus(graph);
+            if (graph.status === 'completed' || graph.status === 'failed' || graph.status === 'cancelled') {
+                graph.endedAt = graph.endedAt ?? timestamp;
+            }
+            graphs.set(graph.id, graph);
+            break;
+        }
+    }
+    const activeGraphIds = [...graphs.values()].filter((graph) => !['completed', 'failed', 'cancelled'].includes(graph.status)).map((graph) => graph.id);
+    return {
+        ...updateDomainMetadata(domain, event.type),
+        graphs,
+        activeGraphIds,
+        totalGraphs: graphs.size,
+        totalCompletedGraphs: [...graphs.values()].filter((graph) => graph.status === 'completed').length,
+        totalFailedGraphs: [...graphs.values()].filter((graph) => graph.status === 'failed').length,
+        recursionGuardTrips: domain.recursionGuardTrips + (event.type === 'ORCHESTRATION_RECURSION_GUARD_TRIGGERED' ? 1 : 0),
+    };
+}
+export { updateTaskDomainFromRecord, transitionTaskDomainRecord, transitionAgentDomainRecord };

package/dist/_internal/platform/runtime/store/helpers/reducers/shared.d.ts

@@ -0,0 +1,15 @@
+import type { PartialToolCall } from '../../../../providers/interface.js';
+import type { ConversationDomainState } from '../../domains/conversation.js';
+export declare function uniq<T>(items: T[]): T[];
+export declare function now(): number;
+export declare function updateDomainMetadata<T extends {
+    revision: number;
+    lastUpdatedAt: number;
+    source: string;
+}>(domain: T, source: string): T;
+export declare function isTerminalTurnState(state: ConversationDomainState['turnState']): boolean;
+export declare function canStartNewTurn(domain: ConversationDomainState): boolean;
+export declare function isCurrentTurnEvent(domain: ConversationDomainState, turnId: string): boolean;
+export declare function formatPartialToolPreview(toolCalls?: PartialToolCall[]): string | undefined;
+export declare function resetStreamState(): ConversationDomainState['stream'];
+//# sourceMappingURL=shared.d.ts.map

package/dist/_internal/platform/runtime/store/helpers/reducers/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../../../../src/_internal/platform/runtime/store/helpers/reducers/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAE7E,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAEvC;AAED,wBAAgB,GAAG,IAAI,MAAM,CAE5B;AAED,wBAAgB,oBAAoB,CAAC,CAAC,SAAS;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACxG,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,MAAM,GACb,CAAC,CAOH;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,uBAAuB,CAAC,WAAW,CAAC,GAAG,OAAO,CAExF;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAExE;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAE3F;AAED,wBAAgB,wBAAwB,CAAC,SAAS,CAAC,EAAE,eAAe,EAAE,GAAG,MAAM,GAAG,SAAS,CAa1F;AAED,wBAAgB,gBAAgB,IAAI,uBAAuB,CAAC,QAAQ,CAAC,CASpE"}

package/dist/_internal/platform/runtime/store/helpers/reducers/shared.js

@@ -0,0 +1,48 @@
+export function uniq(items) {
+    return [...new Set(items)];
+}
+export function now() {
+    return Date.now();
+}
+export function updateDomainMetadata(domain, source) {
+    return {
+        ...domain,
+        revision: domain.revision + 1,
+        lastUpdatedAt: now(),
+        source,
+    };
+}
+export function isTerminalTurnState(state) {
+    return state === 'completed' || state === 'failed' || state === 'cancelled';
+}
+export function canStartNewTurn(domain) {
+    return domain.turnState === 'idle' || isTerminalTurnState(domain.turnState);
+}
+export function isCurrentTurnEvent(domain, turnId) {
+    return domain.currentTurnId !== undefined && domain.currentTurnId === turnId;
+}
+export function formatPartialToolPreview(toolCalls) {
+    if (!toolCalls || toolCalls.length === 0)
+        return undefined;
+    const last = toolCalls[toolCalls.length - 1];
+    const name = typeof last.name === 'string' ? last.name : '';
+    const args = typeof last.arguments === 'string'
+        ? last.arguments
+        : last.arguments !== undefined
+            ? JSON.stringify(last.arguments)
+            : '';
+    if (!name)
+        return undefined;
+    const preview = args.length > 60 ? `${args.slice(0, 57)}...` : args;
+    return `${name}(${preview})`;
+}
+export function resetStreamState() {
+    return {
+        accumulated: '',
+        reasoningAccumulated: '',
+        partialToolPreview: undefined,
+        deltaCount: 0,
+        firstDeltaAt: undefined,
+        lastDeltaAt: undefined,
+    };
+}

package/dist/_internal/platform/runtime/store/helpers/reducers/sync.d.ts

@@ -0,0 +1,40 @@
+import type { CommunicationEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/communication';
+import type { PluginEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/plugins';
+import type { McpEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/mcp';
+import type { TransportEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/transport';
+import type { IntegrationDomainState, IntegrationRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/integrations';
+import type { AutomationDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/automation';
+import type { RoutesDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/routes';
+import type { ControlPlaneDomainState, ControlPlaneClientRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/control-plane';
+import type { DeliveryDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/deliveries';
+import type { WatcherDomainState, WatcherRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/watchers';
+import type { SurfaceDomainState, SurfaceRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/surfaces';
+import type { CommunicationDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/communication';
+import type { PluginDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/plugins';
+import type { McpDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/mcp';
+import type { AcpDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/acp';
+import type { DaemonDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/daemon';
+import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation/jobs';
+import type { AutomationRun } from '@pellux/goodvibes-sdk/platform/automation/runs';
+import type { AutomationSourceRecord } from '@pellux/goodvibes-sdk/platform/automation/sources';
+import type { AutomationRouteBinding } from '@pellux/goodvibes-sdk/platform/automation/routes';
+import type { AutomationSurfaceKind } from '@pellux/goodvibes-sdk/platform/automation/types';
+import type { AutomationDeliveryAttempt } from '@pellux/goodvibes-sdk/platform/automation/delivery';
+import type { SessionDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/session';
+export declare function updateCommunicationState(domain: CommunicationDomainState, event: CommunicationEvent): CommunicationDomainState;
+export declare function updatePluginState(domain: PluginDomainState, event: PluginEvent): PluginDomainState;
+export declare function updateMcpState(domain: McpDomainState, event: McpEvent): McpDomainState;
+export declare function updateTransportState(acp: AcpDomainState, daemon: DaemonDomainState, event: TransportEvent): Pick<import('../../state.js').RuntimeState, 'acp' | 'daemon'>;
+export declare function updateIntegrationDomainFromRecord(domain: IntegrationDomainState, record: IntegrationRecord, source: string): IntegrationDomainState;
+export declare function updateAutomationDomainFromSource(domain: AutomationDomainState, sourceRecord: AutomationSourceRecord, source: string): AutomationDomainState;
+export declare function updateAutomationDomainFromJob(domain: AutomationDomainState, job: AutomationJob, source: string): AutomationDomainState;
+export declare function updateAutomationDomainFromRun(domain: AutomationDomainState, run: AutomationRun, source: string): AutomationDomainState;
+export declare function updateRoutesDomainFromBinding(domain: RoutesDomainState, binding: AutomationRouteBinding, source: string): RoutesDomainState;
+export declare function updateRouteFailureState(domain: RoutesDomainState, _surfaceKind: AutomationSurfaceKind, _externalId: string, source: string): RoutesDomainState;
+export declare function updateControlPlaneDomainFromClient(domain: ControlPlaneDomainState, client: ControlPlaneClientRecord, source: string): ControlPlaneDomainState;
+export declare function patchControlPlaneDomain(domain: ControlPlaneDomainState, patch: Partial<ControlPlaneDomainState>, source: string): ControlPlaneDomainState;
+export declare function updateDeliveryDomainFromAttempt(domain: DeliveryDomainState, attempt: AutomationDeliveryAttempt, source: string): DeliveryDomainState;
+export declare function updateSurfaceDomainFromRecord(domain: SurfaceDomainState, record: SurfaceRecord, source: string): SurfaceDomainState;
+export declare function updateWatcherDomainFromRecord(domain: WatcherDomainState, record: WatcherRecord, source: string): WatcherDomainState;
+export declare function syncSessionStatePatch(domain: SessionDomainState, patch: Partial<SessionDomainState>, source: string): SessionDomainState;
+//# sourceMappingURL=sync.d.ts.map

package/dist/_internal/platform/runtime/store/helpers/reducers/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../../../../../src/_internal/platform/runtime/store/helpers/reducers/sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAC;AACtG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uDAAuD,CAAC;AACzF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mDAAmD,CAAC;AAClF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yDAAyD,CAAC;AAC9F,OAAO,KAAK,EAAE,sBAAsB,EAAE,iBAAiB,EAAqB,MAAM,mEAAmE,CAAC;AACtJ,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iEAAiE,CAAC;AAC7G,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6DAA6D,CAAC;AACrG,OAAO,KAAK,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,oEAAoE,CAAC;AAC5I,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iEAAiE,CAAC;AAC3G,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,+DAA+D,CAAC;AACvH,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,+DAA+D,CAAC;AACvH,OAAO,KAAK,EAAE,wBAAwB,EAA8B,MAAM,oEAAoE,CAAC;AAC/I,OAAO,KAAK,EAAE,iBAAiB,EAAuC,MAAM,8DAA8D,CAAC;AAC3I,OAAO,KAAK,EAAE,cAAc,EAA4C,MAAM,0DAA0D,CAAC;AACzI,OAAO,KAAK,EAAE,cAAc,EAAqB,MAAM,0DAA0D,CAAC;AAClH,OAAO,KAAK,EAAE,iBAAiB,EAAwB,MAAM,6DAA6D,CAAC;AAC3H,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AACpF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AACpF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mDAAmD,CAAC;AAChG,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kDAAkD,CAAC;AAC/F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iDAAiD,CAAC;AAC7F,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oDAAoD,CAAC;AACpG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8DAA8D,CAAC;AAGvG,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,wBAAwB,EAChC,KAAK,EAAE,kBAAkB,GACxB,wBAAwB,CA2C1B;AAuBD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,WAAW,GAAG,iBAAiB,CAmDlG;AAyBD,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,QAAQ,GAAG,cAAc,CA8HtF;AAuBD,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,iBAAiB,EACzB,KAAK,EAAE,cAAc,GACpB,IAAI,CAAC,OAAO,gBAAgB,EAAE,YAAY,EAAE,KAAK,GAAG,QAAQ,CAAC,CAiC/D;AAED,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,sBAAsB,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,GAAG,sBAAsB,CAenJ;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,qBAAqB,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,EAAE,MAAM,GAAG,qBAAqB,CAK3J;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,qBAAqB,CAuBtI;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,qBAAqB,CAyBtI;AAmBD,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,EAAE,MAAM,GAAG,iBAAiB,CAc3I;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,iBAAiB,EAAE,YAAY,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,iBAAiB,CAE9J;AAED,wBAAgB,kCAAkC,CAAC,MAAM,EAAE,uBAAuB,EAAE,MAAM,EAAE,wBAAwB,EAAE,MAAM,EAAE,MAAM,GAAG,uBAAuB,CAiB7J;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,uBAAuB,EAAE,KAAK,EAAE,OAAO,CAAC,uBAAuB,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,uBAAuB,CAMzJ;AAED,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,yBAAyB,EAAE,MAAM,EAAE,MAAM,GAAG,mBAAmB,CAiBpJ;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAcnI;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAiBnI;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,kBAAkB,EAAE,KAAK,EAAE,OAAO,CAAC,kBAAkB,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAExI"}