@recombine-ai/platform 0.2.6-test.9 → 0.3.0

package/build/engine/stream/engine.js

@@ -0,0 +1,167 @@
+import nunjucks from 'nunjucks';
+import { createStubStepTracer } from '../bosun';
+import { defaultLogger } from '../default-logger';
+import { reportProviderError } from '../monitoring';
+import { stdPrompt } from '../step-registry';
+import { agentFilter, composeTokenTransformers } from './token-transformers';
+export function createAIStreamEngine(cfg) {
+    const nunjucksEnv = cfg.nunjucksEnv ??
+        nunjucks.configure({
+            autoescape: false,
+            trimBlocks: true,
+            lstripBlocks: true,
+        });
+    function createWorkflow({ name, prompt, model, tokenTransformers = [agentFilter], onError, }) {
+        const logger = cfg.logger || defaultLogger();
+        logger.debug('streamAiEngine.createWorkflow');
+        const stepTracer = cfg.stepTracer || createStubStepTracer(logger);
+        cfg.stepRegistry?.addStep({
+            type: 'streaming-response',
+            name,
+            prompt: stdPrompt(prompt),
+        });
+        async function run(messages, ctx) {
+            const runId = crypto.randomUUID();
+            logger.debug(`streamingWorkflow.run runId: ${runId}`);
+            const startTime = performance.now();
+            const transcript = createTranscript(logger, messages);
+            const initiatedTransformers = tokenTransformers.map((init) => init());
+            const template = typeof prompt === 'string' ? prompt : await prompt.content();
+            const renderedPrompt = nunjucksEnv.renderString(template, ctx || {});
+            const stringifiedConversation = transcript.toString();
+            const mainStepTrace = {
+                workflowId: name,
+                workflowRunId: runId,
+                name: name,
+                model: JSON.stringify(model.getOptions()),
+                createdAt: Date.now(),
+                response: '',
+                receivedContext: ctx,
+                receivedPrompt: template,
+                renderedPrompt: renderedPrompt,
+                stringifiedConversation: stringifiedConversation,
+            };
+            let mainStepStream;
+            try {
+                mainStepStream = await model.generateStream(renderedPrompt, stringifiedConversation);
+            }
+            catch (error) {
+                logger.error('AI Engine Stream: LLM error', { error });
+                reportProviderError(error, {
+                    logger,
+                    eventTracer: cfg.eventTracer,
+                    providerInfo: model.getProviderInfo?.(),
+                });
+                mainStepTrace.error = error instanceof Error ? error : new Error(String(error));
+                stepTracer.addStepTrace(mainStepTrace);
+                await stepTracer.flush();
+                await onError(error, ctx);
+                return new ReadableStream({
+                    start(controller) {
+                        controller.error(error);
+                    },
+                });
+            }
+            return mainStepStream
+                .pipeThrough(metrics(startTime))
+                .pipeThrough(composeTokenTransformers(initiatedTransformers))
+                .pipeThrough(packageAsResponseChunk())
+                .pipeThrough(pushToTranscript(transcript))
+                .pipeThrough(flushTrace(mainStepTrace, transcript));
+        }
+        function metrics(startTime) {
+            let measureTtft = true;
+            return new TransformStream({
+                start() {
+                    logger.debug(`[MARK] LLM stream created: ${(performance.now() - startTime).toFixed(2)}ms`);
+                },
+                transform(chunk, controller) {
+                    if (measureTtft) {
+                        logger.debug(`[MARK] TTFT: ${(performance.now() - startTime).toFixed(2)}ms`);
+                        measureTtft = false;
+                    }
+                    controller.enqueue(chunk);
+                },
+                flush() {
+                    logger.debug(`[MARK] LLM stream finished: ${(performance.now() - startTime).toFixed(2)}`);
+                },
+            });
+        }
+        function packageAsResponseChunk() {
+            return new TransformStream({
+                transform(chunk, controller) {
+                    controller.enqueue({ role: 'agent', delta: chunk });
+                },
+            });
+        }
+        function pushToTranscript(transcript) {
+            return new TransformStream({
+                transform(chunk, controller) {
+                    transcript.responseChunks.push(chunk);
+                    controller.enqueue(chunk);
+                },
+            });
+        }
+        function flushTrace(mainStepTrace, transcript) {
+            return new TransformStream({
+                async flush() {
+                    mainStepTrace.response = transcript.currentResponse;
+                    stepTracer.addStepTrace(mainStepTrace);
+                    try {
+                        await stepTracer.flush();
+                    }
+                    catch (e) {
+                        logger.error('stepTracer.flush failed', { error: e });
+                    }
+                },
+            });
+        }
+        return {
+            run,
+        };
+    }
+    return {
+        createWorkflow,
+    };
+}
+function createTranscript(logger, initialMessages) {
+    const messages = [...initialMessages];
+    const directivesFormatter = (msg) => `${msg.sender}: ${msg.text}`;
+    const currentResponseFormatter = (partial) => `Current response: ${partial}`;
+    const responseTokens = [];
+    const names = {
+        agent: 'Agent',
+        user: 'User',
+        system: 'System',
+    };
+    return {
+        responseChunks: responseTokens,
+        get currentResponse() {
+            return responseTokens
+                .filter((token) => token.role === 'agent')
+                .map((token) => token?.delta)
+                .join('');
+        },
+        get messages() {
+            return initialMessages;
+        },
+        toString(ignoreDirectives = false) {
+            const serializedMessages = messages
+                .map((msg) => {
+                if (msg.sender === 'system') {
+                    return ignoreDirectives ? null : directivesFormatter(msg);
+                }
+                return `${names[msg.sender]}: ${msg.text}`;
+            })
+                .filter((line) => line !== null)
+                .join('\n');
+            if (responseTokens.length === 0) {
+                return serializedMessages;
+            }
+            return serializedMessages + '\n' + currentResponseFormatter(this.currentResponse);
+        },
+        getConversation() {
+            return messages;
+        },
+    };
+}

