@pellux/goodvibes-tui 0.18.11 → 0.18.13

package/src/runtime/emitters/plugins.ts

@@ -1,78 +0,0 @@
-/**
- * Plugin emitters — typed emission wrappers for PluginEvent domain.
- */
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-/** Emit PLUGIN_DISCOVERED when a plugin is found during scan. */
-export function emitPluginDiscovered(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { pluginId: string; path: string; version: string }
-): void {
-  bus.emit('plugins', createEventEnvelope('PLUGIN_DISCOVERED', { type: 'PLUGIN_DISCOVERED', ...data }, ctx));
-}
-
-/** Emit PLUGIN_LOADING when a plugin begins loading. */
-export function emitPluginLoading(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { pluginId: string; path: string }
-): void {
-  bus.emit('plugins', createEventEnvelope('PLUGIN_LOADING', { type: 'PLUGIN_LOADING', ...data }, ctx));
-}
-
-/** Emit PLUGIN_LOADED when a plugin is successfully loaded. */
-export function emitPluginLoaded(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { pluginId: string; version: string; capabilities: string[] }
-): void {
-  bus.emit('plugins', createEventEnvelope('PLUGIN_LOADED', { type: 'PLUGIN_LOADED', ...data }, ctx));
-}
-
-/** Emit PLUGIN_ACTIVE when a plugin is fully active. */
-export function emitPluginActive(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { pluginId: string }
-): void {
-  bus.emit('plugins', createEventEnvelope('PLUGIN_ACTIVE', { type: 'PLUGIN_ACTIVE', ...data }, ctx));
-}
-
-/** Emit PLUGIN_DEGRADED when a plugin loses partial functionality. */
-export function emitPluginDegraded(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { pluginId: string; reason: string; affectedCapabilities: string[] }
-): void {
-  bus.emit('plugins', createEventEnvelope('PLUGIN_DEGRADED', { type: 'PLUGIN_DEGRADED', ...data }, ctx));
-}
-
-/** Emit PLUGIN_ERROR when a plugin encounters an error. */
-export function emitPluginError(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { pluginId: string; error: string; fatal: boolean }
-): void {
-  bus.emit('plugins', createEventEnvelope('PLUGIN_ERROR', { type: 'PLUGIN_ERROR', ...data }, ctx));
-}
-
-/** Emit PLUGIN_UNLOADING when a plugin begins unloading. */
-export function emitPluginUnloading(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { pluginId: string; reason?: string }
-): void {
-  bus.emit('plugins', createEventEnvelope('PLUGIN_UNLOADING', { type: 'PLUGIN_UNLOADING', ...data }, ctx));
-}
-
-/** Emit PLUGIN_DISABLED when a plugin is permanently disabled. */
-export function emitPluginDisabled(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { pluginId: string; reason: string }
-): void {
-  bus.emit('plugins', createEventEnvelope('PLUGIN_DISABLED', { type: 'PLUGIN_DISABLED', ...data }, ctx));
-}

package/src/runtime/emitters/providers.ts

@@ -1,30 +0,0 @@
-/**
- * Provider emitters — typed emission wrappers for provider events.
- */
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-export function emitProvidersChanged(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { added: string[]; removed: string[]; updated: string[] }
-): void {
-  bus.emit('providers', createEventEnvelope('PROVIDERS_CHANGED', { type: 'PROVIDERS_CHANGED', ...data }, ctx));
-}
-
-export function emitProviderWarning(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { message: string }
-): void {
-  bus.emit('providers', createEventEnvelope('PROVIDER_WARNING', { type: 'PROVIDER_WARNING', ...data }, ctx));
-}
-
-export function emitModelFallback(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { from: string; to: string; provider: string }
-): void {
-  bus.emit('providers', createEventEnvelope('MODEL_FALLBACK', { type: 'MODEL_FALLBACK', ...data }, ctx));
-}

package/src/runtime/emitters/routes.ts

