@hotmeshio/long-tail 0.4.14 → 0.4.16

package/build/adapters/express.js

@@ -43,6 +43,8 @@ const express_1 = __importStar(require("express"));
 const routes_1 = __importDefault(require("../routes"));
 const events_1 = require("../lib/events");
 const socketio_1 = require("../lib/events/socketio");
+const nats_1 = require("../lib/events/nats");
+const nats_ws_proxy_1 = require("../lib/events/nats-ws-proxy");
 /**
  * Express adapter for mounting the Long Tail dashboard at an arbitrary subpath
  * inside an existing Express-based application (NestJS, Fastify-Express, etc.).
@@ -112,6 +114,18 @@ class LTExpressAdapter {
             socketAdapter.attachServer(server);
             await socketAdapter.connect();
         }
+        // Attach NATS WebSocket proxy (if configured)
+        const natsAdapter = events_1.eventRegistry.getAdapter(nats_1.NatsEventAdapter);
+        if (natsAdapter?.wsProxyTarget) {
+            (0, nats_ws_proxy_1.attachNatsWsProxy)(server, natsAdapter.wsProxyTarget, {
+                basePath: this.basePath,
+                onWsUrlDerived: (url) => {
+                    if (!natsAdapter.wsUrl) {
+                        natsAdapter.setWsUrl(url);
+                    }
+                },
+            });
+        }
     }
     /**
      * Return a self-contained Express Router that serves:

package/build/api/escalations/claim.js

@@ -71,16 +71,7 @@ async function claimEscalation(input, auth) {
         if (!result) {
             return { status: 409, error: 'Escalation not available for claim' };
         }
-        (0, publish_1.publishEscalationEvent)({
-            type: 'escalation.claimed',
-            source: 'api',
-            workflowId: escalation.workflow_id || '',
-            workflowName: escalation.workflow_type || '',
-            taskQueue: escalation.task_queue || '',
-            escalationId: id,
-            status: 'claimed',
-            data: { assigned_to: auth.userId },
-        });
+        // Event published by service layer (services/escalation/crud.ts)
         return { status: 200, data: result };
     }
     catch (err) {

package/build/api/escalations/create.js

@@ -36,7 +36,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEscalation = createEscalation;
 const escalationService = __importStar(require("../../services/escalation"));
 const userService = __importStar(require("../../services/user"));
-const publish_1 = require("../../lib/events/publish");
 // ── Create ────────────────────────────────────────────────────────────────
 /**
  * Create a standalone escalation (not tied to a workflow).
@@ -83,16 +82,7 @@ async function createEscalation(input, auth) {
             metadata: input.metadata,
             escalation_payload: input.escalation_payload,
         });
-        (0, publish_1.publishEscalationEvent)({
-            type: 'escalation.created',
-            source: 'api',
-            workflowId: '',
-            workflowName: '',
-            taskQueue: '',
-            escalationId: escalation.id,
-            status: 'pending',
-            data: { type: input.type, role },
-        });
+        // Event published by service layer (services/escalation/crud.ts)
         return { status: 201, data: escalation };
     }
     catch (err) {

package/build/api/escalations/metadata.d.ts

@@ -35,6 +35,7 @@ export declare function claimByMetadata(input: {
     value: string;
     durationMinutes?: number;
     assignee?: string;
+    metadata?: Record<string, any>;
 }, auth: LTApiAuth): Promise<LTApiResult>;
 /**
  * Resolve an escalation by metadata key-value pair.
@@ -53,4 +54,5 @@ export declare function resolveByMetadata(input: {
     value: string;
     resolverPayload: Record<string, any>;
     assignee?: string;
+    metadata?: Record<string, any>;
 }, auth: LTApiAuth): Promise<LTApiResult>;

package/build/api/escalations/metadata.js

@@ -38,7 +38,6 @@ exports.claimByMetadata = claimByMetadata;
 exports.resolveByMetadata = resolveByMetadata;
 const escalationService = __importStar(require("../../services/escalation"));
 const userService = __importStar(require("../../services/user"));
-const publish_1 = require("../../lib/events/publish");
 const helpers_1 = require("./helpers");
 /**
  * Find escalations by a metadata key-value pair.
@@ -105,20 +104,11 @@ async function claimByMetadata(input, auth) {
                 return { status: 403, error: `User must have the "${candidate.role}" role to claim this escalation` };
             }
         }
-        const result = await escalationService.claimByMetadata(input.key, input.value, claimUserId, input.durationMinutes);
+        const result = await escalationService.claimByMetadata(input.key, input.value, claimUserId, input.durationMinutes, input.metadata);
         if (!result) {
             return { status: 409, error: 'Escalation not available for claim' };
         }
-        (0, publish_1.publishEscalationEvent)({
-            type: 'escalation.claimed',
-            source: 'api',
-            workflowId: result.escalation.workflow_id || '',
-            workflowName: result.escalation.workflow_type || '',
-            taskQueue: result.escalation.task_queue || '',
-            escalationId: result.escalation.id,
-            status: 'claimed',
-            data: { assigned_to: claimUserId },
-        });
+        // Event published by service layer (services/escalation/crud.ts)
         return { status: 200, data: result };
     }
     catch (err) {
@@ -161,6 +151,10 @@ async function resolveByMetadata(input, auth) {
                 return { status: 403, error: `User must have the "${escalation.role}" role` };
             }
         }
+        // Merge additional metadata if provided
+        if (input.metadata && Object.keys(input.metadata).length > 0) {
+            await escalationService.updateEscalationMetadata(escalation.id, input.metadata);
+        }
         // Auto-claim if unclaimed or expired
         const isClaimed = escalation.assigned_to &&
             escalation.assigned_until &&

package/build/api/escalations/resolve.js

@@ -36,7 +36,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveEscalation = resolveEscalation;
 const escalationService = __importStar(require("../../services/escalation"));
 const taskService = __importStar(require("../../services/task"));
-const publish_1 = require("../../lib/events/publish");
 const escalation_strategy_1 = require("../../services/escalation-strategy");
 const ephemeral_1 = require("../../services/iam/ephemeral");
 const deployer_1 = require("../../services/yaml-workflow/deployer");
@@ -105,7 +104,7 @@ async function resolveViaConditionSignal(escalation, resolverPayload) {
     const client = (0, workers_1.createClient)();
     const handle = await client.workflow.getHandle(escalation.task_queue, escalation.workflow_type, escalation.workflow_id);
     await handle.signal(signalId, { ...resolverPayload, $escalation_id: escalation.id });
-    publishResolvedEvent(escalation);
+    // Event published by service layer (services/escalation/crud.ts)
     return signaledResult(escalation, escalation.workflow_id);
 }
 /** Path B: waitFor signal escalation — signal via YAML engine or Durable handle. */
