@memberjunction/server 5.43.0 → 5.45.0

package/src/telephony/teamsAcsMediaRegistry.ts

@@ -0,0 +1,152 @@
+/**
+ * @fileoverview Per-call ACS application-hosted-media pump registry for the Teams meetings ingress.
+ *
+ * This is the server half of the Teams audio plane — the analogue of {@link TwilioCallMediaRegistry} for
+ * telephony. It implements the Teams provider package's `IAcsMediaPump` seam (which `PumpBackedAcsMedia` →
+ * `RealTeamsBindings` drive) on top of the live ACS application-hosted-media audio socket(s) the server owns.
+ *
+ * Like telephony, there is a lifecycle gap: when a meeting bridge session starts, `RealTeamsBindings`
+ * registers its inbound-audio handler before the ACS media socket has connected its inbound stream. The
+ * registry bridges that gap by buffering handler registrations + outbound PCM per call id and binding them to
+ * the media transport once it attaches (the server's native ACS media adapter calls {@link AttachTransport}
+ * when the application-hosted-media socket is up for the call).
+ *
+ * Pure + unit-testable: the media transport is injected as the minimal {@link IAcsMediaTransport} surface, so
+ * the registry's buffering / dispatch logic is exercised with a fake transport and no ACS install or network.
+ *
+ * @module @memberjunction/server/telephony
+ */
+
+import type { AcsInboundAudioFrame, IAcsMediaPump } from '@memberjunction/ai-bridge-teams';
+
+/**
+ * The minimal ACS media-transport surface the registry drives — a structural subset of the server's native
+ * application-hosted-media socket adapter, so the registry never imports the ACS SDK and is testable with a
+ * fake. Outbound frames are raw PCM16 `ArrayBuffer`s for the call.
+ */
+export interface IAcsMediaTransport {
+    /** Sends one outbound PCM16 frame on the call's application-hosted-media outbound audio socket. */
+    sendAudioFrame(pcm: ArrayBuffer): void;
+    /** Closes the call's media transport (best-effort; called on call end). */
+    close(): void;
+}
+
+/** One call's audio channel: its transport (once attached), inbound handlers, hand-raise handlers, pending sends. */
+interface CallAudioChannel {
+    transport?: IAcsMediaTransport;
+    /** Inbound per-participant audio handlers registered by RealTeamsBindings (may predate the transport). */
+    frameHandlers: Array<(frame: AcsInboundAudioFrame) => void>;
+    /** Raised-hand handlers (Teams hand-raise is partial; may never fire). */
+    handRaiseHandlers: Array<(participantId: string, raised: boolean) => void>;
+    /** Outbound PCM produced before the transport attached — flushed on AttachTransport. */
+    outboundBuffer: ArrayBuffer[];
+}
+
+/**
+ * Coordinates ACS application-hosted-media transports with the bridge bindings, keyed by Graph call id. One
+ * instance per server, shared between the meetings service (which binds `PumpBackedAcsMedia` over this as the
+ * `IAcsMediaPump`) and the server's native ACS media adapter (which attaches transports + dispatches inbound
+ * audio).
+ */
+export class TeamsAcsMediaRegistry implements IAcsMediaPump {
+    private readonly channels = new Map<string, CallAudioChannel>();
+
+    /**
+     * @param SampleRate The ACS audio-socket sample rate in Hz (the application-hosted-media PCM rate the
+     *   server negotiates). Drives T0 resampling in `RealTeamsBindings`. Defaults to 16000.
+     */
+    constructor(public readonly SampleRate = 16000) {}
+
+    /** Ensures a channel exists for a call (called when a meeting bridge session for the call starts). */
+    public RegisterCall(callId: string): void {
+        this.ensureChannel(callId);
+    }
+
+    // ── IAcsMediaPump ─────────────────────────────────────────────────────────────
+
+    /** @inheritdoc — buffers when the transport has not yet attached; sends immediately once it has. */
+    public Send(callId: string, pcm: ArrayBuffer): void {
+        const channel = this.ensureChannel(callId);
+        if (channel.transport) {
+            channel.transport.sendAudioFrame(pcm);
+        } else {
+            channel.outboundBuffer.push(pcm);
+        }
+    }
+
+    /** @inheritdoc — stores the handler so frames delivered before AND after transport attach reach it. */
+    public OnFrame(callId: string, handler: (frame: AcsInboundAudioFrame) => void): void {
+        this.ensureChannel(callId).frameHandlers.push(handler);
+    }
+
+    /** @inheritdoc — stores the hand-raise handler (Teams hand-raise is partial; tolerated if it never fires). */
+    public OnHandRaise(callId: string, handler: (participantId: string, raised: boolean) => void): void {
+        this.ensureChannel(callId).handRaiseHandlers.push(handler);
+    }
+
+    // ── native-adapter side ─────────────────────────────────────────────────────
+
+    /**
+     * Binds a connected ACS media transport to a call, flushing any outbound PCM produced while the transport
+     * was still connecting. Called by the server's native ACS media adapter once the application-hosted-media
+     * socket is up for the call.
+     */
+    public AttachTransport(callId: string, transport: IAcsMediaTransport): void {
+        const channel = this.ensureChannel(callId);
+        channel.transport = transport;
+        const buffered = channel.outboundBuffer.splice(0, channel.outboundBuffer.length);
+        for (const pcm of buffered) {
+            transport.sendAudioFrame(pcm);
+        }
+    }
+
+    /** Dispatches one inbound per-participant audio frame to all registered handlers for the call. */
+    public DispatchInbound(callId: string, frame: AcsInboundAudioFrame): void {
+        const channel = this.channels.get(callId);
+        if (!channel) {
+            return;
+        }
+        for (const handler of channel.frameHandlers) {
+            handler(frame);
+        }
+    }
+
+    /** Dispatches one raised-hand signal to all registered hand-raise handlers for the call. */
+    public DispatchHandRaise(callId: string, participantId: string, raised: boolean): void {
+        const channel = this.channels.get(callId);
+        if (!channel) {
+            return;
+        }
+        for (const handler of channel.handRaiseHandlers) {
+            handler(participantId, raised);
+        }
+    }
+
+    /** Tears down a call's channel and closes its transport (called on call end / meeting ended). */
+    public EndCall(callId: string): void {
+        const channel = this.channels.get(callId);
+        if (!channel) {
+            return;
+        }
+        try {
+            channel.transport?.close();
+        } catch {
+            /* best-effort */
+        }
+        this.channels.delete(callId);
+    }
+
+    /** Whether a channel is currently tracked for the call (test/observability helper). */
+    public HasCall(callId: string): boolean {
+        return this.channels.has(callId);
+    }
+
+    private ensureChannel(callId: string): CallAudioChannel {
+        let channel = this.channels.get(callId);
+        if (!channel) {
+            channel = { frameHandlers: [], handRaiseHandlers: [], outboundBuffer: [] };
+            this.channels.set(callId, channel);
+        }
+        return channel;
+    }
+}