@@ -1,57 +0,0 @@
-/**
- * Route emitters — typed wrappers for RouteEvent domain.
- */
-
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { RouteEvent, RouteSurfaceKind, RouteTargetKind } from '@pellux/goodvibes-sdk/platform/runtime/events/routes';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-function routeEvent<T extends RouteEvent['type']>(
-  type: T,
-  data: Omit<Extract<RouteEvent, { type: T }>, 'type'>,
-  ctx: EmitterContext,
-): RuntimeEventEnvelope<T, Extract<RouteEvent, { type: T }>> {
-  return createEventEnvelope(type, { type, ...data } as Extract<RouteEvent, { type: T }>, ctx);
-}
-
-export function emitRouteBindingCreated(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { bindingId: string; surfaceKind: RouteSurfaceKind; externalId: string; targetKind: RouteTargetKind; targetId: string },
-): void {
-  bus.emit('routes', routeEvent('ROUTE_BINDING_CREATED', data, ctx));
-}
-
-export function emitRouteBindingUpdated(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { bindingId: string; changedFields: string[] },
-): void {
-  bus.emit('routes', routeEvent('ROUTE_BINDING_UPDATED', data, ctx));
-}
-
-export function emitRouteBindingResolved(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { bindingId: string; surfaceKind: RouteSurfaceKind; externalId: string; targetKind: RouteTargetKind; targetId: string },
-): void {
-  bus.emit('routes', routeEvent('ROUTE_BINDING_RESOLVED', data, ctx));
-}
-
-export function emitRouteReplyTargetCaptured(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { bindingId: string; surfaceKind: RouteSurfaceKind; externalId: string; replyTargetId: string; threadId: string },
-): void {
-  bus.emit('routes', routeEvent('ROUTE_REPLY_TARGET_CAPTURED', data, ctx));
-}
-
-export function emitRouteBindingFailed(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { surfaceKind: RouteSurfaceKind; externalId: string; error: string },
-): void {
-  bus.emit('routes', routeEvent('ROUTE_BINDING_FAILED', data, ctx));
-}

package/src/runtime/emitters/security.ts

@@ -1,53 +0,0 @@
-/**
- * Security emitters — typed wrappers for SecurityEvent domain.
- */
-
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { SecurityEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/security';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-function securityEvent<T extends SecurityEvent['type']>(
-  type: T,
-  data: Omit<Extract<SecurityEvent, { type: T }>, 'type'>,
-  ctx: EmitterContext,
-): RuntimeEventEnvelope<T, Extract<SecurityEvent, { type: T }>> {
-  return createEventEnvelope(type, { type, ...data } as Extract<SecurityEvent, { type: T }>, ctx);
-}
-
-export function emitTokenScopeViolation(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { tokenId: string; label: string; policyId: string; excessScopes: string[] },
-): void {
-  bus.emit('security', securityEvent('TOKEN_SCOPE_VIOLATION', data, ctx));
-}
-
-export function emitTokenRotationWarning(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { tokenId: string; label: string; msUntilDue: number; dueAt: number; ageMs: number },
-): void {
-  bus.emit('security', securityEvent('TOKEN_ROTATION_WARNING', data, ctx));
-}
-
-export function emitTokenRotationExpired(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { tokenId: string; label: string; ageMs: number; cadenceMs: number; dueAt: number },
-): void {
-  bus.emit('security', securityEvent('TOKEN_ROTATION_EXPIRED', data, ctx));
-}
-
-export function emitTokenBlocked(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: {
-    tokenId: string;
-    label: string;
-    reason: 'scope_violation' | 'rotation_overdue' | 'scope_violation_and_rotation_overdue';
-  },
-): void {
-  bus.emit('security', securityEvent('TOKEN_BLOCKED', data, ctx));
-}

package/src/runtime/emitters/session.ts

