@pellux/goodvibes-sdk 0.18.14 → 0.18.16

package/dist/_internal/platform/runtime/telemetry/instrumentation/domain-bridge-agent-session.js

@@ -0,0 +1,325 @@
+import { endAgentSpan, recordAgentPhase, startAgentSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/agent';
+import { endCompactionSpan, recordCompactionPhase, startCompactionSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/compaction';
+import { endPermissionSpan, recordPermissionPhase, startPermissionSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/permission';
+import { endSessionSpan, recordSessionPhase, startSessionSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/session';
+export function attachAgentDomain({ bus, helpers }, agentSpans) {
+    const unsubs = [];
+    unsubs.push(bus.on('AGENT_SPAWNING', (env) => {
+        helpers.safe(() => {
+            const span = startAgentSpan(helpers.tracer, {
+                agentId: env.payload.agentId,
+                taskId: env.payload.taskId,
+                task: env.payload.task,
+                traceId: env.traceId,
+            });
+            agentSpans.set(env.payload.agentId, span);
+        });
+    }));
+    unsubs.push(bus.on('AGENT_RUNNING', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(agentSpans, env.payload.agentId, (span) => recordAgentPhase(span, 'running'));
+        });
+    }));
+    unsubs.push(bus.on('AGENT_AWAITING_MESSAGE', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(agentSpans, env.payload.agentId, (span) => recordAgentPhase(span, 'awaiting_message'));
+        });
+    }));
+    unsubs.push(bus.on('AGENT_AWAITING_TOOL', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(agentSpans, env.payload.agentId, (span) => {
+                recordAgentPhase(span, 'awaiting_tool', {
+                    'agent.tool': env.payload.tool,
+                    'agent.call_id': env.payload.callId,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('AGENT_FINALIZING', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(agentSpans, env.payload.agentId, (span) => recordAgentPhase(span, 'finalizing'));
+        });
+    }));
+    unsubs.push(bus.on('AGENT_COMPLETED', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(agentSpans, env.payload.agentId, (span) => {
+                endAgentSpan(span, {
+                    outcome: 'completed',
+                    durationMs: env.payload.durationMs,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('AGENT_FAILED', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(agentSpans, env.payload.agentId, (span) => {
+                endAgentSpan(span, {
+                    outcome: 'failed',
+                    durationMs: env.payload.durationMs,
+                    error: env.payload.error,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('AGENT_CANCELLED', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(agentSpans, env.payload.agentId, (span) => {
+                endAgentSpan(span, {
+                    outcome: 'cancelled',
+                    durationMs: 0,
+                    reason: env.payload.reason,
+                });
+            });
+        });
+    }));
+    return () => unsubs.forEach((unsub) => unsub());
+}
+export function attachPermissionDomain({ bus, helpers }, permissionSpans) {
+    const unsubs = [];
+    unsubs.push(bus.on('PERMISSION_REQUESTED', (env) => {
+        helpers.safe(() => {
+            const span = startPermissionSpan(helpers.tracer, {
+                callId: env.payload.callId,
+                tool: env.payload.tool,
+                category: env.payload.category,
+                traceId: env.traceId,
+            });
+            permissionSpans.set(env.payload.callId, span);
+        });
+    }));
+    unsubs.push(bus.on('RULES_COLLECTED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(permissionSpans, env.payload.callId, (span) => {
+                recordPermissionPhase(span, 'rules_collected', {
+                    'permission.rule_count': env.payload.ruleCount,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('INPUT_NORMALIZED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(permissionSpans, env.payload.callId, (span) => recordPermissionPhase(span, 'input_normalized'));
+        });
+    }));
+    unsubs.push(bus.on('POLICY_EVALUATED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(permissionSpans, env.payload.callId, (span) => {
+                recordPermissionPhase(span, 'policy_evaluated', {
+                    'permission.policy_result': env.payload.result,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('MODE_EVALUATED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(permissionSpans, env.payload.callId, (span) => {
+                recordPermissionPhase(span, 'mode_evaluated', {
+                    'permission.mode': env.payload.mode,
+                    'permission.mode_result': env.payload.result,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('SESSION_OVERRIDE_EVALUATED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(permissionSpans, env.payload.callId, (span) => {
+                recordPermissionPhase(span, 'session_override_evaluated', {
+                    'permission.override_applied': env.payload.overrideApplied,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('SAFETY_CHECKED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(permissionSpans, env.payload.callId, (span) => {
+                recordPermissionPhase(span, 'safety_checked', {
+                    'permission.safe': env.payload.safe,
+                    'permission.warning_count': env.payload.warnings.length,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('DECISION_EMITTED', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(permissionSpans, env.payload.callId, (span) => {
+                endPermissionSpan(span, {
+                    approved: env.payload.approved,
+                    source: env.payload.source,
+                });
+            });
+        });
+    }));
+    return () => unsubs.forEach((unsub) => unsub());
+}
+export function attachSessionDomain({ bus, helpers }, sessionSpans) {
+    const unsubs = [];
+    unsubs.push(bus.on('SESSION_STARTED', (env) => {
+        helpers.safe(() => {
+            const span = startSessionSpan(helpers.tracer, {
+                sessionId: env.payload.sessionId,
+                traceId: env.traceId,
+                profileId: env.payload.profileId,
+                workingDir: env.payload.workingDir,
+            });
+            sessionSpans.set(env.payload.sessionId, span);
+        });
+    }));
+    unsubs.push(bus.on('SESSION_LOADING', (env) => {
+        helpers.safe(() => {
+            if (!sessionSpans.has(env.payload.sessionId)) {
+                const span = startSessionSpan(helpers.tracer, {
+                    sessionId: env.payload.sessionId,
+                    traceId: env.traceId,
+                    path: env.payload.path,
+                });
+                sessionSpans.set(env.payload.sessionId, span);
+                return;
+            }
+            helpers.withSpan(sessionSpans, env.payload.sessionId, (span) => recordSessionPhase(span, 'loading'));
+        });
+    }));
+    unsubs.push(bus.on('SESSION_RESUMED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(sessionSpans, env.payload.sessionId, (span) => {
+                recordSessionPhase(span, 'resumed', {
+                    'session.turn_count': env.payload.turnCount,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('SESSION_REPAIRING', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(sessionSpans, env.payload.sessionId, (span) => {
+                recordSessionPhase(span, 'repairing', {
+                    'session.repair_reason': env.payload.reason,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('SESSION_RECONCILING', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(sessionSpans, env.payload.sessionId, (span) => {
+                recordSessionPhase(span, 'reconciling', {
+                    'session.message_count': env.payload.messageCount,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('SESSION_READY', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(sessionSpans, env.payload.sessionId, (span) => {
+                endSessionSpan(span, { outcome: 'ready' });
+            });
+        });
+    }));
+    unsubs.push(bus.on('SESSION_RECOVERY_FAILED', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(sessionSpans, env.payload.sessionId, (span) => {
+                endSessionSpan(span, {
+                    outcome: 'recovery_failed',
+                    error: env.payload.error,
+                });
+            });
+        });
+    }));
+    return () => unsubs.forEach((unsub) => unsub());
+}
+export function attachCompactionDomain({ bus, helpers }, compactionSpans) {
+    const unsubs = [];
+    unsubs.push(bus.on('COMPACTION_CHECK', (env) => {
+        helpers.safe(() => {
+            if (compactionSpans.has(env.payload.sessionId))
+                return;
+            const span = startCompactionSpan(helpers.tracer, {
+                sessionId: env.payload.sessionId,
+                strategy: 'check',
+                tokenCount: env.payload.tokenCount,
+                threshold: env.payload.threshold,
+                traceId: env.traceId,
+            });
+            compactionSpans.set(env.payload.sessionId, span);
+        });
+    }));
+    unsubs.push(bus.on('COMPACTION_AUTOCOMPACT', (env) => {
+        helpers.safe(() => {
+            if (compactionSpans.has(env.payload.sessionId))
+                return;
+            const span = startCompactionSpan(helpers.tracer, {
+                sessionId: env.payload.sessionId,
+                strategy: env.payload.strategy,
+                tokenCount: env.payload.tokensBefore,
+                traceId: env.traceId,
+            });
+            compactionSpans.set(env.payload.sessionId, span);
+        });
+    }));
+    unsubs.push(bus.on('COMPACTION_REACTIVE', (env) => {
+        helpers.safe(() => {
+            if (compactionSpans.has(env.payload.sessionId))
+                return;
+            const span = startCompactionSpan(helpers.tracer, {
+                sessionId: env.payload.sessionId,
+                strategy: 'reactive',
+                tokenCount: env.payload.tokenCount,
+                limit: env.payload.limit,
+                traceId: env.traceId,
+            });
+            compactionSpans.set(env.payload.sessionId, span);
+        });
+    }));
+    unsubs.push(bus.on('COMPACTION_MICROCOMPACT', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(compactionSpans, env.payload.sessionId, (span) => {
+                recordCompactionPhase(span, 'microcompact', {
+                    'compaction.turn_count': env.payload.turnCount,
+                    'compaction.tokens_before': env.payload.tokensBefore,
+                    'compaction.tokens_after': env.payload.tokensAfter,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('COMPACTION_COLLAPSE', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(compactionSpans, env.payload.sessionId, (span) => {
+                recordCompactionPhase(span, 'collapse', {
+                    'compaction.message_count': env.payload.messageCount,
+                    'compaction.tokens_before': env.payload.tokensBefore,
+                    'compaction.tokens_after': env.payload.tokensAfter,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('COMPACTION_BOUNDARY_COMMIT', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(compactionSpans, env.payload.sessionId, (span) => {
+                recordCompactionPhase(span, 'boundary_commit', {
+                    'compaction.checkpoint_id': env.payload.checkpointId,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('COMPACTION_DONE', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(compactionSpans, env.payload.sessionId, (span) => {
+                endCompactionSpan(span, {
+                    outcome: 'done',
+                    tokensBefore: env.payload.tokensBefore,
+                    tokensAfter: env.payload.tokensAfter,
+                    durationMs: env.payload.durationMs,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('COMPACTION_FAILED', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(compactionSpans, env.payload.sessionId, (span) => {
+                endCompactionSpan(span, {
+                    outcome: 'failed',
+                    tokensBefore: 0,
+                    error: env.payload.error,
+                });
+            });
+        });
+    }));
+    return () => unsubs.forEach((unsub) => unsub());
+}

package/dist/_internal/platform/runtime/telemetry/instrumentation/domain-bridge-plugin-mcp.d.ts

@@ -0,0 +1,4 @@
+import type { DomainBridgeAttachmentInput, SpanMap } from './domain-bridge-shared.js';
+export declare function attachPluginDomain({ bus, helpers }: DomainBridgeAttachmentInput, pluginSpans: SpanMap): () => void;
+export declare function attachMcpDomain({ bus, helpers }: DomainBridgeAttachmentInput, mcpSpans: SpanMap): () => void;
+//# sourceMappingURL=domain-bridge-plugin-mcp.d.ts.map

package/dist/_internal/platform/runtime/telemetry/instrumentation/domain-bridge-plugin-mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-bridge-plugin-mcp.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/telemetry/instrumentation/domain-bridge-plugin-mcp.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,2BAA2B,EAAO,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAE3F,wBAAgB,kBAAkB,CAChC,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,2BAA2B,EAC7C,WAAW,EAAE,OAAO,GACnB,MAAM,IAAI,CA6FZ;AAED,wBAAgB,eAAe,CAC7B,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,2BAA2B,EAC7C,QAAQ,EAAE,OAAO,GAChB,MAAM,IAAI,CA4FZ"}

package/dist/_internal/platform/runtime/telemetry/instrumentation/domain-bridge-plugin-mcp.js

@@ -0,0 +1,142 @@
+import { endMcpSpan, recordMcpPhase, startMcpSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/mcp';
+import { endPluginSpan, recordPluginPhase, startPluginSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/plugin';
+export function attachPluginDomain({ bus, helpers }, pluginSpans) {
+    const unsubs = [];
+    unsubs.push(bus.on('PLUGIN_DISCOVERED', (env) => {
+        helpers.safe(() => {
+            const span = startPluginSpan(helpers.tracer, {
+                pluginId: env.payload.pluginId,
+                path: env.payload.path,
+                version: env.payload.version,
+                traceId: env.traceId,
+            });
+            pluginSpans.set(env.payload.pluginId, span);
+        });
+    }));
+    unsubs.push(bus.on('PLUGIN_LOADING', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(pluginSpans, env.payload.pluginId, (span) => recordPluginPhase(span, 'loading'));
+        });
+    }));
+    unsubs.push(bus.on('PLUGIN_LOADED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(pluginSpans, env.payload.pluginId, (span) => {
+                recordPluginPhase(span, 'loaded', {
+                    'plugin.capability_count': env.payload.capabilities.length,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('PLUGIN_ACTIVE', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(pluginSpans, env.payload.pluginId, (span) => recordPluginPhase(span, 'active'));
+        });
+    }));
+    unsubs.push(bus.on('PLUGIN_DEGRADED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(pluginSpans, env.payload.pluginId, (span) => {
+                recordPluginPhase(span, 'degraded', {
+                    'plugin.degraded_reason': env.payload.reason,
+                    'plugin.affected_capability_count': env.payload.affectedCapabilities.length,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('PLUGIN_ERROR', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(pluginSpans, env.payload.pluginId, (span) => {
+                endPluginSpan(span, {
+                    outcome: 'error',
+                    error: env.payload.error,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('PLUGIN_UNLOADING', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(pluginSpans, env.payload.pluginId, (span) => recordPluginPhase(span, 'unloading'));
+        });
+    }));
+    unsubs.push(bus.on('PLUGIN_DISABLED', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(pluginSpans, env.payload.pluginId, (span) => {
+                endPluginSpan(span, {
+                    outcome: 'disabled',
+                    reason: env.payload.reason,
+                });
+            });
+        });
+    }));
+    return () => unsubs.forEach((unsub) => unsub());
+}
+export function attachMcpDomain({ bus, helpers }, mcpSpans) {
+    const unsubs = [];
+    unsubs.push(bus.on('MCP_CONFIGURED', (env) => {
+        helpers.safe(() => {
+            const span = startMcpSpan(helpers.tracer, {
+                serverId: env.payload.serverId,
+                transport: env.payload.transport,
+                url: env.payload.url,
+                traceId: env.traceId,
+            });
+            mcpSpans.set(env.payload.serverId, span);
+        });
+    }));
+    unsubs.push(bus.on('MCP_CONNECTING', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(mcpSpans, env.payload.serverId, (span) => recordMcpPhase(span, 'connecting'));
+        });
+    }));
+    unsubs.push(bus.on('MCP_CONNECTED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(mcpSpans, env.payload.serverId, (span) => {
+                recordMcpPhase(span, 'connected', {
+                    'mcp.tool_count': env.payload.toolCount,
+                    'mcp.resource_count': env.payload.resourceCount,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('MCP_DEGRADED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(mcpSpans, env.payload.serverId, (span) => {
+                recordMcpPhase(span, 'degraded', {
+                    'mcp.degraded_reason': env.payload.reason,
+                    'mcp.available_tool_count': env.payload.availableTools.length,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('MCP_AUTH_REQUIRED', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(mcpSpans, env.payload.serverId, (span) => {
+                recordMcpPhase(span, 'auth_required', {
+                    'mcp.auth_type': env.payload.authType,
+                });
+                endMcpSpan(span, { outcome: 'auth_failed' });
+            });
+        });
+    }));
+    unsubs.push(bus.on('MCP_RECONNECTING', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(mcpSpans, env.payload.serverId, (span) => {
+                recordMcpPhase(span, 'reconnecting', {
+                    'mcp.reconnect_attempt': env.payload.attempt,
+                    'mcp.reconnect_max_attempts': env.payload.maxAttempts,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('MCP_DISCONNECTED', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(mcpSpans, env.payload.serverId, (span) => {
+                endMcpSpan(span, {
+                    outcome: 'disconnected',
+                    reason: env.payload.reason,
+                    willRetry: env.payload.willRetry,
+                });
+            });
+        });
+    }));
+    return () => unsubs.forEach((unsub) => unsub());
+}

package/dist/_internal/platform/runtime/telemetry/instrumentation/domain-bridge-shared.d.ts

@@ -0,0 +1,18 @@
+import type { RuntimeEventBus, RuntimeEventEnvelope } from '../../events/index.js';
+import type { RuntimeTracer } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/tracer';
+import type { Span } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/types';
+export type Env<T extends {
+    type: string;
+}> = RuntimeEventEnvelope<T['type'], T>;
+export type SpanMap = Map<string, Span>;
+export interface DomainBridgeHelpers {
+    readonly tracer: RuntimeTracer;
+    readonly safe: (action: () => void) => void;
+    readonly withSpan: (map: SpanMap, key: string, action: (span: Span) => void) => void;
+    readonly closeSpan: (map: SpanMap, key: string, action: (span: Span) => void) => void;
+}
+export interface DomainBridgeAttachmentInput {
+    readonly bus: RuntimeEventBus;
+    readonly helpers: DomainBridgeHelpers;
+}
+//# sourceMappingURL=domain-bridge-shared.d.ts.map

package/dist/_internal/platform/runtime/telemetry/instrumentation/domain-bridge-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-bridge-shared.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/telemetry/instrumentation/domain-bridge-shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AACnF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yDAAyD,CAAC;AAC7F,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wDAAwD,CAAC;AAEnF,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,IAAI,oBAAoB,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;AACjF,MAAM,MAAM,OAAO,GAAG,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAExC,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IAC5C,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,KAAK,IAAI,CAAC;IACrF,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,KAAK,IAAI,CAAC;CACvF;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,GAAG,EAAE,eAAe,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;CACvC"}

package/dist/_internal/platform/runtime/telemetry/instrumentation/domain-bridge-shared.js

@@ -0,0 +1 @@
+export {};

package/dist/_internal/platform/runtime/telemetry/instrumentation/domain-bridge-transport-task.d.ts

@@ -0,0 +1,4 @@
+import type { DomainBridgeAttachmentInput, SpanMap } from './domain-bridge-shared.js';
+export declare function attachTransportDomain({ bus, helpers }: DomainBridgeAttachmentInput, transportSpans: SpanMap): () => void;
+export declare function attachTaskDomain({ bus, helpers }: DomainBridgeAttachmentInput, taskSpans: SpanMap): () => void;
+//# sourceMappingURL=domain-bridge-transport-task.d.ts.map

package/dist/_internal/platform/runtime/telemetry/instrumentation/domain-bridge-transport-task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-bridge-transport-task.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/telemetry/instrumentation/domain-bridge-transport-task.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,2BAA2B,EAAO,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAE3F,wBAAgB,qBAAqB,CACnC,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,2BAA2B,EAC7C,cAAc,EAAE,OAAO,GACtB,MAAM,IAAI,CAiGZ;AAED,wBAAgB,gBAAgB,CAC9B,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,2BAA2B,EAC7C,SAAS,EAAE,OAAO,GACjB,MAAM,IAAI,CA4FZ"}

package/dist/_internal/platform/runtime/telemetry/instrumentation/domain-bridge-transport-task.js

@@ -0,0 +1,146 @@
+import { endTaskSpan, recordTaskPhase, startTaskSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/task';
+import { endTransportSpan, recordTransportPhase, startTransportSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/transport';
+export function attachTransportDomain({ bus, helpers }, transportSpans) {
+    const unsubs = [];
+    unsubs.push(bus.on('TRANSPORT_INITIALIZING', (env) => {
+        helpers.safe(() => {
+            const span = startTransportSpan(helpers.tracer, {
+                transportId: env.payload.transportId,
+                protocol: env.payload.protocol,
+                traceId: env.traceId,
+            });
+            transportSpans.set(env.payload.transportId, span);
+        });
+    }));
+    unsubs.push(bus.on('TRANSPORT_AUTHENTICATING', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(transportSpans, env.payload.transportId, (span) => recordTransportPhase(span, 'authenticating'));
+        });
+    }));
+    unsubs.push(bus.on('TRANSPORT_CONNECTED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(transportSpans, env.payload.transportId, (span) => {
+                recordTransportPhase(span, 'connected', {
+                    'transport.endpoint': env.payload.endpoint,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('TRANSPORT_SYNCING', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(transportSpans, env.payload.transportId, (span) => recordTransportPhase(span, 'syncing'));
+        });
+    }));
+    unsubs.push(bus.on('TRANSPORT_DEGRADED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(transportSpans, env.payload.transportId, (span) => {
+                recordTransportPhase(span, 'degraded', {
+                    'transport.degraded_reason': env.payload.reason,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('TRANSPORT_RECONNECTING', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(transportSpans, env.payload.transportId, (span) => {
+                recordTransportPhase(span, 'reconnecting', {
+                    'transport.reconnect_attempt': env.payload.attempt,
+                    'transport.reconnect_max_attempts': env.payload.maxAttempts,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('TRANSPORT_DISCONNECTED', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(transportSpans, env.payload.transportId, (span) => {
+                endTransportSpan(span, {
+                    outcome: 'disconnected',
+                    reason: env.payload.reason,
+                    willRetry: env.payload.willRetry,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('TRANSPORT_TERMINAL_FAILURE', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(transportSpans, env.payload.transportId, (span) => {
+                endTransportSpan(span, {
+                    outcome: 'terminal_failure',
+                    reason: env.payload.error,
+                });
+            });
+        });
+    }));
+    return () => unsubs.forEach((unsub) => unsub());
+}
+export function attachTaskDomain({ bus, helpers }, taskSpans) {
+    const unsubs = [];
+    unsubs.push(bus.on('TASK_CREATED', (env) => {
+        helpers.safe(() => {
+            const span = startTaskSpan(helpers.tracer, {
+                taskId: env.payload.taskId,
+                agentId: env.payload.agentId,
+                description: env.payload.description,
+                priority: env.payload.priority,
+                traceId: env.traceId,
+            });
+            taskSpans.set(env.payload.taskId, span);
+        });
+    }));
+    unsubs.push(bus.on('TASK_STARTED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(taskSpans, env.payload.taskId, (span) => recordTaskPhase(span, 'started'));
+        });
+    }));
+    unsubs.push(bus.on('TASK_BLOCKED', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(taskSpans, env.payload.taskId, (span) => {
+                recordTaskPhase(span, 'blocked', {
+                    'task.blocked_reason': env.payload.reason,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('TASK_PROGRESS', (env) => {
+        helpers.safe(() => {
+            helpers.withSpan(taskSpans, env.payload.taskId, (span) => {
+                recordTaskPhase(span, 'progress', {
+                    'task.progress': env.payload.progress,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('TASK_COMPLETED', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(taskSpans, env.payload.taskId, (span) => {
+                endTaskSpan(span, {
+                    outcome: 'completed',
+                    durationMs: env.payload.durationMs,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('TASK_FAILED', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(taskSpans, env.payload.taskId, (span) => {
+                endTaskSpan(span, {
+                    outcome: 'failed',
+                    durationMs: env.payload.durationMs,
+                    error: env.payload.error,
+                });
+            });
+        });
+    }));
+    unsubs.push(bus.on('TASK_CANCELLED', (env) => {
+        helpers.safe(() => {
+            helpers.closeSpan(taskSpans, env.payload.taskId, (span) => {
+                endTaskSpan(span, {
+                    outcome: 'cancelled',
+                    durationMs: 0,
+                    reason: env.payload.reason,
+                });
+            });
+        });
+    }));
+    return () => unsubs.forEach((unsub) => unsub());
+}