@@ -129,12 +128,7 @@ async function resolveViaSignalRouting(escalation, resolverPayload) {
     if (signalRouting.engine !== 'yaml') {
         await escalationService.resolveEscalation(escalation.id, resolverPayload);
     }
-    publishResolvedEvent(escalation, {
-        workflowId: escalation.workflow_id || signalRouting.workflowId,
-        workflowName: escalation.workflow_type || signalRouting.workflowType,
-        taskQueue: escalation.task_queue || signalRouting.taskQueue || signalRouting.appId,
-        status: signalRouting.engine === 'yaml' ? 'signaled' : 'resolved',
-    });
+    // Event published by service layer (services/escalation/crud.ts)
     return signaledResult(escalation, signalRouting.workflowId || signalRouting.appId);
 }
 /** Path C: escalation strategy directed triage — start a triage workflow. */
@@ -165,7 +159,7 @@ async function resolveViaTriage(escalation, resolverPayload, triageEnvelope) {
         ...resolverPayload,
         _lt: { ...resolverPayload._lt, triaged: true, triageWorkflowId },
     });
-    publishResolvedEvent(escalation);
+    // Event published by service layer (services/escalation/crud.ts)
     return {
         status: 200,
         data: { started: true, escalationId: escalation.id, workflowId: triageWorkflowId, triage: true },
@@ -184,26 +178,13 @@ async function resolveViaRerun(escalation, envelope, resolverPayload) {
         workflowId: newWorkflowId,
         expire: 180,
     });
-    publishResolvedEvent(escalation);
+    // Event published by service layer (services/escalation/crud.ts)
     return {
         status: 200,
         data: { started: true, escalationId: escalation.id, workflowId: newWorkflowId },
     };
 }
 // ── Shared helpers ───────────────────────────────────────────────────────