package/build/engine/stream/get-client.d.ts

@@ -0,0 +1,15 @@
+import OpenAI, { AzureOpenAI } from 'openai';
+import { Logger } from '../interfaces';
+interface AzureConfig {
+    endpoint: string;
+    apiVersion: string;
+    deployment: string;
+    apiKey: string;
+}
+interface OpenAiConfig {
+    apiKey: string;
+}
+export declare function getAzureClient(logger: Logger, config: AzureConfig): AzureOpenAI;
+export declare function getOpenAiClient(logger: Logger, config: OpenAiConfig): OpenAI;
+export {};
+//# sourceMappingURL=get-client.d.ts.map

package/build/engine/stream/get-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-client.d.ts","sourceRoot":"","sources":["../../../src/engine/stream/get-client.ts"],"names":[],"mappings":"AACA,OAAO,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAG5C,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAEtC,UAAU,WAAW;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;CACjB;AAED,UAAU,YAAY;IAClB,MAAM,EAAE,MAAM,CAAA;CACjB;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,eASjE;AACD,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,UAMnE"}

package/build/engine/stream/get-client.js

@@ -0,0 +1,118 @@
+import OpenAI, { AzureOpenAI } from 'openai';
+import { Client as HttpClient } from 'undici';
+export function getAzureClient(logger, config) {
+    logger.debug(`getting azure client: ${config.endpoint}, v: ${config.apiVersion}`);
+    return new AzureOpenAI({
+        apiKey: config.apiKey,
+        apiVersion: config.apiVersion,
+        endpoint: config.endpoint,
+        deployment: config.deployment,
+        fetch: getOptimizedFetch(logger, new URL(config.endpoint).origin),
+    });
+}
+export function getOpenAiClient(logger, config) {
+    logger.debug(`getting OpenAi client.`);
+    return new OpenAI({
+        apiKey: config.apiKey,
+        fetch: getOptimizedFetch(logger, 'https://api.openai.com'),
+    });
+}
+function getOptimizedFetch(logger, url) {
+    const defaultHeaders = {
+        'content-type': 'application/json',
+        accept: 'application/json',
+        connection: 'keep-alive',
+    };
+    const httpClient = new HttpClient(url, {
+        keepAliveTimeout: 120_000,
+        keepAliveMaxTimeout: 300_000,
+        pipelining: 10,
+        connect: {
+            noDelay: true,
+            keepAlive: true,
+            rejectUnauthorized: false,
+        },
+        maxCachedSessions: 100,
+        headersTimeout: 30000,
+        bodyTimeout: 60000,
+    });
+    process.on('SIGTERM', () => {
+        void httpClient.close();
+    });
+    process.on('SIGINT', () => {
+        void httpClient.close();
+    });
+    async function customFetch(url, options = {}) {
+        const requestUrl = url instanceof Request ? url.url : url.toString();
+        const method = options.method || 'GET';
+        logger.debug('Optimized Fetch', { method, url });
+        const originalHeaders = options.headers instanceof Headers
+            ? Object.fromEntries(options.headers.entries())
+            : options.headers;
+        const headers = {
+            ...defaultHeaders,
+            ...(originalHeaders || {}),
+        };
+        const response = await httpClient.request({
+            path: new URL(requestUrl).pathname + new URL(requestUrl).search,
+            method,
+            headers,
+            body: options.body,
+            origin: new URL(requestUrl).origin,
+        });
+        const responseHeaders = new Headers();
+        Object.entries(response.headers).forEach(([key, value]) => {
+            if (Array.isArray(value)) {
+                value.forEach((v) => responseHeaders.append(key, v));
+            }
+            else if (value !== undefined) {
+                responseHeaders.append(key, value);
+            }
+        });
+        if (response.statusCode === 429) {
+            logger.debug('LLM provider returned 429', { url: requestUrl });
+        }
+        let canceled = false;
+        return new Response(new ReadableStream({
+            cancel() {
+                canceled = true;
+            },
+            start(controller) {
+                response.body.on('data', (chunk) => {
+                    if (canceled)
+                        return;
+                    try {
+                        controller.enqueue(chunk);
+                    }
+                    catch (e) {
+                        logger.error(e);
+                    }
+                });
+                response.body.on('end', () => {
+                    if (canceled)
+                        return;
+                    try {
+                        controller.close();
+                    }
+                    catch (e) {
+                        logger.error(e);
+                    }
+                });
+                response.body.on('error', (err) => {
+                    if (canceled)
+                        return;
+                    try {
+                        controller.error(err);
+                    }
+                    catch (e) {
+                        logger.error(e);
+                    }
+                });
+            },
+        }), {
+            status: response.statusCode,
+            headers: responseHeaders,
+        });
+    }
+    return customFetch;
+}