@@ -1,93 +0,0 @@
-/**
- * Session emitters — typed emission wrappers for SessionEvent domain.
- *
- * Import and call these instead of emitting raw strings.
- */
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { SessionEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/session';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-// ---------------------------------------------------------------------------
-// Internal helper
-// ---------------------------------------------------------------------------
-
-/**
- * Creates a typed session event envelope, reducing boilerplate across the
- * 7 public wrapper functions below.
- */
-function sessionEvent<T extends SessionEvent['type']>(
-  type: T,
-  data: Omit<Extract<SessionEvent, { type: T }>, 'type'>,
-  ctx: EmitterContext,
-): RuntimeEventEnvelope<T, Extract<SessionEvent, { type: T }>> {
-  return createEventEnvelope(type, { type, ...data } as Extract<SessionEvent, { type: T }>, ctx);
-}
-
-// ---------------------------------------------------------------------------
-// Public typed emitter wrappers
-// ---------------------------------------------------------------------------
-
-/** Emit SESSION_STARTED when a new session is created and initialising. */
-export function emitSessionStarted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { sessionId: string; profileId: string; workingDir: string }
-): void {
-  bus.emit('session', sessionEvent('SESSION_STARTED', data, ctx));
-}
-
-/** Emit SESSION_LOADING when an existing session is being loaded from disk. */
-export function emitSessionLoading(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { sessionId: string; path: string }
-): void {
-  bus.emit('session', sessionEvent('SESSION_LOADING', data, ctx));
-}
-
-/** Emit SESSION_RESUMED when a previously saved session is being resumed. */
-export function emitSessionResumed(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { sessionId: string; turnCount: number }
-): void {
-  bus.emit('session', sessionEvent('SESSION_RESUMED', data, ctx));
-}
-
-/** Emit SESSION_REPAIRING when session state is being repaired after a detected inconsistency. */
-export function emitSessionRepairing(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { sessionId: string; reason: string }
-): void {
-  bus.emit('session', sessionEvent('SESSION_REPAIRING', data, ctx));
-}
-
-/** Emit SESSION_RECONCILING when context messages are being reconciled with stored state. */
-export function emitSessionReconciling(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { sessionId: string; messageCount: number }
-): void {
-  bus.emit('session', sessionEvent('SESSION_RECONCILING', data, ctx));
-}
-
-/** Emit SESSION_READY when session is fully loaded and ready for input. */
-export function emitSessionReady(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { sessionId: string }
-): void {
-  bus.emit('session', sessionEvent('SESSION_READY', data, ctx));
-}
-
-/** Emit SESSION_RECOVERY_FAILED when session recovery has failed unrecoverably. */
-export function emitSessionRecoveryFailed(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { sessionId: string; error: string }
-): void {
-  bus.emit('session', sessionEvent('SESSION_RECOVERY_FAILED', data, ctx));
-}

package/src/runtime/emitters/surfaces.ts

@@ -1,57 +0,0 @@
-/**
- * Surface emitters — typed wrappers for SurfaceEvent domain.
- */
-
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { SurfaceEvent, SurfaceKind } from '@pellux/goodvibes-sdk/platform/runtime/events/surfaces';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-function surfaceEvent<T extends SurfaceEvent['type']>(
-  type: T,
-  data: Omit<Extract<SurfaceEvent, { type: T }>, 'type'>,
-  ctx: EmitterContext,
-): RuntimeEventEnvelope<T, Extract<SurfaceEvent, { type: T }>> {
-  return createEventEnvelope(type, { type, ...data } as Extract<SurfaceEvent, { type: T }>, ctx);
-}
-
-export function emitSurfaceEnabled(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { surfaceKind: SurfaceKind; surfaceId: string; accountId: string },
-): void {
-  bus.emit('surfaces', surfaceEvent('SURFACE_ENABLED', data, ctx));
-}
-
-export function emitSurfaceDisabled(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { surfaceKind: SurfaceKind; surfaceId: string; reason: string },
-): void {
-  bus.emit('surfaces', surfaceEvent('SURFACE_DISABLED', data, ctx));
-}
-
-export function emitSurfaceAccountConnected(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { surfaceKind: SurfaceKind; surfaceId: string; accountId: string; displayName: string },
-): void {
-  bus.emit('surfaces', surfaceEvent('SURFACE_ACCOUNT_CONNECTED', data, ctx));
-}
-
-export function emitSurfaceAccountDegraded(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { surfaceKind: SurfaceKind; surfaceId: string; accountId: string; error: string },
-): void {
-  bus.emit('surfaces', surfaceEvent('SURFACE_ACCOUNT_DEGRADED', data, ctx));
-}
-
-export function emitSurfaceCapabilityChanged(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { surfaceKind: SurfaceKind; surfaceId: string; capability: string; enabled: boolean },
-): void {
-  bus.emit('surfaces', surfaceEvent('SURFACE_CAPABILITY_CHANGED', data, ctx));
-}