package/src/telephony/telephony-runtime.ts

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview Process-wide holder for the startup-constructed telephony service, so the
+ * outbound `PlaceTwilioCall` GraphQL resolver reaches the SAME {@link TwilioTelephonyService}
+ * (and thus the same {@link TwilioCallMediaRegistry} the Media-Streams WSS attaches sockets to)
+ * that the inbound webhook router uses. Set once during server boot; read by the resolver.
+ *
+ * @module @memberjunction/server/telephony
+ */
+
+import type { TwilioTelephonyService } from './TwilioTelephonyService.js';
+
+let twilioService: TwilioTelephonyService | undefined;
+
+/** Binds the startup-constructed Twilio telephony service (called from server boot). */
+export function SetTwilioTelephonyService(service: TwilioTelephonyService): void {
+    twilioService = service;
+}
+
+/** Returns the bound Twilio telephony service, or `undefined` when telephony is not configured. */
+export function GetTwilioTelephonyService(): TwilioTelephonyService | undefined {
+    return twilioService;
+}

package/src/telephony/twilioMediaRegistry.ts

@@ -0,0 +1,137 @@
+/**
+ * @fileoverview Per-call Media-Streams pump registry for the Twilio telephony ingress.
+ *
+ * This is the server half of the Twilio media plane: it implements the provider package's
+ * `ITwilioMediaPump` seam (which `RealTwilioBindings` drives) on top of the live Media-Streams
+ * websockets MJAPI accepts at `WSS /telephony/twilio/media`. It exists because of a lifecycle gap:
+ * when an INBOUND call's webhook fires, the bridge session starts and `RealTwilioBindings` registers
+ * its inbound-audio handler — but Twilio has not yet opened the media websocket (it does so only AFTER
+ * the webhook's `<Connect><Stream>` TwiML response). The registry bridges that gap by buffering
+ * handler registrations + outbound frames per Call SID and binding them to the socket once it connects
+ * (matched on the `start` frame's Call SID).
+ *
+ * Pure + unit-testable: the websocket is injected as the minimal {@link ITelephonyMediaSocket} surface,
+ * so the registry's buffering / dispatch / stream-SID capture logic is exercised with a fake socket and
+ * no `ws` install or network.
+ *
+ * @module @memberjunction/server/telephony
+ */
+
+import type { TwilioMediaFrame } from '@memberjunction/ai-bridge-twilio';
+import type { ITwilioMediaPump } from '@memberjunction/ai-bridge-twilio';
+
+/**
+ * The minimal websocket surface the registry drives — a structural subset of a `ws` socket, so the
+ * registry never imports `ws` and is testable with a fake. Outbound frames are sent as JSON strings.
+ */
+export interface ITelephonyMediaSocket {
+    /** Sends a serialized outbound Media-Streams frame on the call's socket. */
+    send(data: string): void;
+    /** Closes the socket (best-effort; called on call end). */
+    close(): void;
+}
+
+/** One call's media channel: its socket (once connected), captured stream SID, handlers, and pending sends. */
+interface CallMediaChannel {
+    socket?: ITelephonyMediaSocket;
+    streamSid?: string;
+    /** Inbound-frame handlers registered by RealTwilioBindings (may predate the socket). */
+    frameHandlers: Array<(frame: TwilioMediaFrame) => void>;
+    /** Outbound frames produced before the socket connected — flushed on AttachSocket. */
+    outboundBuffer: TwilioMediaFrame[];
+}
+
+/**
+ * Coordinates Media-Streams sockets with the bridge bindings, keyed by Call SID. One instance per
+ * server, shared between the inbound-webhook service (which binds `RealTwilioBindings` over this as the
+ * `ITwilioMediaPump`) and the WSS server (which attaches sockets + dispatches inbound frames).
+ */
+export class TwilioCallMediaRegistry implements ITwilioMediaPump {
+    private readonly channels = new Map<string, CallMediaChannel>();
+
+    /** Ensures a channel exists for a call (called when a bridge session for the call starts). */
+    public RegisterCall(callSid: string): void {
+        this.ensureChannel(callSid);
+    }
+
+    // ── ITwilioMediaPump ─────────────────────────────────────────────────────────
+
+    /** @inheritdoc — buffers when the socket has not yet connected; sends immediately once it has. */
+    public Send(callSid: string, frame: TwilioMediaFrame): void {
+        const channel = this.ensureChannel(callSid);
+        if (channel.socket) {
+            channel.socket.send(JSON.stringify(frame));
+        } else {
+            channel.outboundBuffer.push(frame);
+        }
+    }
+
+    /** @inheritdoc — stores the handler so frames delivered before AND after socket connect reach it. */
+    public OnFrame(callSid: string, handler: (frame: TwilioMediaFrame) => void): void {
+        this.ensureChannel(callSid).frameHandlers.push(handler);
+    }
+
+    /** @inheritdoc — the captured stream SID, or `''` until the `start` frame arrives. */
+    public GetStreamSid(callSid: string): string {
+        return this.channels.get(callSid)?.streamSid ?? '';
+    }
+
+    // ── WSS-server side ─────────────────────────────────────────────────────────
+
+    /**
+     * Binds a connected Media-Streams socket (and its captured stream SID) to a call, flushing any
+     * outbound frames produced while the socket was still connecting. Called by the WSS server on the
+     * `start` frame.
+     */
+    public AttachSocket(callSid: string, socket: ITelephonyMediaSocket, streamSid: string): void {
+        const channel = this.ensureChannel(callSid);
+        channel.socket = socket;
+        channel.streamSid = streamSid;
+        const buffered = channel.outboundBuffer.splice(0, channel.outboundBuffer.length);
+        for (const frame of buffered) {
+            socket.send(JSON.stringify(frame));
+        }
+    }
+
+    /** Dispatches one inbound Media-Streams frame to all registered handlers for the call. */
+    public DispatchInbound(callSid: string, frame: TwilioMediaFrame): void {
+        const channel = this.channels.get(callSid);
+        if (!channel) {
+            return;
+        }
+        if (frame.event === 'start' && frame.streamSid) {
+            channel.streamSid = frame.streamSid;
+        }
+        for (const handler of channel.frameHandlers) {
+            handler(frame);
+        }
+    }
+
+    /** Tears down a call's channel and closes its socket (called on socket close / call end). */
+    public EndCall(callSid: string): void {
+        const channel = this.channels.get(callSid);
+        if (!channel) {
+            return;
+        }
+        try {
+            channel.socket?.close();
+        } catch {
+            /* best-effort */
+        }
+        this.channels.delete(callSid);
+    }
+
+    /** Whether a channel is currently tracked for the call (test/observability helper). */
+    public HasCall(callSid: string): boolean {
+        return this.channels.has(callSid);
+    }
+
+    private ensureChannel(callSid: string): CallMediaChannel {
+        let channel = this.channels.get(callSid);
+        if (!channel) {
+            channel = { frameHandlers: [], outboundBuffer: [] };
+            this.channels.set(callSid, channel);
+        }
+        return channel;
+    }
+}

