@pellux/goodvibes-tui 0.18.11 → 0.18.13

package/src/channels/builtin/plugins.ts

@@ -1,308 +0,0 @@
-import {
-  type SurfaceAdapterContext,
-  handleBlueBubblesSurfaceWebhook,
-  handleDiscordSurfaceWebhook,
-  handleGenericWebhookSurface,
-  handleGoogleChatSurfaceWebhook,
-  handleIMessageSurfaceWebhook,
-  handleMSTeamsSurfaceWebhook,
-  handleMattermostSurfaceWebhook,
-  handleMatrixSurfaceWebhook,
-  handleNtfySurfaceWebhook,
-  handleSignalSurfaceWebhook,
-  handleSlackSurfaceWebhook,
-  handleTelegramSurfaceWebhook,
-  handleWhatsAppSurfaceWebhook,
-} from '@pellux/goodvibes-sdk/platform/adapters/index';
-import type { AutomationRouteBinding } from '@pellux/goodvibes-sdk/platform/automation/routes';
-import type { SharedApprovalRecord } from '@pellux/goodvibes-sdk/platform/control-plane/index';
-import type { ProviderRuntimeSurface } from '@pellux/goodvibes-sdk/platform/channels/provider-runtime';
-import type {
-  ChannelAccountRecord,
-  ChannelCapabilityDescriptor,
-  ChannelDirectoryEntry,
-  ChannelDirectoryQueryOptions,
-  ChannelOperatorActionDescriptor,
-  ChannelSurface,
-  ChannelToolDescriptor,
-} from '@pellux/goodvibes-sdk/platform/channels/types';
-import type { ChannelPlugin } from '@pellux/goodvibes-sdk/platform/channels/plugin-registry';
-import type { BuiltinChannelRuntimeDeps, ManagedSurface } from '@pellux/goodvibes-sdk/platform/channels/builtin/shared';
-
-interface BuiltinPluginRegistrationContext {
-  readonly deps: BuiltinChannelRuntimeDeps;
-  readonly buildAccount: (surface: ChannelSurface) => Promise<ChannelAccountRecord>;
-  readonly resolveAccount: (surface: ChannelSurface, accountId: string) => Promise<ChannelAccountRecord | null>;
-  readonly listCapabilities: (surface: ChannelSurface) => Promise<ChannelCapabilityDescriptor[]>;
-  readonly listTools: (surface: ChannelSurface) => ChannelToolDescriptor[];
-  readonly runTool: (surface: ChannelSurface, toolId: string, input?: Record<string, unknown>) => Promise<unknown>;
-  readonly listOperatorActions: (surface: ChannelSurface) => ChannelOperatorActionDescriptor[];
-  readonly runOperatorAction: (surface: ChannelSurface, actionId: string, input?: Record<string, unknown>) => Promise<unknown>;
-  readonly buildContractHooks: (surface: ChannelSurface) => Pick<
-    ChannelPlugin,
-    | 'setupVersion'
-    | 'renderPolicy'
-    | 'getSetupSchema'
-    | 'doctor'
-    | 'listRepairActions'
-    | 'getLifecycleState'
-    | 'migrateLifecycle'
-    | 'resolveAllowlist'
-    | 'editAllowlist'
-  >;
-  readonly buildProductHooks: (surface: ChannelSurface) => Pick<
-    ChannelPlugin,
-    | 'runAccountAction'
-    | 'authorizeActorAction'
-    | 'parseExplicitTarget'
-    | 'inferTargetConversationKind'
-    | 'resolveTarget'
-    | 'resolveSessionTarget'
-    | 'resolveParentConversationCandidates'
-    | 'renderEvent'
-    | 'listAgentTools'
-  >;
-  readonly lookupDirectory: (surface: ManagedSurface, query: string, options?: ChannelDirectoryQueryOptions) => Promise<ChannelDirectoryEntry[]>;
-  readonly lookupRouteDirectory: (surface: ManagedSurface, query: string, options?: ChannelDirectoryQueryOptions) => Promise<ChannelDirectoryEntry[]>;
-  readonly notifyApprovalViaRouter: (surface: ChannelSurface, approval: SharedApprovalRecord, binding: AutomationRouteBinding) => Promise<void>;
-  readonly providerRuntimeStatus: (surface: ProviderRuntimeSurface) => unknown;
-}
-
-export function registerBuiltinChannelPlugins(context: BuiltinPluginRegistrationContext): void {
-  context.deps.channelPlugins.register({
-    id: 'surface:tui',
-    surface: 'tui',
-    displayName: 'Terminal UI',
-    capabilities: ['ingress', 'egress', 'session_binding', 'account_lifecycle', 'target_resolution', 'agent_tools'],
-    getStatus: async () => ({
-      id: 'surface:tui',
-      surface: 'tui',
-      label: 'Terminal UI',
-      state: 'healthy',
-      enabled: true,
-      metadata: {},
-    }),
-    listAccounts: async () => [await context.buildAccount('tui')],
-    getAccount: async (accountId) => context.resolveAccount('tui', accountId),
-    listCapabilities: async () => context.listCapabilities('tui'),
-    listTools: async () => context.listTools('tui'),
-    runTool: (toolId, input) => context.runTool('tui', toolId, input),
-    listOperatorActions: async () => context.listOperatorActions('tui'),
-    runOperatorAction: (actionId, input) => context.runOperatorAction('tui', actionId, input),
-    ...context.buildContractHooks('tui'),
-    ...context.buildProductHooks('tui'),
-    lookupDirectory: async (query) => query.trim()
-      ? [{ id: 'surface:tui', surface: 'tui', kind: 'service', label: 'Terminal UI', metadata: {} }]
-      : [],
-  });
-
-  context.deps.channelPlugins.register({
-    id: 'surface:web',
-    surface: 'web',
-    displayName: 'Web control plane',
-    capabilities: ['ingress', 'egress', 'threaded_reply', 'account_lifecycle', 'target_resolution', 'agent_tools'],
-    getStatus: async () => ({
-      id: 'surface:web',
-      surface: 'web',
-      label: 'Web control plane',
-      state: context.deps.configManager.get('web.enabled') || context.deps.configManager.get('controlPlane.enabled') ? 'healthy' : 'disabled',
-      enabled: Boolean(context.deps.configManager.get('web.enabled') || context.deps.configManager.get('controlPlane.enabled')),
-      metadata: {
-        baseUrl: context.deps.configManager.get('web.publicBaseUrl'),
-      },
-    }),
-    listAccounts: async () => [await context.buildAccount('web')],
-    getAccount: async (accountId) => context.resolveAccount('web', accountId),
-    listCapabilities: async () => context.listCapabilities('web'),
-    listTools: async () => context.listTools('web'),
-    runTool: (toolId, input) => context.runTool('web', toolId, input),
-    listOperatorActions: async () => context.listOperatorActions('web'),
-    runOperatorAction: (actionId, input) => context.runOperatorAction('web', actionId, input),
-    ...context.buildContractHooks('web'),
-    ...context.buildProductHooks('web'),
-    lookupDirectory: async () => [{ id: 'surface:web', surface: 'web', kind: 'service', label: 'Web control plane', metadata: {} }],
-  });
-
-  context.deps.channelPlugins.register({
-    id: 'surface:slack',
-    surface: 'slack',
-    displayName: 'Slack',
-    capabilities: ['ingress', 'egress', 'threaded_reply', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'],
-    webhookPath: '/webhook/slack',
-    handleInbound: (req) => handleSlackSurfaceWebhook(req, context.deps.buildSurfaceAdapterContext()),
-    deliverReply: (pending, message) => context.deps.deliverSlackAgentReply(pending, message),
-    deliverProgress: (pending, progress) => context.deps.deliverSurfaceProgress(pending, progress),
-    notifyApproval: (approval, binding) => context.deps.deliverSlackApprovalUpdate(approval, binding),
-    getStatus: async () => ({
-      id: 'surface:slack',
-      surface: 'slack',
-      label: 'Slack',
-      state: context.deps.surfaceDeliveryEnabled('slack') ? 'healthy' : 'disabled',
-      enabled: context.deps.surfaceDeliveryEnabled('slack'),
-      accountId: String(context.deps.configManager.get('surfaces.slack.workspaceId') || ''),
-      metadata: {
-        defaultChannel: context.deps.configManager.get('surfaces.slack.defaultChannel'),
-        providerRuntime: context.providerRuntimeStatus('slack'),
-      },
-    }),
-    listAccounts: async () => [await context.buildAccount('slack')],
-    getAccount: async (accountId) => context.resolveAccount('slack', accountId),
-    listCapabilities: async () => context.listCapabilities('slack'),
-    listTools: async () => context.listTools('slack'),
-    runTool: (toolId, input) => context.runTool('slack', toolId, input),
-    listOperatorActions: async () => context.listOperatorActions('slack'),
-    runOperatorAction: (actionId, input) => context.runOperatorAction('slack', actionId, input),
-    ...context.buildContractHooks('slack'),
-    ...context.buildProductHooks('slack'),
-    lookupDirectory: async (query, options) => context.lookupDirectory('slack', query, options),
-  });
-
-  context.deps.channelPlugins.register({
-    id: 'surface:discord',
-    surface: 'discord',
-    displayName: 'Discord',
-    capabilities: ['ingress', 'egress', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'],
-    webhookPath: '/webhook/discord',
-    handleInbound: (req) => handleDiscordSurfaceWebhook(req, context.deps.buildSurfaceAdapterContext()),
-    deliverReply: (pending, message) => context.deps.deliverDiscordAgentReply(pending, message),
-    deliverProgress: (pending, progress) => context.deps.deliverSurfaceProgress(pending, progress),
-    notifyApproval: (approval, binding) => context.deps.deliverDiscordApprovalUpdate(approval, binding),
-    getStatus: async () => ({
-      id: 'surface:discord',
-      surface: 'discord',
-      label: 'Discord',
-      state: context.deps.surfaceDeliveryEnabled('discord') ? 'healthy' : 'disabled',
-      enabled: context.deps.surfaceDeliveryEnabled('discord'),
-      accountId: String(context.deps.configManager.get('surfaces.discord.applicationId') || ''),
-      metadata: {
-        defaultChannelId: context.deps.configManager.get('surfaces.discord.defaultChannelId'),
-        providerRuntime: context.providerRuntimeStatus('discord'),
-      },
-    }),
-    listAccounts: async () => [await context.buildAccount('discord')],
-    getAccount: async (accountId) => context.resolveAccount('discord', accountId),
-    listCapabilities: async () => context.listCapabilities('discord'),
-    listTools: async () => context.listTools('discord'),
-    runTool: (toolId, input) => context.runTool('discord', toolId, input),
-    listOperatorActions: async () => context.listOperatorActions('discord'),
-    runOperatorAction: (actionId, input) => context.runOperatorAction('discord', actionId, input),
-    ...context.buildContractHooks('discord'),
-    ...context.buildProductHooks('discord'),
-    lookupDirectory: async (query, options) => context.lookupDirectory('discord', query, options),
-  });
-
-  context.deps.channelPlugins.register({
-    id: 'surface:ntfy',
-    surface: 'ntfy',
-    displayName: 'ntfy',
-    capabilities: ['ingress', 'egress', 'delivery_only', 'account_lifecycle', 'target_resolution', 'agent_tools'],
-    webhookPath: '/webhook/ntfy',
-    handleInbound: (req) => handleNtfySurfaceWebhook(req, context.deps.buildSurfaceAdapterContext()),
-    deliverReply: (pending, message) => context.deps.deliverNtfyAgentReply(pending, message),
-    notifyApproval: (approval, binding) => context.deps.deliverNtfyApprovalUpdate(approval, binding),
-    getStatus: async () => ({
-      id: 'surface:ntfy',
-      surface: 'ntfy',
-      label: 'ntfy',
-      state: context.deps.surfaceDeliveryEnabled('ntfy') ? 'healthy' : 'disabled',
-      enabled: context.deps.surfaceDeliveryEnabled('ntfy'),
-      metadata: {
-        topic: context.deps.configManager.get('surfaces.ntfy.topic'),
-        baseUrl: context.deps.configManager.get('surfaces.ntfy.baseUrl'),
-        providerRuntime: context.providerRuntimeStatus('ntfy'),
-      },
-    }),
-    listAccounts: async () => [await context.buildAccount('ntfy')],
-    getAccount: async (accountId) => context.resolveAccount('ntfy', accountId),
-    listCapabilities: async () => context.listCapabilities('ntfy'),
-    listTools: async () => context.listTools('ntfy'),
-    runTool: (toolId, input) => context.runTool('ntfy', toolId, input),
-    listOperatorActions: async () => context.listOperatorActions('ntfy'),
-    runOperatorAction: (actionId, input) => context.runOperatorAction('ntfy', actionId, input),
-    ...context.buildContractHooks('ntfy'),
-    ...context.buildProductHooks('ntfy'),
-    lookupDirectory: async (query, options) => context.lookupDirectory('ntfy', query, options),
-  });
-
-  context.deps.channelPlugins.register({
-    id: 'surface:webhook',
-    surface: 'webhook',
-    displayName: 'Generic webhook',
-    capabilities: ['ingress', 'egress', 'delivery_only', 'account_lifecycle', 'target_resolution', 'agent_tools'],
-    webhookPath: '/webhook/generic',
-    handleInbound: (req) => handleGenericWebhookSurface(req, context.deps.buildGenericWebhookAdapterContext()),
-    deliverReply: (pending, message) => context.deps.deliverWebhookAgentReply(pending, message),
-    notifyApproval: (approval, binding) => context.deps.deliverWebhookApprovalUpdate(approval, binding),
-    getStatus: async () => ({
-      id: 'surface:webhook',
-      surface: 'webhook',
-      label: 'Generic webhook',
-      state: context.deps.surfaceDeliveryEnabled('webhook') ? 'healthy' : 'disabled',
-      enabled: context.deps.surfaceDeliveryEnabled('webhook'),
-      metadata: {
-        defaultTarget: context.deps.configManager.get('surfaces.webhook.defaultTarget'),
-      },
-    }),
-    listAccounts: async () => [await context.buildAccount('webhook')],
-    getAccount: async (accountId) => context.resolveAccount('webhook', accountId),
-    listCapabilities: async () => context.listCapabilities('webhook'),
-    listTools: async () => context.listTools('webhook'),
-    runTool: (toolId, input) => context.runTool('webhook', toolId, input),
-    listOperatorActions: async () => context.listOperatorActions('webhook'),
-    runOperatorAction: (actionId, input) => context.runOperatorAction('webhook', actionId, input),
-    ...context.buildContractHooks('webhook'),
-    ...context.buildProductHooks('webhook'),
-    lookupDirectory: async (query, options) => context.lookupRouteDirectory('webhook', query, options),
-  });
-
-  registerRouterBackedPlugin(context, 'telegram', 'Telegram', ['ingress', 'egress', 'threaded_reply', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/telegram', handleTelegramSurfaceWebhook);
-  registerRouterBackedPlugin(context, 'google-chat', 'Google Chat', ['ingress', 'egress', 'threaded_reply', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/google-chat', handleGoogleChatSurfaceWebhook);
-  registerRouterBackedPlugin(context, 'signal', 'Signal', ['ingress', 'egress', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/signal', handleSignalSurfaceWebhook);
-  registerRouterBackedPlugin(context, 'whatsapp', 'WhatsApp', ['ingress', 'egress', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/whatsapp', handleWhatsAppSurfaceWebhook);
-  registerRouterBackedPlugin(context, 'imessage', 'iMessage', ['ingress', 'egress', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/imessage', handleIMessageSurfaceWebhook);
-  registerRouterBackedPlugin(context, 'msteams', 'Microsoft Teams', ['ingress', 'egress', 'threaded_reply', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/msteams', handleMSTeamsSurfaceWebhook);
-  registerRouterBackedPlugin(context, 'bluebubbles', 'BlueBubbles', ['ingress', 'egress', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/bluebubbles', handleBlueBubblesSurfaceWebhook);
-  registerRouterBackedPlugin(context, 'mattermost', 'Mattermost', ['ingress', 'egress', 'threaded_reply', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/mattermost', handleMattermostSurfaceWebhook);
-  registerRouterBackedPlugin(context, 'matrix', 'Matrix', ['ingress', 'egress', 'threaded_reply', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/matrix', handleMatrixSurfaceWebhook);
-}
-
-function registerRouterBackedPlugin(
-  context: BuiltinPluginRegistrationContext,
-  surface: ManagedSurface,
-  displayName: string,
-  capabilities: ChannelPlugin['capabilities'],
-  webhookPath: string,
-  handleInbound: (req: Request, context: SurfaceAdapterContext) => Promise<Response>,
-): void {
-  context.deps.channelPlugins.register({
-    id: `surface:${surface}`,
-    surface,
-    displayName,
-    capabilities,
-    webhookPath,
-    handleInbound: (req) => handleInbound(req, context.deps.buildSurfaceAdapterContext()),
-    getStatus: async () => {
-      const account = await context.buildAccount(surface);
-      return {
-        id: `surface:${surface}`,
-        surface,
-        label: displayName,
-        state: account.state === 'healthy' ? 'healthy' : account.state === 'disabled' ? 'disabled' : 'degraded',
-        enabled: context.deps.surfaceDeliveryEnabled(surface),
-        accountId: account.accountId,
-        metadata: account.metadata,
-      };
-    },
-    listAccounts: async () => [await context.buildAccount(surface)],
-    getAccount: async (accountId) => context.resolveAccount(surface, accountId),
-    listCapabilities: async () => context.listCapabilities(surface),
-    listTools: async () => context.listTools(surface),
-    runTool: (toolId, input) => context.runTool(surface, toolId, input),
-    listOperatorActions: async () => context.listOperatorActions(surface),
-    runOperatorAction: (actionId, input) => context.runOperatorAction(surface, actionId, input),
-    notifyApproval: (approval, binding) => context.notifyApprovalViaRouter(surface, approval, binding),
-    ...context.buildContractHooks(surface),
-    ...context.buildProductHooks(surface),
-    lookupDirectory: async (query, options) => context.lookupDirectory(surface, query, options),
-  });
-}

package/src/channels/builtin/rendering.ts

@@ -1,174 +0,0 @@
-import type { AutomationRouteBinding } from '@pellux/goodvibes-sdk/platform/automation/routes';
-import type { SharedApprovalRecord } from '@pellux/goodvibes-sdk/platform/control-plane/index';
-import type { Tool } from '@pellux/goodvibes-sdk/platform/types/tools';
-import type { ChannelDeliveryRouteBinding } from '@pellux/goodvibes-sdk/platform/channels/delivery-router';
-import type { ChannelDeliveryRequest } from '@pellux/goodvibes-sdk/platform/channels/delivery/types';
-import type {
-  ChannelRenderRequest,
-  ChannelRenderResult,
-  ChannelSurface,
-  ChannelToolDescriptor,
-} from '@pellux/goodvibes-sdk/platform/channels/types';
-import type { BuiltinChannelRuntimeDeps } from '@pellux/goodvibes-sdk/platform/channels/builtin/shared';
-
-interface BuiltinRenderingContext {
-  readonly deps: BuiltinChannelRuntimeDeps;
-  readonly listTools: (surface: ChannelSurface) => ChannelToolDescriptor[];
-  readonly runTool: (surface: ChannelSurface, toolId: string, input?: Record<string, unknown>) => Promise<unknown>;
-}
-
-export async function renderBuiltinChannelEvent(
-  context: BuiltinRenderingContext,
-  surface: ChannelSurface,
-  request: ChannelRenderRequest,
-): Promise<ChannelRenderResult> {
-  const router = context.deps.deliveryRouter;
-  const binding = request.routeId ? context.deps.routeBindings.getBinding(request.routeId) : undefined;
-  const responseId = await router.deliver({
-    target: buildDeliveryTarget(surface, request, binding),
-    body: request.text,
-    title: request.title,
-    jobId: binding?.jobId ?? request.routeId ?? `channel:${surface}`,
-    runId: binding?.runId ?? request.agentId ?? request.sessionId ?? `${surface}:${Date.now()}`,
-    ...(request.agentId ? { agentId: request.agentId } : {}),
-    status: renderStatus(request),
-    includeLinks: request.phase !== 'progress',
-    ...(binding ? { binding: toDeliveryRouteBinding(binding) } : {}),
-  });
-  return {
-    delivered: true,
-    ...(responseId ? { responseId } : {}),
-    ...(binding?.threadId ? { threadId: binding.threadId } : {}),
-    metadata: {
-      surface,
-      phase: request.phase,
-      via: 'channel-delivery-router',
-    },
-  };
-}
-
-export async function notifyBuiltinApprovalViaRouter(
-  context: BuiltinRenderingContext,
-  surface: ChannelSurface,
-  approval: SharedApprovalRecord,
-  binding: AutomationRouteBinding,
-): Promise<void> {
-  const router = context.deps.deliveryRouter;
-  const status = approval.status === 'approved'
-    ? 'completed'
-    : approval.status === 'denied' || approval.status === 'cancelled' || approval.status === 'expired'
-      ? 'failed'
-      : 'running';
-  await router.deliver({
-    target: buildDeliveryTarget(surface, { pending: {} }, binding),
-    body: formatApprovalMessage(approval),
-    title: `Approval ${approval.status}: ${approval.request.tool}`,
-    jobId: binding.jobId ?? `approval:${approval.id}`,
-    runId: binding.runId ?? approval.id,
-    status,
-    includeLinks: true,
-    binding: toDeliveryRouteBinding(binding),
-  });
-}
-
-export function listBuiltinAgentTools(
-  context: BuiltinRenderingContext,
-  surface: ChannelSurface,
-): readonly Tool[] {
-  return context.listTools(surface).map((descriptor): Tool => ({
-    definition: {
-      name: descriptor.name,
-      description: descriptor.description,
-      parameters: descriptor.inputSchema ?? {
-        type: 'object',
-        additionalProperties: true,
-      },
-      sideEffects: ['network', 'state'],
-      concurrency: 'serial',
-    },
-    execute: async (args) => {
-      const result = await context.runTool(surface, descriptor.id, args);
-      if (result === null) {
-        return {
-          success: false,
-          error: `Unknown channel tool '${descriptor.id}' for surface '${surface}'.`,
-        };
-      }
-      return {
-        success: true,
-        output: JSON.stringify({ surface, toolId: descriptor.id, result }, null, 2),
-      };
-    },
-  }));
-}
-
-function buildDeliveryTarget(
-  surface: ChannelSurface,
-  request: { readonly pending?: Record<string, unknown> },
-  binding?: AutomationRouteBinding,
-): ChannelDeliveryRequest['target'] {
-  const pending = request.pending ?? {};
-  const address = surface === 'webhook'
-    ? readPendingString(pending, 'callbackUrl')
-      ?? readMetadataString(binding?.metadata, 'callbackUrl')
-    : readPendingString(pending, 'targetAddress')
-      ?? readPendingString(pending, 'responseUrl')
-      ?? readPendingString(pending, 'channelId')
-      ?? readPendingString(pending, 'topic')
-      ?? binding?.channelId
-      ?? binding?.externalId;
-  if (surface === 'webhook') {
-    return {
-      kind: 'webhook',
-      surfaceKind: 'webhook',
-      ...(address ? { address } : {}),
-    };
-  }
-  return {
-    kind: 'surface',
-    surfaceKind: surface,
-    ...(address ? { address } : {}),
-  };
-}
-
-function toDeliveryRouteBinding(binding: AutomationRouteBinding): ChannelDeliveryRouteBinding {
-  return {
-    id: binding.id,
-    surfaceKind: binding.surfaceKind,
-    surfaceId: binding.surfaceId,
-    externalId: binding.externalId,
-    ...(binding.threadId ? { threadId: binding.threadId } : {}),
-    ...(binding.channelId ? { channelId: binding.channelId } : {}),
-    ...(binding.title ? { title: binding.title } : {}),
-    metadata: { ...binding.metadata },
-  };
-}
-
-function renderStatus(request: ChannelRenderRequest): string {
-  if (request.events.some((event) => event.kind === 'error')) return 'failed';
-  if (request.phase === 'final') return 'completed';
-  if (request.phase === 'approval') return 'running';
-  return 'running';
-}
-
-function formatApprovalMessage(approval: SharedApprovalRecord): string {
-  const lines = [
-    `Approval ${approval.status}: ${approval.id}`,
-    `Tool: ${approval.request.tool}`,
-    approval.request.analysis.summary,
-    approval.request.analysis.target ? `Target: ${approval.request.analysis.target}` : '',
-    approval.resolvedBy ? `Resolved by: ${approval.resolvedBy}` : '',
-  ].filter((line) => line.trim().length > 0);
-  return lines.join('\n');
-}
-
-function readPendingString(pending: Record<string, unknown>, key: string): string | undefined {
-  const value = pending[key];
-  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
-}
-
-function readMetadataString(metadata: Record<string, unknown> | undefined, key: string): string | undefined {
-  if (!metadata) return undefined;
-  const value = metadata[key];
-  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
-}