package/src/runtime/emitters/tasks.ts

@@ -1,69 +0,0 @@
-/**
- * Task emitters — typed emission wrappers for TaskEvent domain.
- */
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-/** Emit TASK_CREATED when a new task enters the queue. */
-export function emitTaskCreated(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { taskId: string; agentId?: string; description: string; priority: number }
-): void {
-  bus.emit('tasks', createEventEnvelope('TASK_CREATED', { type: 'TASK_CREATED', ...data }, ctx));
-}
-
-/** Emit TASK_STARTED when task execution begins. */
-export function emitTaskStarted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { taskId: string; agentId?: string }
-): void {
-  bus.emit('tasks', createEventEnvelope('TASK_STARTED', { type: 'TASK_STARTED', ...data }, ctx));
-}
-
-/** Emit TASK_BLOCKED when a task is waiting on a dependency. */
-export function emitTaskBlocked(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { taskId: string; agentId?: string; reason: string }
-): void {
-  bus.emit('tasks', createEventEnvelope('TASK_BLOCKED', { type: 'TASK_BLOCKED', ...data }, ctx));
-}
-
-/** Emit TASK_PROGRESS when a task makes measurable progress. */
-export function emitTaskProgress(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { taskId: string; agentId?: string; progress: number; message?: string }
-): void {
-  bus.emit('tasks', createEventEnvelope('TASK_PROGRESS', { type: 'TASK_PROGRESS', ...data }, ctx));
-}
-
-/** Emit TASK_COMPLETED when a task finishes successfully. */
-export function emitTaskCompleted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { taskId: string; agentId?: string; durationMs: number }
-): void {
-  bus.emit('tasks', createEventEnvelope('TASK_COMPLETED', { type: 'TASK_COMPLETED', ...data }, ctx));
-}
-
-/** Emit TASK_FAILED when a task fails. */
-export function emitTaskFailed(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { taskId: string; agentId?: string; error: string; durationMs: number }
-): void {
-  bus.emit('tasks', createEventEnvelope('TASK_FAILED', { type: 'TASK_FAILED', ...data }, ctx));
-}
-
-/** Emit TASK_CANCELLED when a task is cancelled. */
-export function emitTaskCancelled(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { taskId: string; agentId?: string; reason?: string }
-): void {
-  bus.emit('tasks', createEventEnvelope('TASK_CANCELLED', { type: 'TASK_CANCELLED', ...data }, ctx));
-}

package/src/runtime/emitters/tools.ts