package/src/telephony/vonage-runtime.ts

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview Process-wide holder for the startup-constructed Vonage telephony service, so the
+ * outbound `PlaceVonageCall` GraphQL resolver reaches the SAME {@link VonageTelephonyService}
+ * (and thus the same {@link VonageCallMediaRegistry} the media WSS attaches sockets to) that the
+ * inbound webhook router uses. Set once during server boot; read by the resolver.
+ *
+ * @module @memberjunction/server/telephony
+ */
+
+import type { VonageTelephonyService } from './VonageTelephonyService.js';
+
+let vonageService: VonageTelephonyService | undefined;
+
+/** Binds the startup-constructed Vonage telephony service (called from server boot). */
+export function SetVonageTelephonyService(service: VonageTelephonyService): void {
+    vonageService = service;
+}
+
+/** Returns the bound Vonage telephony service, or `undefined` when Vonage telephony is not configured. */
+export function GetVonageTelephonyService(): VonageTelephonyService | undefined {
+    return vonageService;
+}

package/src/telephony/vonageMediaRegistry.ts

@@ -0,0 +1,200 @@
+/**
+ * @fileoverview Per-call WebSocket-media pump registry for the Vonage telephony ingress.
+ *
+ * This is the server half of the Vonage media plane: it implements the provider package's
+ * `IVonageMediaPump` seam (which `RealVonageBindings` drives) on top of the live bidirectional media
+ * websockets MJAPI accepts at `WSS /telephony/vonage/media`. It exists because of the same lifecycle
+ * gap the Twilio ingress has: when an INBOUND call's answer webhook fires, the bridge session starts and
+ * `RealVonageBindings` registers its inbound-audio handler — but Vonage has not yet opened the media
+ * websocket (it does so only AFTER the answer-webhook's `connect`-websocket NCCO response). The registry
+ * bridges that gap by buffering handler registrations + outbound frames per call UUID and binding them to
+ * the socket once it connects (matched on the call UUID Vonage forwards on the websocket handshake).
+ *
+ * Pure + unit-testable: the websocket is injected as the minimal {@link ITelephonyMediaSocket} surface,
+ * so the registry's buffering / dispatch logic is exercised with a fake socket and no `ws` install or
+ * network.
+ *
+ * @module @memberjunction/server/telephony
+ */
+
+import type { VonageControlEvent, IVonageMediaPump } from '@memberjunction/ai-bridge-vonage';
+
+/**
+ * The minimal websocket surface the registry drives — a structural subset of a `ws` socket, so the
+ * registry never imports `ws` and is testable with a fake. Vonage audio is sent as BINARY frames (raw
+ * L16 PCM); the registry never sends text frames outbound (Vonage's media socket only accepts audio).
+ */
+export interface ITelephonyMediaSocket {
+    /** Sends one outbound BINARY audio frame (raw L16 PCM) on the call's socket. */
+    sendBinary(data: Uint8Array): void;
+    /** Sends one outbound TEXT control frame (JSON command, e.g. `{"action":"clear"}`) on the call's socket. */
+    sendText(data: string): void;
+    /** Closes the socket (best-effort; called on call end). */
+    close(): void;
+}
+
+/**
+ * The exact byte size of one outbound audio frame Vonage expects on the `audio/l16;rate=8000` leg: a
+ * 20 ms slice = 8000 Hz × 0.020 s = 160 samples × 2 bytes = **320 bytes**. The realtime model emits audio
+ * in arbitrary-size deltas; the bridge resamples each whole delta to 8 kHz, so the registry MUST re-slice
+ * into these fixed frames before sending. Handing Vonage one oversized blob per delta garbles playback and
+ * (worse) defeats barge-in: `{"action":"clear"}` can drop QUEUED frames but not a giant in-flight one.
+ */
+const OUTBOUND_FRAME_BYTES = 320;
+
+/** One call's media channel: its socket (once connected), handlers, and pending outbound audio. */
+interface CallMediaChannel {
+    socket?: ITelephonyMediaSocket;
+    /** Inbound audio handlers registered by RealVonageBindings (may predate the socket). */
+    audioHandlers: Array<(pcm: ArrayBuffer) => void>;
+    /** Inbound control-event handlers (DTMF / connected / close) registered by RealVonageBindings. */
+    eventHandlers: Array<(event: VonageControlEvent) => void>;
+    /** Whole 20 ms (320-byte) outbound frames produced before the socket connected — flushed on AttachSocket. */
+    outboundBuffer: Uint8Array[];
+    /** Carry-over outbound bytes that didn't fill a whole 320-byte frame yet (prepended to the next delta). */
+    partial: Uint8Array;
+}
+
+/**
+ * Coordinates Vonage media websockets with the bridge bindings, keyed by call UUID. One instance per
+ * server, shared between the inbound-webhook service (which binds `RealVonageBindings` over this as the
+ * `IVonageMediaPump`) and the WSS server (which attaches sockets + dispatches inbound audio/events).
+ *
+ * Models Vonage's wire split: outbound audio → binary frames; inbound binary frames → audio handlers;
+ * inbound JSON text frames → parsed {@link VonageControlEvent}s → event handlers. There is no base64
+ * envelope or μ-law transcode — that's the Twilio path, not Vonage's.
+ */
+export class VonageCallMediaRegistry implements IVonageMediaPump {
+    private readonly channels = new Map<string, CallMediaChannel>();
+
+    /** Ensures a channel exists for a call (called when a bridge session for the call starts). */
+    public RegisterCall(callUuid: string): void {
+        this.ensureChannel(callUuid);
+    }
+
+    // ── IVonageMediaPump ─────────────────────────────────────────────────────────
+
+    /**
+     * @inheritdoc — re-slices the (already-8 kHz) delta into fixed 320-byte / 20 ms frames before sending,
+     * carrying any sub-frame remainder into the next delta so the stream stays continuous (no silence gaps).
+     * Each whole frame is sent immediately if the socket is live, else buffered for {@link AttachSocket}.
+     */
+    public SendAudio(callUuid: string, pcm: ArrayBuffer): void {
+        const channel = this.ensureChannel(callUuid);
+        const incoming = new Uint8Array(pcm);
+        const data = channel.partial.length > 0 ? concatBytes(channel.partial, incoming) : incoming;
+
+        let offset = 0;
+        while (data.length - offset >= OUTBOUND_FRAME_BYTES) {
+            // `.slice` returns a fresh copy, so a buffered frame never retains the larger backing buffer.
+            const frame = data.slice(offset, offset + OUTBOUND_FRAME_BYTES);
+            offset += OUTBOUND_FRAME_BYTES;
+            if (channel.socket) {
+                channel.socket.sendBinary(frame);
+            } else {
+                channel.outboundBuffer.push(frame);
+            }
+        }
+
+        channel.partial = offset < data.length ? data.slice(offset) : new Uint8Array(0);
+    }
+
+    /** @inheritdoc — stores the audio handler so frames delivered before AND after socket connect reach it. */
+    public OnAudio(callUuid: string, handler: (pcm: ArrayBuffer) => void): void {
+        this.ensureChannel(callUuid).audioHandlers.push(handler);
+    }
+
+    /** @inheritdoc — stores the control-event handler (DTMF / connected / close). */
+    public OnEvent(callUuid: string, handler: (event: VonageControlEvent) => void): void {
+        this.ensureChannel(callUuid).eventHandlers.push(handler);
+    }
+
+    /**
+     * @inheritdoc — barge-in flush: drop any outbound audio buffered locally (socket not yet connected) AND,
+     * if the socket is live, send Vonage's `{"action":"clear"}` text command to discard its playback queue.
+     * Safe to call for an unknown/uninitialized call (no-op).
+     */
+    public Clear(callUuid: string): void {
+        const channel = this.channels.get(callUuid);
+        if (!channel) {
+            return;
+        }
+        channel.outboundBuffer.length = 0;
+        channel.partial = new Uint8Array(0); // drop the half-built frame too, or it would prepend to the next turn
+        channel.socket?.sendText(JSON.stringify({ action: 'clear' }));
+    }
+
+    // ── WSS-server side ─────────────────────────────────────────────────────────
+
+    /**
+     * Binds a connected media socket to a call, flushing any outbound audio produced while the socket
+     * was still connecting. Called by the WSS server once it resolves the call UUID for the socket (from
+     * the `call_uuid` query param the answer NCCO embedded on the media URL).
+     */
+    public AttachSocket(callUuid: string, socket: ITelephonyMediaSocket): void {
+        const channel = this.ensureChannel(callUuid);
+        channel.socket = socket;
+        const buffered = channel.outboundBuffer.splice(0, channel.outboundBuffer.length);
+        for (const frame of buffered) {
+            socket.sendBinary(frame);
+        }
+    }
+
+    /** Dispatches one inbound binary audio frame (raw L16 PCM) to all audio handlers for the call. */
+    public DispatchInboundAudio(callUuid: string, pcm: ArrayBuffer): void {
+        const channel = this.channels.get(callUuid);
+        if (!channel) {
+            return;
+        }
+        for (const handler of channel.audioHandlers) {
+            handler(pcm);
+        }
+    }
+
+    /** Dispatches one inbound control event (parsed from a JSON text frame) to all event handlers for the call. */
+    public DispatchInboundEvent(callUuid: string, event: VonageControlEvent): void {
+        const channel = this.channels.get(callUuid);
+        if (!channel) {
+            return;
+        }
+        for (const handler of channel.eventHandlers) {
+            handler(event);
+        }
+    }
+
+    /** Tears down a call's channel and closes its socket (called on socket close / call end). */
+    public EndCall(callUuid: string): void {
+        const channel = this.channels.get(callUuid);
+        if (!channel) {
+            return;
+        }
+        try {
+            channel.socket?.close();
+        } catch {
+            /* best-effort */
+        }
+        this.channels.delete(callUuid);
+    }
+
+    /** Whether a channel is currently tracked for the call (test/observability helper). */
+    public HasCall(callUuid: string): boolean {
+        return this.channels.has(callUuid);
+    }
+
+    private ensureChannel(callUuid: string): CallMediaChannel {
+        let channel = this.channels.get(callUuid);
+        if (!channel) {
+            channel = { audioHandlers: [], eventHandlers: [], outboundBuffer: [], partial: new Uint8Array(0) };
+            this.channels.set(callUuid, channel);
+        }
+        return channel;
+    }
+}
+
+/** Concatenates two byte arrays into a fresh `Uint8Array` (the carry-over remainder + the next delta). */
+function concatBytes(a: Uint8Array, b: Uint8Array): Uint8Array {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+}