package/build/engine/stream/index.d.ts

@@ -0,0 +1,4 @@
+export { createAIStreamEngine } from './engine';
+export { AIStreamEngine, LlmStreamAdapter, ResponseChunk, Transcript, StreamingEngineConfig, StreamWorkflowConfig as StreamingWorkflowConfig, } from '../interfaces/stream';
+export { getAzureClient, getOpenAiClient } from './get-client';
+//# sourceMappingURL=index.d.ts.map

package/build/engine/stream/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine/stream/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAE/C,OAAO,EACH,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,UAAU,EACV,qBAAqB,EACrB,oBAAoB,IAAI,uBAAuB,GAClD,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA"}

package/build/engine/stream/index.js

@@ -0,0 +1,2 @@
+export { createAIStreamEngine } from './engine';
+export { getAzureClient, getOpenAiClient } from './get-client';

package/build/engine/stream/token-transformers.d.ts

@@ -0,0 +1,6 @@
+export declare class MessageStartFilter extends TransformStream<string, string> {
+    constructor(toRemove: string);
+}
+export declare function agentFilter(): MessageStartFilter;
+export declare function composeTokenTransformers(transformers: TransformStream<string, string>[]): TransformStream<string, string>;
+//# sourceMappingURL=token-transformers.d.ts.map