@@ -1,140 +0,0 @@
-/**
- * Tool emitters — typed emission wrappers for ToolEvent domain.
- */
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-/** Emit TOOL_RECEIVED when a tool call is received from the LLM. */
-export function emitToolReceived(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; turnId: string; tool: string; args: Record<string, unknown> }
-): void {
-  bus.emit('tools', createEventEnvelope('TOOL_RECEIVED', { type: 'TOOL_RECEIVED', ...data }, ctx));
-}
-
-/** Emit TOOL_VALIDATED when tool arguments pass schema validation. */
-export function emitToolValidated(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; turnId: string; tool: string }
-): void {
-  bus.emit('tools', createEventEnvelope('TOOL_VALIDATED', { type: 'TOOL_VALIDATED', ...data }, ctx));
-}
-
-/** Emit TOOL_PREHOOKED after pre-execution hooks have run. */
-export function emitToolPrehooked(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; turnId: string; tool: string }
-): void {
-  bus.emit('tools', createEventEnvelope('TOOL_PREHOOKED', { type: 'TOOL_PREHOOKED', ...data }, ctx));
-}
-
-/** Emit TOOL_PERMISSIONED after permission check completes. */
-export function emitToolPermissioned(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; turnId: string; tool: string; approved: boolean }
-): void {
-  bus.emit('tools', createEventEnvelope('TOOL_PERMISSIONED', { type: 'TOOL_PERMISSIONED', ...data }, ctx));
-}
-
-/** Emit TOOL_EXECUTING when the tool starts executing. */
-export function emitToolExecuting(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; turnId: string; tool: string; startedAt: number }
-): void {
-  bus.emit('tools', createEventEnvelope('TOOL_EXECUTING', { type: 'TOOL_EXECUTING', ...data }, ctx));
-}
-
-/** Emit TOOL_MAPPED after the result is mapped for the provider. */
-export function emitToolMapped(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; turnId: string; tool: string }
-): void {
-  bus.emit('tools', createEventEnvelope('TOOL_MAPPED', { type: 'TOOL_MAPPED', ...data }, ctx));
-}
-
-/** Emit TOOL_POSTHOOKED after post-execution hooks have run. */
-export function emitToolPosthooked(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; turnId: string; tool: string }
-): void {
-  bus.emit('tools', createEventEnvelope('TOOL_POSTHOOKED', { type: 'TOOL_POSTHOOKED', ...data }, ctx));
-}
-
-/** Emit TOOL_SUCCEEDED when a tool call completes successfully. */
-export function emitToolSucceeded(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; turnId: string; tool: string; durationMs: number; result?: unknown }
-): void {
-  bus.emit('tools', createEventEnvelope('TOOL_SUCCEEDED', { type: 'TOOL_SUCCEEDED', ...data }, ctx));
-}
-
-/** Emit TOOL_FAILED when a tool call fails. */
-export function emitToolFailed(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; turnId: string; tool: string; error: string; durationMs: number; result?: unknown }
-): void {
-  bus.emit('tools', createEventEnvelope('TOOL_FAILED', { type: 'TOOL_FAILED', ...data }, ctx));
-}
-
-/** Emit TOOL_RECONCILED when unresolved tool calls are synthesized. */
-export function emitToolReconciled(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: {
-    turnId: string;
-    count: number;
-    callIds: string[];
-    toolNames: string[];
-    reason: string;
-    timestamp: number;
-    isMalformed?: boolean;
-  }
-): void {
-  bus.emit('tools', createEventEnvelope('TOOL_RECONCILED', { type: 'TOOL_RECONCILED', ...data }, ctx));
-}
-
-/** Emit TOOL_CANCELLED when a tool call is cancelled. */
-export function emitToolCancelled(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; turnId: string; tool: string; reason?: string }
-): void {
-  bus.emit('tools', createEventEnvelope('TOOL_CANCELLED', { type: 'TOOL_CANCELLED', ...data }, ctx));
-}
-
-/** Emit BUDGET_EXCEEDED_MS when wall-clock time limit is breached. */
-export function emitBudgetExceededMs(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; turnId: string; tool: string; phase: string; limitMs: number; elapsedMs: number }
-): void {
-  bus.emit('tools', createEventEnvelope('BUDGET_EXCEEDED_MS', { type: 'BUDGET_EXCEEDED_MS', ...data }, ctx));
-}
-
-/** Emit BUDGET_EXCEEDED_TOKENS when token consumption limit is breached. */
-export function emitBudgetExceededTokens(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; turnId: string; tool: string; phase: string; limitTokens: number; usedTokens: number }
-): void {
-  bus.emit('tools', createEventEnvelope('BUDGET_EXCEEDED_TOKENS', { type: 'BUDGET_EXCEEDED_TOKENS', ...data }, ctx));
-}
-
-/** Emit BUDGET_EXCEEDED_COST when cost-in-USD limit is breached. */
-export function emitBudgetExceededCost(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; turnId: string; tool: string; phase: string; limitCostUsd: number; usedCostUsd: number }
-): void {
-  bus.emit('tools', createEventEnvelope('BUDGET_EXCEEDED_COST', { type: 'BUDGET_EXCEEDED_COST', ...data }, ctx));
-}