package/dist/agents/skip-agent.d.ts

@@ -1,111 +0,0 @@
-/**
- * Skip Proxy Agent
- *
- * A proxy agent that integrates Skip SaaS API into the MemberJunction agent framework.
- * This agent acts as a bridge, allowing Skip to be invoked like any other MJ agent
- * while maintaining compatibility with the existing Skip infrastructure.
- */
-import { BaseAgent } from "@memberjunction/ai-agents";
-import { ExecuteAgentParams, AgentConfiguration, BaseAgentNextStep } from "@memberjunction/ai-core-plus";
-import { SkipAPIResponse } from "@memberjunction/skip-types";
-import { DataContext } from "@memberjunction/data-context";
-/**
- * Context type for Skip agent execution
- */
-export interface SkipAgentContext {
-    /**
-     * Optional data context ID to load
-     */
-    dataContextId?: string;
-    /**
-     * Optional pre-loaded data context
-     */
-    dataContext?: DataContext;
-    /**
-     * Conversation ID for tracking Skip conversations
-     */
-    conversationId?: string;
-    /**
-     * Force entity metadata refresh
-     */
-    forceEntityRefresh?: boolean;
-    /**
-     * Database connection (injected by caller)
-     */
-    dataSource?: any;
-}
-/**
- * Payload returned from Skip agent execution
- * Contains the full Skip API response for downstream consumers
- */
-export interface SkipAgentPayload {
-    /**
-     * The full Skip API response
-     */
-    skipResponse: SkipAPIResponse;
-    /**
-     * Response phase from Skip
-     */
-    responsePhase: string;
-    /**
-     * Conversation ID
-     */
-    conversationId: string;
-    /**
-     * User-facing message (title or clarifying question)
-     */
-    message?: string;
-}
-/**
- * Skip Proxy Agent
- *
- * This agent provides a simple proxy to the Skip SaaS API, allowing Skip to be
- * invoked through the standard MJ agent framework. It handles:
- * - Converting MJ conversation messages to Skip format
- * - Streaming progress updates from Skip
- * - Mapping Skip responses to MJ agent next steps
- * - Returning full Skip responses in the payload
- */
-export declare class SkipProxyAgent extends BaseAgent {
-    private skipSDK;
-    constructor();
-    /**
-     * Execute the Skip agent - proxies to Skip SaaS API
-     */
-    protected executeAgentInternal<P = SkipAgentPayload>(params: ExecuteAgentParams<SkipAgentContext, P>, config: AgentConfiguration): Promise<{
-        finalStep: BaseAgentNextStep<P>;
-        stepCount: number;
-    }>;
-    /**
-     * Load conversation messages from database with real UUIDs using MemberJunction's RunView pattern
-     * This is the preferred method as it ensures all messages have proper conversationDetailIDs
-     */
-    private loadMessagesFromDatabase;
-    /**
-     * Convert MJ ChatMessage format to Skip SkipMessage format
-     * This is a fallback method when database loading is not available
-     */
-    private convertMessagesToSkipFormat;
-    /**
-     * Map Skip API response to MJ agent next step.
-     *
-     * Checks for Skip-level errors first, then delegates to phase-specific handlers.
-     */
-    private mapSkipResponseToNextStep;
-    /**
-     * Handle Skip error responses — extracts the most descriptive error available
-     */
-    private handleSkipError;
-    /**
-     * Handle analysis_complete phase — supports both component-bearing responses
-     * (componentOptions populated) and analysis-only responses (markdown in `analysis`
-     * with no component, produced by Skip's Analysis Agent path).
-     */
-    private handleAnalysisComplete;
-    /**
-     * Handle clarifying_question phase
-     */
-    private handleClarifyingQuestion;
-    private tempHack;
-}
-//# sourceMappingURL=skip-agent.d.ts.map

package/dist/agents/skip-agent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skip-agent.d.ts","sourceRoot":"","sources":["../../src/agents/skip-agent.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EACH,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACpB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACH,eAAe,EAIlB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAM3D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,UAAU,CAAC,EAAE,GAAG,CAAC;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,YAAY,EAAE,eAAe,CAAC;IAE9B;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,qBACa,cAAe,SAAQ,SAAS;IACzC,OAAO,CAAC,OAAO,CAAU;;IAOzB;;OAEG;cACsB,oBAAoB,CAAC,CAAC,GAAG,gBAAgB,EAC9D,MAAM,EAAE,kBAAkB,CAAC,gBAAgB,EAAE,CAAC,CAAC,EAC/C,MAAM,EAAE,kBAAkB,GAC3B,OAAO,CAAC;QAAE,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;KAAE,CAAC;IA4FnE;;;OAGG;YACW,wBAAwB;IA2DtC;;;OAGG;IACH,OAAO,CAAC,2BAA2B;IAsBnC;;;;OAIG;IACH,OAAO,CAAC,yBAAyB;IA8BjC;;OAEG;IACH,OAAO,CAAC,eAAe;IAqBvB;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAqD9B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAYhC,OAAO,CAAC,QAAQ;CAQnB"}