package/build/engine/stream/token-transformers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-transformers.d.ts","sourceRoot":"","sources":["../../../src/engine/stream/token-transformers.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAmB,SAAQ,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC;gBACvD,QAAQ,EAAE,MAAM;CA2C/B;AAED,wBAAgB,WAAW,uBAE1B;AAED,wBAAgB,wBAAwB,CACpC,YAAY,EAAE,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAChD,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,CAYjC"}

package/build/engine/stream/token-transformers.js

@@ -0,0 +1,50 @@
+export class MessageStartFilter extends TransformStream {
+    constructor(toRemove) {
+        const prefix = toRemove.toLowerCase();
+        let buffer = '';
+        let done = false;
+        const releaseChunks = (controller) => {
+            done = true;
+            const out = buffer.toLowerCase().startsWith(prefix)
+                ? buffer.slice(toRemove.length)
+                : buffer;
+            if (out) {
+                controller.enqueue(out);
+            }
+        };
+        super({
+            transform(chunk, controller) {
+                if (done) {
+                    controller.enqueue(chunk);
+                    return;
+                }
+                buffer += chunk;
+                if (buffer.length >= prefix.length) {
+                    releaseChunks(controller);
+                }
+                else if (!prefix.startsWith(buffer.toLowerCase())) {
+                    releaseChunks(controller);
+                }
+            },
+            flush(controller) {
+                if (!done && buffer) {
+                    releaseChunks(controller);
+                }
+            },
+        });
+    }
+}
+export function agentFilter() {
+    return new MessageStartFilter('agent:');
+}
+export function composeTokenTransformers(transformers) {
+    if (transformers.length === 0) {
+        return new TransformStream();
+    }
+    const writable = transformers[0].writable;
+    let readable = transformers[0].readable;
+    for (let i = 1; i < transformers.length; i++) {
+        readable = readable.pipeThrough(transformers[i]);
+    }
+    return { writable, readable };
+}

package/build/index.d.ts

@@ -1,8 +1,3 @@
-export * from './interfaces/platform';
-export * from './interfaces/rc-voice';
-export * from './context-cache';
-export * from './analytics';
-export * from './postgres-analytics';
-export * from './postgres-analytics-query';
-export * from './timeouts-manager';
+export * from './core';
+export * from './telescope';
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,aAAa,CAAA;AAC3B,cAAc,sBAAsB,CAAA;AACpC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,QAAQ,CAAA;AACtB,cAAc,aAAa,CAAA"}

package/build/index.js

@@ -1,23 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./interfaces/platform"), exports);
-__exportStar(require("./interfaces/rc-voice"), exports);
-__exportStar(require("./context-cache"), exports);
-__exportStar(require("./analytics"), exports);
-__exportStar(require("./postgres-analytics"), exports);
-__exportStar(require("./postgres-analytics-query"), exports);
-__exportStar(require("./timeouts-manager"), exports);
+export * from './core';
+export * from './telescope';

package/build/notifications/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './router';
+export * from './transport';
+export * from './publisher';
+//# sourceMappingURL=index.d.ts.map

package/build/notifications/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/notifications/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA"}

package/build/notifications/index.js

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './router';
+export * from './transport';
+export * from './publisher';

package/build/notifications/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("../dockyard").Logger;
+//# sourceMappingURL=logger.d.ts.map

package/build/notifications/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/notifications/logger.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,8BAAiB,CAAA"}

package/build/notifications/logger.js

@@ -0,0 +1,2 @@
+import createLogger from '../dockyard';
+export const logger = createLogger();

package/build/notifications/publisher.d.ts