-function publishResolvedEvent(escalation, overrides) {
-    (0, publish_1.publishEscalationEvent)({
-        type: 'escalation.resolved',
-        source: 'api',
-        workflowId: overrides?.workflowId || escalation.workflow_id || '',
-        workflowName: overrides?.workflowName || escalation.workflow_type || '',
-        taskQueue: overrides?.taskQueue || escalation.task_queue || '',
-        taskId: escalation.task_id,
-        escalationId: escalation.id,
-        originId: escalation.origin_id ?? undefined,
-        status: overrides?.status || 'resolved',
-    });
-}
 function signaledResult(escalation, workflowId) {
     return {
         status: 200,

package/build/api/settings.js

@@ -5,6 +5,7 @@ const telemetry_1 = require("../lib/telemetry");
 const events_1 = require("../lib/events");
 const nats_1 = require("../lib/events/nats");
 const socketio_1 = require("../lib/events/socketio");
+const config_1 = require("../modules/config");
 const defaults_1 = require("../modules/defaults");
 const llm_1 = require("../services/llm");
 /**
@@ -18,13 +19,13 @@ const llm_1 = require("../services/llm");
 async function getSettings() {
     try {
         const hasSocketIO = !!events_1.eventRegistry.getAdapter(socketio_1.SocketIOEventAdapter);
-        const hasNats = !!events_1.eventRegistry.getAdapter(nats_1.NatsEventAdapter);
+        const natsAdapter = events_1.eventRegistry.getAdapter(nats_1.NatsEventAdapter);
         // Dashboard transport: Socket.IO is the default (works in-process, zero config).
         // NATS is only reported when explicitly opted in via EVENT_TRANSPORT=nats,
         // which a multi-container deployment sets when it wants the dashboard to
         // connect via NATS instead of Socket.IO.
-        const forceNats = process.env.EVENT_TRANSPORT === 'nats';
-        const transport = forceNats && hasNats ? 'nats' : hasSocketIO ? 'socketio' : hasNats ? 'nats' : 'none';
+        const forceNats = config_1.config.EVENT_TRANSPORT === 'nats';
+        const transport = forceNats && natsAdapter ? 'nats' : hasSocketIO ? 'socketio' : natsAdapter ? 'nats' : 'none';
         return {
             status: 200,
             data: {
@@ -36,9 +37,7 @@ async function getSettings() {
                 },
                 events: {
                     transport,
-                    natsWsUrl: hasNats
-                        ? (process.env.VITE_NATS_WS_URL || process.env.NATS_WS_URL || null)
-                        : null,
+                    natsWsUrl: natsAdapter?.wsUrl ?? null,
                 },
                 ai: {
                     enabled: (0, llm_1.hasLLMApiKey)(),

package/build/bin/ltc.js

@@ -145,11 +145,13 @@ escCmd.command('claim-by-meta <key> <value>')
     .description('Claim an escalation by metadata key-value pair')
     .option('--duration <minutes>', 'Claim duration in minutes')
     .option('--assignee <external_id>', 'Claim on behalf of user (external_id)')
+    .option('--meta <json>', 'Merge metadata (JSON object, e.g. \'{"claimedBy":"jimbo"}\')')
     .action(wrap(esc.claimByMetadata));
 escCmd.command('resolve-by-meta <key> <value>')
     .description('Resolve an escalation by metadata key-value pair')
     .option('--data <json>', 'Resolver payload (JSON string)')
     .option('--assignee <external_id>', 'Resolve on behalf of user (external_id)')
+    .option('--meta <json>', 'Merge metadata (JSON object)')
     .action(wrap(esc.resolveByMetadata));
 // ── Workflows ────────────────────────────────────────────────────────────
 const wfCmd = commander_1.program.command('workflows').alias('wf').description('Manage durable workflows');

package/build/index.js

@@ -171,8 +171,8 @@ async function main() {
             strategy: 'mcp',
         },
         telemetry: honeycombKey ? { honeycomb: { apiKey: honeycombKey } } : undefined,
-        events: process.env.NATS_URL
-            ? { nats: { url: config_1.config.NATS_URL, token: process.env.NATS_TOKEN || 'dev_api_secret' } }
+        events: config_1.config.EVENT_TRANSPORT === 'nats'
+            ? { nats: { url: config_1.config.NATS_URL, wsUrl: config_1.config.NATS_WS_URL || undefined, token: config_1.config.NATS_TOKEN || undefined } }
             : undefined,
     });
 }

package/build/lib/cli/commands/escalations.d.ts

@@ -20,9 +20,11 @@ export declare function findByMetadata(key: string, value: string, opts: ListOpt
 export declare function claimByMetadata(key: string, value: string, opts: {
     duration?: string;
     assignee?: string;
+    meta?: string;
 }): Promise<void>;
 export declare function resolveByMetadata(key: string, value: string, opts: {
     data?: string;
     assignee?: string;
+    meta?: string;
 }): Promise<void>;
 export {};

package/build/lib/cli/commands/escalations.js

@@ -86,6 +86,8 @@ async function claimByMetadata(key, value, opts) {
         body.durationMinutes = parseInt(opts.duration, 10);
     if (opts.assignee)
         body.assignee = opts.assignee;
+    if (opts.meta)
+        body.metadata = JSON.parse(opts.meta);
     const data = await (0, client_1.apiFetch)('/escalations/claim-by-metadata', {
         method: 'POST',
         body: JSON.stringify(body),
@@ -97,6 +99,8 @@ async function resolveByMetadata(key, value, opts) {
     const body = { key, value, resolverPayload };
     if (opts.assignee)
         body.assignee = opts.assignee;
+    if (opts.meta)
+        body.metadata = JSON.parse(opts.meta);
     await (0, client_1.apiFetch)('/escalations/resolve-by-metadata', {
         method: 'POST',
         body: JSON.stringify(body),

package/build/lib/events/nats-ws-proxy.d.ts

@@ -0,0 +1,19 @@
+import type { Server as HttpServer } from 'http';
+/** Default path for the NATS WebSocket proxy endpoint. */
+export declare const NATS_WS_PROXY_PATH = "/nats-ws";
+/**
+ * Attach a WebSocket proxy to an HTTP server that bridges browser
+ * connections to an internal NATS WebSocket endpoint.
+ *
+ * The browser connects to `wss://domain.com{basePath}/nats-ws` (port 443,
+ * through an ALB or reverse proxy). This handler upgrades the connection
+ * and bridges bidirectionally to the internal NATS WS target.
+ *
+ * The proxy auto-derives the public `wsUrl` from the first incoming
+ * request's headers, respecting `X-Forwarded-Proto` and `X-Forwarded-Host`
+ * so the correct `wss://` scheme is used behind TLS-terminating load balancers.
+ */
+export declare function attachNatsWsProxy(server: HttpServer, target: string, options?: {
+    basePath?: string;
+    onWsUrlDerived?: (url: string) => void;
+}): void;

package/build/lib/events/nats-ws-proxy.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NATS_WS_PROXY_PATH = void 0;
+exports.attachNatsWsProxy = attachNatsWsProxy;
+const ws_1 = require("ws");
+const logger_1 = require("../logger");
+/** Default path for the NATS WebSocket proxy endpoint. */
+exports.NATS_WS_PROXY_PATH = '/nats-ws';
+/**
+ * Attach a WebSocket proxy to an HTTP server that bridges browser
+ * connections to an internal NATS WebSocket endpoint.
+ *
+ * The browser connects to `wss://domain.com{basePath}/nats-ws` (port 443,
+ * through an ALB or reverse proxy). This handler upgrades the connection
+ * and bridges bidirectionally to the internal NATS WS target.
+ *
+ * The proxy auto-derives the public `wsUrl` from the first incoming
+ * request's headers, respecting `X-Forwarded-Proto` and `X-Forwarded-Host`
+ * so the correct `wss://` scheme is used behind TLS-terminating load balancers.
+ */
+function attachNatsWsProxy(server, target, options = {}) {
+    const basePath = options.basePath || '';
+    const proxyPath = `${basePath}${exports.NATS_WS_PROXY_PATH}`;
+    const wss = new ws_1.WebSocketServer({ noServer: true });
+    let derived = false;
+    server.on('upgrade', (req, socket, head) => {
+        if (req.url !== proxyPath)
+            return;
+        // Derive the public wsUrl from the first request's headers
+        if (!derived && options.onWsUrlDerived) {
+            const proto = req.headers['x-forwarded-proto'] || 'ws';
+            const scheme = proto === 'https' ? 'wss' : 'ws';
+            const host = req.headers['x-forwarded-host'] || req.headers.host || 'localhost';
+            options.onWsUrlDerived(`${scheme}://${host}${proxyPath}`);
+            derived = true;
+        }
+        wss.handleUpgrade(req, socket, head, (clientWs) => {
+            const upstream = new ws_1.WebSocket(target);
+            upstream.on('open', () => {
+                clientWs.on('message', (data) => {
+                    if (upstream.readyState === ws_1.WebSocket.OPEN)
+                        upstream.send(data);
+                });
+                upstream.on('message', (data) => {
+                    if (clientWs.readyState === ws_1.WebSocket.OPEN)
+                        clientWs.send(data);
+                });
+            });
+            const close = () => {
+                if (clientWs.readyState === ws_1.WebSocket.OPEN)
+                    clientWs.close();
+                if (upstream.readyState === ws_1.WebSocket.OPEN)
+                    upstream.close();
+            };
+            clientWs.on('close', close);
+            upstream.on('close', close);
+            upstream.on('error', (err) => {
+                logger_1.loggerRegistry.error(`[lt-nats-ws-proxy] upstream error: ${err.message}`);
+                close();
+            });
+            clientWs.on('error', (err) => {
+                logger_1.loggerRegistry.error(`[lt-nats-ws-proxy] client error: ${err.message}`);
+                close();
+            });
+        });
+    });
+    logger_1.loggerRegistry.info(`[lt-nats-ws-proxy] active: ${proxyPath} -> ${target}`);
+}

package/build/lib/events/nats.d.ts

@@ -23,15 +23,31 @@ export declare class NatsEventAdapter implements LTEventAdapter {
     private nc;
     private sub;
     private url;
+    private _wsUrl;
+    private _wsProxyTarget;
     private subjectPrefix;
     private token?;
     private originId;
     private callbackAdapter;
     constructor(options?: {
         url?: string;
+        wsUrl?: string;
+        wsProxy?: string;
         subjectPrefix?: string;
         token?: string;
     });
+    /**
+     * Public NATS WebSocket URL for browser connections.
+     * When a wsProxy is configured, this can be set dynamically
+     * via `setWsUrl()` once the server's public address is known.
+     */
+    get wsUrl(): string | null;
+    /** Set the browser-facing WebSocket URL (called by proxy setup). */
+    setWsUrl(url: string): void;
+    /** Internal NATS WS target for the proxy to bridge to (e.g. ws://nats:9222). */
+    get wsProxyTarget(): string | null;
+    /** NATS auth token for browser connections. */
+    get authToken(): string | null;
     /**
      * Bridge NATS → local callback adapter for cross-container dispatch.
      * Part of the LTEventAdapter contract. Call before `connect()`.

package/build/lib/events/nats.js

@@ -33,8 +33,30 @@ class NatsEventAdapter {
         this.originId = (0, crypto_1.randomUUID)();
         this.callbackAdapter = null;
         this.url = options?.url || config_1.config.NATS_URL;
+        this._wsUrl = options?.wsUrl || config_1.config.NATS_WS_URL || null;
+        this._wsProxyTarget = options?.wsProxy || null;
         this.subjectPrefix = options?.subjectPrefix || 'lt.events';
-        this.token = options?.token || process.env.NATS_TOKEN || 'dev_api_secret';
+        this.token = options?.token || config_1.config.NATS_TOKEN || undefined;
+    }
+    /**
+     * Public NATS WebSocket URL for browser connections.
+     * When a wsProxy is configured, this can be set dynamically
+     * via `setWsUrl()` once the server's public address is known.
+     */
+    get wsUrl() {
+        return this._wsUrl;
+    }
+    /** Set the browser-facing WebSocket URL (called by proxy setup). */
+    setWsUrl(url) {
+        this._wsUrl = url;
+    }
+    /** Internal NATS WS target for the proxy to bridge to (e.g. ws://nats:9222). */
+    get wsProxyTarget() {
+        return this._wsProxyTarget;
+    }
+    /** NATS auth token for browser connections. */
+    get authToken() {
+        return this.token || null;
     }
     /**
      * Bridge NATS → local callback adapter for cross-container dispatch.

package/build/lib/events/publish.js

@@ -9,12 +9,14 @@ exports.publishFileEvent = publishFileEvent;
 exports.publishAgentEvent = publishAgentEvent;
 exports.publishWorkflowEvent = publishWorkflowEvent;
 const index_1 = require("./index");
+const logger_1 = require("../logger");
 /**
  * Fire-and-forget publish helper. Swallows errors (best-effort).
  */
 function fireAndForget(event) {
     if (!index_1.eventRegistry.hasAdapters)
         return Promise.resolve();
+    logger_1.loggerRegistry.info(`[lt-pub] ${event.type} ${event.workflowId || ''} ${event.escalationId || event.taskId || ''}`);
     return index_1.eventRegistry.publish(event).catch(() => { });
 }
 /**

package/build/modules/config.d.ts

@@ -4,7 +4,10 @@ export declare const config: {
     POSTGRES_USER: string;
     POSTGRES_PASSWORD: string;
     POSTGRES_DB: string;
+    EVENT_TRANSPORT: string;
     NATS_URL: string;
+    NATS_WS_URL: string;
+    NATS_TOKEN: string;
     PORT: number;
     NODE_ENV: string;
     JWT_SECRET: string;

package/build/modules/config.js

@@ -11,7 +11,10 @@ exports.config = {
     POSTGRES_DB: process.env.NODE_ENV === 'test'
         ? 'longtail_test'
         : (process.env.POSTGRES_DB || 'longtail'),
+    EVENT_TRANSPORT: process.env.EVENT_TRANSPORT || '',
     NATS_URL: process.env.NATS_URL || 'nats://localhost:4222',
+    NATS_WS_URL: process.env.NATS_WS_URL || '',
+    NATS_TOKEN: process.env.NATS_TOKEN || '',
     PORT: parseInt(process.env.PORT || '3000', 10),
     NODE_ENV: process.env.NODE_ENV || 'development',
     JWT_SECRET: process.env.JWT_SECRET || '',

package/build/routes/escalations/metadata.js

@@ -58,7 +58,7 @@ function registerMetadataRoutes(router) {
     /**
      * POST /api/escalations/claim-by-metadata
      * Find and claim an escalation by metadata key-value pair.
-     * Body: { key, value, durationMinutes?, assignee? }
+     * Body: { key, value, durationMinutes?, assignee?, metadata? }
      */
     router.post('/claim-by-metadata', async (req, res) => {
         const result = await api.claimByMetadata({
@@ -66,13 +66,14 @@ function registerMetadataRoutes(router) {
             value: req.body?.value,
             durationMinutes: req.body?.durationMinutes,
             assignee: req.body?.assignee,
+            metadata: req.body?.metadata,
         }, req.auth);
         res.status(result.status).json(result.data ?? { error: result.error });
     });
     /**
      * POST /api/escalations/resolve-by-metadata
      * Find and resolve an escalation by metadata key-value pair.
-     * Body: { key, value, resolverPayload, assignee? }
+     * Body: { key, value, resolverPayload, assignee?, metadata? }
      */
     router.post('/resolve-by-metadata', async (req, res) => {
         const result = await api.resolveByMetadata({
@@ -80,6 +81,7 @@ function registerMetadataRoutes(router) {
             value: req.body?.value,
             resolverPayload: req.body?.resolverPayload,
             assignee: req.body?.assignee,
+            metadata: req.body?.metadata,
         }, req.auth);
         res.status(result.status).json(result.data ?? { error: result.error });
     });

package/build/routes/nats-credentials.js

@@ -10,13 +10,13 @@ const router = (0, express_1.Router)();
  * Mounted behind requireAuth — only authenticated users receive the token.
  */
 router.get('/', async (_req, res) => {
-    const hasNats = !!events_1.eventRegistry.getAdapter(nats_1.NatsEventAdapter);
-    if (!hasNats) {
+    const natsAdapter = events_1.eventRegistry.getAdapter(nats_1.NatsEventAdapter);
+    if (!natsAdapter) {
         return res.json({ natsWsUrl: null, natsToken: null });
     }
     res.json({
-        natsWsUrl: process.env.VITE_NATS_WS_URL || process.env.NATS_WS_URL || null,
-        natsToken: process.env.NATS_TOKEN || null,
+        natsWsUrl: natsAdapter.wsUrl,
+        natsToken: natsAdapter.authToken,
     });
 });
 exports.default = router;

package/build/sdk/index.d.ts

@@ -162,12 +162,14 @@ export declare function createClient(options?: LTClientOptions): {
             value: string;
             durationMinutes?: number;
             assignee?: string;
+            metadata?: Record<string, any>;
         }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
         resolveByMetadata: (input: {
             key: string;
             value: string;
             resolverPayload: Record<string, any>;
             assignee?: string;
+            metadata?: Record<string, any>;
         }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
     };
     workflows: {

package/build/services/escalation/crud.d.ts

@@ -49,4 +49,4 @@ export declare function findByMetadata(key: string, value: string, status?: stri
     escalations: LTEscalationRecord[];
     total: number;
 }>;
-export declare function claimByMetadata(key: string, value: string, userId: string, durationMinutes?: number): Promise<ClaimResult | null>;
+export declare function claimByMetadata(key: string, value: string, userId: string, durationMinutes?: number, metadata?: Record<string, any>): Promise<ClaimResult | null>;