package/src/runtime/emitters/transport.ts

@@ -1,78 +0,0 @@
-/**
- * Transport emitters — typed emission wrappers for TransportEvent domain.
- */
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-/** Emit TRANSPORT_INITIALIZING when the transport layer starts. */
-export function emitTransportInitializing(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { transportId: string; protocol: string }
-): void {
-  bus.emit('transport', createEventEnvelope('TRANSPORT_INITIALIZING', { type: 'TRANSPORT_INITIALIZING', ...data }, ctx));
-}
-
-/** Emit TRANSPORT_AUTHENTICATING when transport auth is in progress. */
-export function emitTransportAuthenticating(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { transportId: string }
-): void {
-  bus.emit('transport', createEventEnvelope('TRANSPORT_AUTHENTICATING', { type: 'TRANSPORT_AUTHENTICATING', ...data }, ctx));
-}
-
-/** Emit TRANSPORT_CONNECTED when the connection is ready. */
-export function emitTransportConnected(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { transportId: string; endpoint: string }
-): void {
-  bus.emit('transport', createEventEnvelope('TRANSPORT_CONNECTED', { type: 'TRANSPORT_CONNECTED', ...data }, ctx));
-}
-
-/** Emit TRANSPORT_SYNCING during state synchronisation. */
-export function emitTransportSyncing(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { transportId: string }
-): void {
-  bus.emit('transport', createEventEnvelope('TRANSPORT_SYNCING', { type: 'TRANSPORT_SYNCING', ...data }, ctx));
-}
-
-/** Emit TRANSPORT_DEGRADED during reduced-reliability operation. */
-export function emitTransportDegraded(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { transportId: string; reason: string }
-): void {
-  bus.emit('transport', createEventEnvelope('TRANSPORT_DEGRADED', { type: 'TRANSPORT_DEGRADED', ...data }, ctx));
-}
-
-/** Emit TRANSPORT_RECONNECTING when retrying after failure. */
-export function emitTransportReconnecting(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { transportId: string; attempt: number; maxAttempts: number }
-): void {
-  bus.emit('transport', createEventEnvelope('TRANSPORT_RECONNECTING', { type: 'TRANSPORT_RECONNECTING', ...data }, ctx));
-}
-
-/** Emit TRANSPORT_DISCONNECTED when the connection closes. */
-export function emitTransportDisconnected(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { transportId: string; reason?: string; willRetry: boolean }
-): void {
-  bus.emit('transport', createEventEnvelope('TRANSPORT_DISCONNECTED', { type: 'TRANSPORT_DISCONNECTED', ...data }, ctx));
-}
-
-/** Emit TRANSPORT_TERMINAL_FAILURE on unrecoverable failure. */
-export function emitTransportTerminalFailure(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { transportId: string; error: string }
-): void {
-  bus.emit('transport', createEventEnvelope('TRANSPORT_TERMINAL_FAILURE', { type: 'TRANSPORT_TERMINAL_FAILURE', ...data }, ctx));
-}