@@ -0,0 +1,10 @@
+import { NotificationEvent } from './types';
+export interface NotificationPublisher {
+    publish(event: NotificationEvent): Promise<number>;
+    close(): Promise<void>;
+}
+export declare function createRedisNotificationPublisher(options: {
+    url: string;
+    channel?: string;
+}): NotificationPublisher;
+//# sourceMappingURL=publisher.d.ts.map

package/build/notifications/publisher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher.d.ts","sourceRoot":"","sources":["../../src/notifications/publisher.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAE3C,MAAM,WAAW,qBAAqB;IAElC,OAAO,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAClD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB;AAMD,wBAAgB,gCAAgC,CAAC,OAAO,EAAE;IACtD,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,qBAAqB,CA+BxB"}

package/build/notifications/publisher.js

@@ -0,0 +1,31 @@
+import { createClient } from 'redis';
+import { logger } from './logger';
+import { DEFAULT_NOTIFICATION_CHANNEL } from './transport';
+export function createRedisNotificationPublisher(options) {
+    const channel = options.channel ?? DEFAULT_NOTIFICATION_CHANNEL;
+    let client;
+    async function getClient() {
+        if (client?.isReady)
+            return client;
+        if (!client) {
+            client = createClient({ url: options.url });
+            client.on('error', (err) => logger.error('notification-publisher: redis error', { err }));
+        }
+        if (!client.isOpen) {
+            await client.connect();
+        }
+        return client;
+    }
+    return {
+        async publish(event) {
+            const connected = await getClient();
+            return connected.publish(channel, JSON.stringify(event));
+        },
+        async close() {
+            if (client?.isOpen) {
+                await client.close();
+            }
+            client = undefined;
+        },
+    };
+}

package/build/notifications/router.d.ts

@@ -0,0 +1,18 @@
+import type { VoiceAgent } from '../agent';
+import type { ITelescope } from '../telescope';
+import { ConversationIds, NotificationEvent, NotificationTransport } from './types';
+export type NotificationRouterOptions = {
+    transport: NotificationTransport;
+    telescope: ITelescope;
+    registrationTtlMs?: number;
+    sweepIntervalMs?: number;
+};
+export interface NotificationRouter {
+    register<TMeta>(ids: ConversationIds, agent: VoiceAgent<TMeta>): void;
+    unregister(conversationId: string): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export declare function createNotificationRouter({ transport, telescope, registrationTtlMs, sweepIntervalMs, }: NotificationRouterOptions): NotificationRouter;
+export declare function parseNotificationEvent(raw: string): NotificationEvent | null;
+//# sourceMappingURL=router.d.ts.map

package/build/notifications/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/notifications/router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAE9C,OAAO,EACH,eAAe,EAEf,iBAAiB,EACjB,qBAAqB,EACxB,MAAM,SAAS,CAAA;AAEhB,MAAM,MAAM,yBAAyB,GAAG;IACpC,SAAS,EAAE,qBAAqB,CAAA;IAChC,SAAS,EAAE,UAAU,CAAA;IAKrB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED,MAAM,WAAW,kBAAkB;IAO/B,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,CAAC,GAAG,IAAI,CAAA;IACrE,UAAU,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IACxC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACxB;AAWD,wBAAgB,wBAAwB,CAAC,EACrC,SAAS,EACT,SAAS,EACT,iBAA+C,EAC/C,eAA2C,GAC9C,EAAE,yBAAyB,GAAG,kBAAkB,CAiHhD;AAMD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CA0C5E"}

package/build/notifications/router.js

@@ -0,0 +1,132 @@
+import { logger } from './logger';
+import { NOTIFICATION_EVENT_SCHEMA, } from './types';
+const DEFAULT_REGISTRATION_TTL_MS = 4 * 60 * 60 * 1000;
+const DEFAULT_SWEEP_INTERVAL_MS = 5 * 60 * 1000;
+export function createNotificationRouter({ transport, telescope, registrationTtlMs = DEFAULT_REGISTRATION_TTL_MS, sweepIntervalMs = DEFAULT_SWEEP_INTERVAL_MS, }) {
+    const byConversationId = new Map();
+    const byExternalId = new Map();
+    let sweepTimer;
+    function register(ids, agent) {
+        const handleNotification = agent.handleNotification;
+        if (!handleNotification)
+            return;
+        const { conversationId, externalConversationId } = ids;
+        unregister(conversationId);
+        const registration = {
+            ...ids,
+            agentName: agent.name,
+            handle: (payload) => handleNotification.call(agent, conversationId, payload),
+            registeredAt: Date.now(),
+        };
+        byConversationId.set(conversationId, registration);
+        if (externalConversationId) {
+            byExternalId.set(externalConversationId, registration);
+        }
+        logger.debug('notification-router: registered', { conversationId, externalConversationId });
+    }
+    function unregister(conversationId) {
+        const registration = byConversationId.get(conversationId);
+        if (!registration)
+            return;
+        byConversationId.delete(conversationId);
+        if (registration.externalConversationId) {
+            byExternalId.delete(registration.externalConversationId);
+        }
+        logger.debug('notification-router: unregistered', { conversationId });
+    }
+    function dispatch(event) {
+        const registration = event.conversationId !== undefined
+            ? byConversationId.get(event.conversationId)
+            : byExternalId.get(event.externalConversationId);
+        if (!registration) {
+            logger.debug('notification-router: no local registration', {
+                conversationId: event.conversationId,
+                externalConversationId: event.externalConversationId,
+            });
+            return;
+        }
+        void deliver(registration, event.payload);
+    }
+    async function deliver(registration, payload) {
+        const { conversationId, agentName } = registration;
+        try {
+            await telescope.runObservation(() => registration.handle(payload), {
+                conversationId,
+                agentId: agentName,
+            });
+        }
+        catch (err) {
+            logger.error('notification-router: handler failed', { err, conversationId });
+        }
+    }
+    function sweepExpired() {
+        const expiredBefore = Date.now() - registrationTtlMs;
+        for (const [conversationId, registration] of byConversationId) {
+            if (registration.registeredAt > expiredBefore)
+                continue;
+            logger.warn('notification-router: registration expired without an explicit end', {
+                conversationId,
+                externalConversationId: registration.externalConversationId,
+            });
+            unregister(conversationId);
+        }
+    }
+    return {
+        register,
+        unregister,
+        async start() {
+            await transport.subscribe((raw) => {
+                const event = parseNotificationEvent(raw);
+                if (event)
+                    dispatch(event);
+            });
+            sweepTimer = setInterval(sweepExpired, sweepIntervalMs);
+            sweepTimer.unref();
+        },
+        async stop() {
+            if (sweepTimer) {
+                clearInterval(sweepTimer);
+                sweepTimer = undefined;
+            }
+            byConversationId.clear();
+            byExternalId.clear();
+            await transport.close();
+        },
+    };
+}
+export function parseNotificationEvent(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        logger.warn('notification-router: message is not valid JSON', { err });
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        logger.warn('notification-router: message is not an object');
+        return null;
+    }
+    const { schema, payload, conversationId, externalConversationId } = parsed;
+    if (schema !== NOTIFICATION_EVENT_SCHEMA) {
+        logger.warn('notification-router: unsupported schema', { schema });
+        return null;
+    }
+    const id = asNonEmptyString(conversationId);
+    const externalId = asNonEmptyString(externalConversationId);
+    if (id !== undefined && externalId !== undefined) {
+        logger.warn('notification-router: conversationId and externalConversationId are mutually exclusive');
+        return null;
+    }
+    if (id !== undefined) {
+        return { schema: NOTIFICATION_EVENT_SCHEMA, payload, conversationId: id };
+    }
+    if (externalId !== undefined) {
+        return { schema: NOTIFICATION_EVENT_SCHEMA, payload, externalConversationId: externalId };
+    }
+    logger.warn('notification-router: conversationId or externalConversationId required');
+    return null;
+}
+function asNonEmptyString(value) {
+    return typeof value === 'string' && value !== '' ? value : undefined;
+}