@symbolica/agentica 0.3.2 → 0.4.1

package/dist-transformer/client-session-manager/client-session-manager.js

@@ -35,9 +35,10 @@ import { version } from '../version.js';
  */
 export class ClientSessionManager {
     constructor(config = {}) {
-        this.websocket = null;
-        this.tasks = null;
-        this.sendQueue = null;
+        // Per-session-manager WebSocket state (sm_id → connection state)
+        this.sessionManagers = new Map();
+        this.smLocks = new Map();
+        this.uidToSm = new Map(); // agent uid → sm_id
         this.baseHttp = null;
         this.baseWs = null;
         this.apiKey = null;
@@ -158,31 +159,30 @@ export class ClientSessionManager {
         return headers;
     }
     /**
-     * Background task for writing messages to WebSocket - matches Python _ws_background_task_writer
+     * Background task for writing messages to WebSocket for a specific session manager.
      */
-    async wsBackgroundTaskWriter(control) {
+    async smWriter(smId, control) {
         await waitForTracing;
-        const wsLogger = this.logger.withScope('ws-writer');
+        const wsLogger = this.logger.withScope(`ws-writer-${smId.slice(0, 8)}`);
         wsLogger.debug('Writer task started');
-        const ws = this.websocket;
         try {
             while (!control.shouldStop) {
+                const smc = this.sessionManagers.get(smId);
+                if (!smc) {
+                    wsLogger.debug('Session manager connection removed, exiting writer');
+                    break;
+                }
                 try {
-                    const sendQueue = this.sendQueue;
-                    if (!sendQueue) {
-                        wsLogger.debug('Send queue removed, exiting writer');
-                        break;
-                    }
-                    const msg = await sendQueue.get();
+                    const msg = await smc.sendQueue.get();
                     const msgUid = msg.uid;
                     const msgLogger = msgUid ? (this.uidToLogger.get(msgUid) ?? wsLogger) : wsLogger;
-                    if (ws.readyState !== 1) {
+                    if (smc.websocket.readyState !== 1) {
                         const error = new WebSocketConnectionError(`cannot send as websocket is not open.`);
                         enrichError(error, { uid: msgUid, sessionId: this.clientSessionId });
                         throw error;
                     }
                     msgLogger.debug(`Sending ${msg.type} message`);
-                    ws.send(encodeMessage(msg));
+                    smc.websocket.send(encodeMessage(msg));
                 }
                 catch (error) {
                     if (error instanceof Error && error.message === 'Queue closed') {
@@ -196,26 +196,24 @@ export class ClientSessionManager {
         }
         catch (error) {
             wsLogger.error('Writer task failed', error);
-            for (const [matchId, handlers] of this.matchIid.entries()) {
-                handlers.reject(new WebSocketConnectionError(`WebSocket writer failed: ${error.message}`));
-                this.matchIid.delete(matchId);
-            }
-            for (const [_, exceptionMap] of this.uidIidException.entries()) {
-                for (const [_iid, handlers] of exceptionMap.entries()) {
-                    handlers.reject(new WebSocketConnectionError(`WebSocket writer failed: ${error.message}`));
-                }
-            }
+            // Clean up this session manager only - don't affect others
+            await this._cleanupSessionManager(smId);
             throw error;
         }
     }
     /**
-     * Background task for reading messages from WebSocket - matches Python _ws_background_task_reader
+     * Background task for reading messages from WebSocket for a specific session manager.
      */
-    async wsBackgroundTaskReader(control) {
+    async smReader(smId, control) {
         await waitForTracing;
-        const wsLogger = this.logger.withScope('ws-reader');
+        const wsLogger = this.logger.withScope(`ws-reader-${smId.slice(0, 8)}`);
         wsLogger.debug('Reader task started');
-        const ws = this.websocket;
+        const smc = this.sessionManagers.get(smId);
+        if (!smc) {
+            wsLogger.warn('Session manager connection not found');
+            return;
+        }
+        const ws = smc.websocket;
         ws.onmessage = (event) => {
             if (control.shouldStop)
                 return;
@@ -317,48 +315,125 @@ export class ClientSessionManager {
             ws.onclose = (event) => {
                 wsLogger.debug(`WebSocket closed (code=${event.code}, reason=${event.reason || 'none'})`);
                 control.shouldStop = true;
-                for (const [matchId, handlers] of this.matchIid.entries()) {
-                    handlers.reject(new WebSocketConnectionError(`WebSocket closed: ${event.reason || 'Connection closed'}`));
-                    this.matchIid.delete(matchId);
-                }
-                for (const [_, exceptionMap] of this.uidIidException.entries()) {
-                    for (const [_iid, handlers] of exceptionMap.entries()) {
-                        handlers.reject(new WebSocketConnectionError(`WebSocket closed: ${event.reason || 'Connection closed'}`));
-                    }
-                    exceptionMap.clear();
-                }
+                // Only fail futures for agents on THIS session manager
+                this._failSmFutures(smId, `WebSocket closed: ${event.reason || 'Connection closed'}`);
                 resolve();
             };
             ws.onerror = (_error) => {
                 wsLogger.error('WebSocket error');
                 control.shouldStop = true;
-                for (const [matchId, handlers] of this.matchIid.entries()) {
-                    handlers.reject(new WebSocketConnectionError('WebSocket error occurred'));
-                    this.matchIid.delete(matchId);
-                }
-                for (const [_, exceptionMap] of this.uidIidException.entries()) {
-                    for (const [_iid, handlers] of exceptionMap.entries()) {
-                        handlers.reject(new WebSocketConnectionError('WebSocket error occurred'));
-                    }
-                    exceptionMap.clear();
-                }
+                // Only fail futures for agents on THIS session manager
+                this._failSmFutures(smId, 'WebSocket error occurred');
                 resolve();
             };
         });
     }
     /**
-     * Ensure WebSocket connection exists, creating it if needed.
+     * Fail pending futures for agents on a specific session manager.
+     */
+    _failSmFutures(smId, reason) {
+        // Get all UIDs that belong to this session manager
+        const affectedUids = [];
+        for (const [uid, sid] of this.uidToSm.entries()) {
+            if (sid === smId) {
+                affectedUids.push(uid);
+            }
+        }
+        // Fail matchIid promises for affected UIDs (we don't track which session manager a match_id belongs to,
+        // so we fail all of them when any session manager fails - this is conservative but safe)
+        for (const [matchId, handlers] of this.matchIid.entries()) {
+            handlers.reject(new WebSocketConnectionError(reason));
+            this.matchIid.delete(matchId);
+        }
+        // Fail exception handlers for affected UIDs
+        for (const uid of affectedUids) {
+            const exceptionMap = this.uidIidException.get(uid);
+            if (exceptionMap) {
+                for (const [_iid, handlers] of exceptionMap.entries()) {
+                    handlers.reject(new WebSocketConnectionError(reason));
+                }
+                exceptionMap.clear();
+            }
+        }
+    }
+    /**
+     * Clean up a specific session manager's connection without affecting others.
+     */
+    async _cleanupSessionManager(smId) {
+        const smc = this.sessionManagers.get(smId);
+        if (!smc) {
+            return;
+        }
+        this.logger.debug(`Cleaning up session manager ${smId.slice(0, 8)}`);
+        this.sessionManagers.delete(smId);
+        this.smLocks.delete(smId);
+        // Stop tasks
+        const [readerControl, writerControl] = smc.tasks;
+        readerControl.shouldStop = true;
+        writerControl.shouldStop = true;
+        // Close send queue
+        smc.sendQueue.close();
+        // Close WebSocket gracefully
+        try {
+            if (smc.websocket.readyState === 0 || smc.websocket.readyState === 1) {
+                smc.websocket.close(1000, 'Normal closure');
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Failed to close WebSocket for session manager ${smId.slice(0, 8)}`, error);
+        }
+        // Wait for tasks to complete
+        await Promise.allSettled([readerControl.promise, writerControl.promise]);
+        // Fail pending futures for agents on this session manager
+        this._failSmFutures(smId, 'Session manager connection closed');
+        // Clean up agent-to-session-manager mappings
+        const affectedUids = [];
+        for (const [uid, sid] of this.uidToSm.entries()) {
+            if (sid === smId) {
+                affectedUids.push(uid);
+            }
+        }
+        for (const uid of affectedUids) {
+            this.uidToSm.delete(uid);
+        }
+        this.logger.debug(`Cleaned up session manager ${smId.slice(0, 8)}`);
+    }
+    /**
+     * Ensure WebSocket connection exists for a specific session manager, creating it if needed.
      */
-    async _ensureWebSocketConnection() {
-        if (this.websocket && this.websocket.readyState === 1) {
+    async _ensureSmConnection(smId) {
+        // Fast path: connection already exists
+        const existing = this.sessionManagers.get(smId);
+        if (existing && existing.websocket.readyState === 1) {
             return;
         }
+        // Check if another call is already creating this connection
+        const existingLock = this.smLocks.get(smId);
+        if (existingLock) {
+            await existingLock;
+            return;
+        }
+        // Create lock IMMEDIATELY after check - no await between check and set
+        let resolveLock;
+        const lockPromise = new Promise((resolve) => {
+            resolveLock = resolve;
+        });
+        this.smLocks.set(smId, lockPromise);
+        // Now safe to yield
         await waitForTracing;
-        const span = this.logger.startSpan('sdk.websocket_connection');
+        const span = this.logger.startSpan('sdk.sm_connection');
+        span.setAttribute('session_manager.id', smId);
         try {
-            this.sendQueue = new Queue();
+            // Double-check after acquiring lock
+            const doubleCheck = this.sessionManagers.get(smId);
+            if (doubleCheck && doubleCheck.websocket.readyState === 1) {
+                resolveLock();
+                this.smLocks.delete(smId);
+                return;
+            }
+            const sendQueue = new Queue();
             const websocket_uri = `${this.baseWs}/socket`;
-            this.logger.debug(`Connecting WebSocket`);
+            this.logger.debug(`Connecting WebSocket for session manager ${smId.slice(0, 8)}`);
             span.setAttribute('websocket.uri', websocket_uri);
             span.setAttribute('websocket.state', 'connecting');
             // Create headers object with trace context for distributed tracing
@@ -368,22 +443,18 @@ export class ClientSessionManager {
             }
             headers['x-client-session-id'] = this.clientSessionId;
             // Inject trace context into WebSocket headers for distributed tracing
-            // Execute in span's context to ensure proper trace propagation (like Python's inject(headers, context=ctx))
             if (span.executeInContext) {
                 span.executeInContext(() => {
                     injectTraceContext(headers);
                 });
             }
             else {
-                // Fallback: pass span context directly
                 injectTraceContext(headers, span);
             }
-            // Pass null for apiKey since headers already has Authorization
             const ws = await createWebSocket(websocket_uri, this.apiKey, headers);
             ws.binaryType = 'arraybuffer';
             return new Promise((resolve, reject) => {
                 ws.onopen = () => {
-                    this.websocket = ws;
                     try {
                         ws._socket?.unref?.();
                     }
@@ -398,23 +469,34 @@ export class ClientSessionManager {
                         shouldStop: false,
                         promise: Promise.resolve(),
                     };
-                    readerControl.promise = this.wsBackgroundTaskReader(readerControl).catch((error) => {
-                        this.logger.error('Reader background task crashed', error);
+                    // Store the session manager connection first so tasks can access it
+                    const smc = {
+                        websocket: ws,
+                        sendQueue,
+                        tasks: [readerControl, writerControl],
+                    };
+                    this.sessionManagers.set(smId, smc);
+                    // Start per-session-manager reader and writer tasks
+                    readerControl.promise = this.smReader(smId, readerControl).catch((error) => {
+                        this.logger.error(`Reader task crashed for session manager ${smId.slice(0, 8)}`, error);
                     });
-                    writerControl.promise = this.wsBackgroundTaskWriter(writerControl).catch((error) => {
-                        this.logger.error('Writer background task crashed', error);
+                    writerControl.promise = this.smWriter(smId, writerControl).catch((error) => {
+                        this.logger.error(`Writer task crashed for session manager ${smId.slice(0, 8)}`, error);
                     });
-                    this.tasks = [readerControl, writerControl];
-                    this.logger.info(`WebSocket connected`);
+                    this.logger.info(`WebSocket connected for session manager ${smId.slice(0, 8)}`);
                     span.setAttribute('websocket.state', 'connected');
                     span.end();
+                    resolveLock();
+                    this.smLocks.delete(smId);
                     resolve();
                 };
                 ws.onerror = (error) => {
-                    this.logger.error(`WebSocket connection failed:\n${error.toString()}`);
+                    this.logger.error(`WebSocket connection failed for session manager ${smId.slice(0, 8)}:\n${error.toString()}`);
                     span.setAttribute('websocket.state', 'error');
                     span.recordException(error);
                     span.end();
+                    resolveLock();
+                    this.smLocks.delete(smId);
                     reject(new WebSocketConnectionError('WebSocket connection failed'));
                 };
             });
@@ -423,6 +505,8 @@ export class ClientSessionManager {
             span.setAttribute('websocket.state', 'error');
             span.recordException(error);
             span.end();
+            resolveLock();
+            this.smLocks.delete(smId);
             throw error;
         }
     }
@@ -503,10 +587,26 @@ export class ClientSessionManager {
                     logger.warn(message);
                 }
             }
-            const uid = await response.text();
+            // Parse JSON response: { uid, session_manager_id }
+            const responseData = await response.json();
+            const uid = responseData.uid;
+            const smId = responseData.session_manager_id;
+            // Validate response fields
+            if (!uid) {
+                logger.error(`Server response missing "uid" field: ${JSON.stringify(responseData)}`);
+                throw new ConnectionError('Invalid server response: missing "uid" field');
+            }
+            if (!smId) {
+                logger.error(`Server response missing "session_manager_id" field: ${JSON.stringify(responseData)}`);
+                throw new ConnectionError('Invalid server response: missing "session_manager_id" field');
+            }
             logger.info('Created agent');
             span.setAttribute('agent.uid', uid);
-            await this._ensureWebSocketConnection();
+            span.setAttribute('agent.session_manager_id', smId);
+            // Track which session manager this agent belongs to
+            this.uidToSm.set(uid, smId);
+            // Ensure WebSocket connection for this session manager
+            await this._ensureSmConnection(smId);
             this.knownUids.add(uid);
             this._initAgentState(uid, parentLogger);
             return uid;
@@ -542,8 +642,22 @@ export class ClientSessionManager {
                 enrichError(error, { uid, sessionId: this.clientSessionId });
                 throw error;
             }
+            // Get session manager for this agent
+            const smId = this.uidToSm.get(uid);
+            if (!smId) {
+                const error = new WebSocketConnectionError(`No session manager found for agent ${uid}`);
+                enrichError(error, { uid, sessionId: this.clientSessionId });
+                throw error;
+            }
+            const smc = this.sessionManagers.get(smId);
+            if (!smc || smc.websocket.readyState !== 1) {
+                const error = new WebSocketConnectionError(`No active connection for session manager ${smId}`);
+                enrichError(error, { uid, sessionId: this.clientSessionId });
+                throw error;
+            }
             // Add attributes matching Python SDK
             span.setAttribute('agent.uid', uid);
+            span.setAttribute('agent.session_manager_id', smId);
             span.setAttribute('agent.task_desc', typeof taskDesc === 'string' ? taskDesc : taskDesc.template);
             span.setAttribute('invocation.streaming', streaming);
             const matchId = this.idIssuer();
@@ -556,11 +670,12 @@ export class ClientSessionManager {
                 prompt: taskDesc,
                 streaming: streaming,
             };
-            invLogger.debug(`Invoking with match_id=${matchId}`);
+            invLogger.debug(`Invoking with match_id=${matchId} on session manager ${smId.slice(0, 8)}`);
             const iidPromise = new Promise((resolve, reject) => {
                 this.matchIid.set(matchId, { resolve, reject });
             });
-            this.sendQueue.put(msg);
+            // Route to the correct session manager's send queue
+            smc.sendQueue.put(msg);
             const iid = await iidPromise;
             this.iidToUid.set(iid, uid);
             invLogger.info(`Invocation created with iid=${iid}`);
@@ -577,8 +692,14 @@ export class ClientSessionManager {
                 return { resolvers: { resolve, reject, promise }, promise };
             })();
             this.uidIidException.get(uid).set(iid, resolvers);
+            // Capture smId for the closure
+            const capturedSmId = smId;
             return {
                 send_message: async (data) => {
+                    const currentSmc = this.sessionManagers.get(capturedSmId);
+                    if (!currentSmc || currentSmc.websocket.readyState !== 1) {
+                        throw new WebSocketConnectionError(`Session manager connection closed for ${capturedSmId}`);
+                    }
                     const dataMsg = {
                         type: 'data',
                         uid,
@@ -586,7 +707,7 @@ export class ClientSessionManager {
                         data,
                         timestamp: new Date().toISOString(),
                     };
-                    this.sendQueue.put(dataMsg);
+                    currentSmc.sendQueue.put(dataMsg);
                     invLogger.debug(`Queued ${data.length} bytes to send`);
                 },
                 recv_message: async () => {
@@ -610,7 +731,7 @@ export class ClientSessionManager {
     /**
      * Echo streaming endpoint
      */
-    async *echo(cancelSignal, uid, iid) {
+    async *echo(cancelSignal, uid, iid, includeUsage = false) {
         if (!this.baseHttp) {
             const error = new ConnectionError('Base HTTP endpoint must be set');
             enrichError(error, { uid, iid, sessionId: this.clientSessionId });
@@ -670,8 +791,16 @@ export class ClientSessionManager {
                             const logmsg = JSON.parse(line);
                             const typ = logmsg.type;
                             if (typ === 'sm_invocation_exit') {
-                                this.logger.debug('Received invocation exit signal, ending stream');
-                                return;
+                                // Only return if listening to a specific invocation.
+                                // When iid is undefined, we're listening to all invocations
+                                // for this agent and should continue across invocations.
+                                if (iid !== undefined) {
+                                    this.logger.debug('Received invocation exit signal, ending stream');
+                                    return;
+                                }
+                                yield { role: 'agent', content: '', type: 'invocation_exit' };
+                                isStreaming = false;
+                                continue;
                             }
                             if (typ === 'sm_monad' && logmsg.body) {
                                 const body = JSON.parse(logmsg.body);
@@ -681,7 +810,7 @@ export class ClientSessionManager {
                                     isStreaming = true;
                                     const delta = body.args[0];
                                     if (delta && delta.content) {
-                                        yield { role: 'agent', content: delta.content };
+                                        yield { role: 'agent', content: delta.content, type: delta.type };
                                         chunkCount++;
                                     }
                                 }
@@ -693,11 +822,15 @@ export class ClientSessionManager {
                                             // Skip system messages
                                             continue;
                                         }
-                                        else if (isStreaming && role === 'agent') {
-                                            // Skip agent messages as they're already handled in stream_chunk
+                                        else if (isStreaming && role === 'agent' && delta.type !== 'usage') {
+                                            // Skip agent messages as they're already handled in stream_chunk,
+                                            // except usage chunks which are only sent via delta
                                             continue;
                                         }
-                                        yield { role, content: delta.content };
+                                        if (delta.type === 'usage' && !includeUsage) {
+                                            continue;
+                                        }
+                                        yield { role, content: delta.content, type: delta.type };
                                         chunkCount++;
                                     }
                                 }
@@ -804,29 +937,34 @@ export class ClientSessionManager {
      * @param lastTotal - Previous cumulative total (for cross-invocation adjustment)
      * @returns Object containing the usage for this invocation and the new cumulative total
      */
-    async fetchUsage(uid, iid, lastTotal) {
+    async fetchUsage(uid, iid, _lastTotal) {
         // Fetch logs for this invocation and sum usages
+        // Each log entry contains non-cumulative usage values, so we just add them up
+        // The logs are already filtered by iid, so they only contain this invocation's data
         let total = Usage.zero();
         const logs = await this.logs(uid, iid, { type: 'sm_inference_usage' });
         for (const log of logs) {
             const logUsage = log.usage;
             if (logUsage) {
-                total = total.add(Usage.fromCompletions(logUsage, total));
+                // Don't pass lastUsage - each log entry is already non-cumulative
+                total = total.add(Usage.fromCompletions(logUsage));
             }
         }
-        let usage = total;
-        if (lastTotal) {
-            // Subtract previous cumulative total, but keep output_tokens as-is
-            // since output_tokens is already absolute (not cumulative)
-            usage = total.sub(lastTotal.replace({ outputTokens: 0 }));
-        }
-        return { usage, newTotal: total };
+        return { usage: total, newTotal: total };
     }
     /**
      * Check if agent exists - matches Python agent_exists
      */
     agentExists(uid) {
-        return this.knownUids.has(uid) && this.websocket !== null && this.websocket.readyState === 1; // 1 = OPEN
+        if (!this.knownUids.has(uid)) {
+            return false;
+        }
+        const smId = this.uidToSm.get(uid);
+        if (!smId) {
+            return false;
+        }
+        const smc = this.sessionManagers.get(smId);
+        return smc !== undefined && smc.websocket.readyState === 1; // 1 = OPEN
     }
     /**
      * Get uid from iid (used for parent-child agent tracking)
@@ -867,7 +1005,7 @@ export class ClientSessionManager {
         }
     }
     /**
-     * Close a specific agent's resources (does not close the shared WebSocket)
+     * Close a specific agent's resources (does not close the session manager's WebSocket unless it's the last agent)
      */
     async closeAgent(uid) {
         const logger = this.uidToLogger.get(uid) ?? this.logger;
@@ -890,6 +1028,7 @@ export class ClientSessionManager {
         this.uidIidException.delete(uid);
         this.knownUids.delete(uid);
         this.uidToLogger.delete(uid);
+        this.uidToSm.delete(uid);
         logger.debug(`Closed agent ${uid.slice(0, 8)}`);
         // Finally, destroy the agent on the server
         await this.destroyAgent(uid);
@@ -905,37 +1044,16 @@ export class ClientSessionManager {
         const span = this.logger.startSpan('stop');
         try {
             const agentCount = this.knownUids.size;
-            this.logger.debug(`CSM Stop: stopping with ${agentCount} agent(s)`);
+            const smCount = this.sessionManagers.size;
+            this.logger.debug(`CSM Stop: stopping with ${agentCount} agent(s) on ${smCount} session manager(s)`);
             span.setAttribute('agent_count', agentCount);
+            span.setAttribute('session_manager_count', smCount);
             // Close all agents (cleans up per-agent state and destroys on server)
             const uids = Array.from(this.knownUids);
             await Promise.allSettled(uids.map((uid) => this.closeAgent(uid)));
-            // Close send queue
-            if (this.sendQueue) {
-                this.sendQueue.close();
-                this.sendQueue = null;
-            }
-            // Close WebSocket gracefully
-            if (this.websocket) {
-                try {
-                    // 0 = CONNECTING, 1 = OPEN
-                    if (this.websocket.readyState === 0 || this.websocket.readyState === 1) {
-                        this.websocket.close(1000, 'Normal closure');
-                    }
-                }
-                catch (error) {
-                    this.logger.warn('Failed to close WebSocket', error);
-                }
-                this.websocket = null;
-            }
-            // Stop tasks
-            if (this.tasks) {
-                const [readerControl, writerControl] = this.tasks;
-                readerControl.shouldStop = true;
-                writerControl.shouldStop = true;
-                await Promise.allSettled([readerControl.promise, writerControl.promise]);
-                this.tasks = null;
-            }
+            // Clean up all session manager connections
+            const smIds = Array.from(this.sessionManagers.keys());
+            await Promise.allSettled(smIds.map((smId) => this._cleanupSessionManager(smId)));
             this.logger.debug('All resources cleaned up');
             this.isStopped = true;
             // Ensure invocation guard is cleared

package/dist-transformer/client-session-manager/types.d.ts

@@ -1,6 +1,6 @@
 export type { components, operations, paths } from '../types/api.d';
 import type { components } from '../types/api.d';
-export type CreateAgentRequest = Omit<components['schemas']['CreateAgentRequest'], 'warp_globals_payload' | 'protocol'> & {
+export type CreateAgentRequest = Omit<components['schemas']['CreateAgentRequest'], 'warp_globals_payload' | 'protocol' | 'json'> & {
     warp_globals_payload: Uint8Array;
     protocol?: string;
 };

package/dist-transformer/client-session-manager/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/client-session-manager/types.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,MAAM,MAAM,kBAAkB,GAAG,IAAI,CACjC,UAAU,CAAC,SAAS,CAAC,CAAC,oBAAoB,CAAC,EAC3C,sBAAsB,GAAG,UAAU,CACtC,GAAG;IACA,oBAAoB,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,gBAAgB,CAAC,CAAC;AAGrE,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,wBAAwB,CAAC,CAAC;AACrF,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC,GAAG;IAC7F,IAAI,EAAE,UAAU,CAAC;CACpB,CAAC;AACF,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,uBAAuB,CAAC,CAAC;AACnF,MAAM,MAAM,0BAA0B,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,iCAAiC,CAAC,CAAC;AAClG,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,wBAAwB,CAAC,EAAE,qBAAqB,CAAC,GAAG;IAChH,mBAAmB,EAAE,UAAU,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,yBAAyB,CAAC,CAAC;AAGvF,MAAM,MAAM,gBAAgB,GACtB,oBAAoB,GACpB,qBAAqB,GACrB,0BAA0B,GAC1B,uBAAuB,GACvB,sBAAsB,GACtB,sBAAsB,CAAC;AAE7B,MAAM,MAAM,sBAAsB,GAAG,sBAAsB,GAAG,oBAAoB,GAAG,sBAAsB,CAAC;AAE5G,MAAM,MAAM,8BAA8B,GAAG,oBAAoB,GAAG,sBAAsB,CAAC;AAE3F,MAAM,MAAM,sBAAsB,GAC5B,uBAAuB,GACvB,qBAAqB,GACrB,oBAAoB,GACpB,0BAA0B,CAAC;AAEjC,MAAM,MAAM,8BAA8B,GAAG,qBAAqB,GAAG,oBAAoB,GAAG,0BAA0B,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/client-session-manager/types.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,MAAM,MAAM,kBAAkB,GAAG,IAAI,CACjC,UAAU,CAAC,SAAS,CAAC,CAAC,oBAAoB,CAAC,EAC3C,sBAAsB,GAAG,UAAU,GAAG,MAAM,CAC/C,GAAG;IACA,oBAAoB,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,gBAAgB,CAAC,CAAC;AAGrE,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,wBAAwB,CAAC,CAAC;AACrF,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC,GAAG;IAC7F,IAAI,EAAE,UAAU,CAAC;CACpB,CAAC;AACF,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,uBAAuB,CAAC,CAAC;AACnF,MAAM,MAAM,0BAA0B,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,iCAAiC,CAAC,CAAC;AAClG,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,wBAAwB,CAAC,EAAE,qBAAqB,CAAC,GAAG;IAChH,mBAAmB,EAAE,UAAU,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,yBAAyB,CAAC,CAAC;AAGvF,MAAM,MAAM,gBAAgB,GACtB,oBAAoB,GACpB,qBAAqB,GACrB,0BAA0B,GAC1B,uBAAuB,GACvB,sBAAsB,GACtB,sBAAsB,CAAC;AAE7B,MAAM,MAAM,sBAAsB,GAAG,sBAAsB,GAAG,oBAAoB,GAAG,sBAAsB,CAAC;AAE5G,MAAM,MAAM,8BAA8B,GAAG,oBAAoB,GAAG,sBAAsB,CAAC;AAE3F,MAAM,MAAM,sBAAsB,GAC5B,uBAAuB,GACvB,qBAAqB,GACrB,oBAAoB,GACpB,0BAA0B,CAAC;AAEjC,MAAM,MAAM,8BAA8B,GAAG,qBAAqB,GAAG,oBAAoB,GAAG,0BAA0B,CAAC"}

package/dist-transformer/coming-soon.d.ts

@@ -1,7 +1,5 @@
 import type { FrameContext } from './warpc/frame-context/frame-ctx.js';
-import type { ToolModeStrings } from './agentica/common.js';
 declare enum Feature {
-    JSON_MODE = "JSON mode",
     ENUM_VALUES = "Enum support",
     FUTURE_VALUES = "Promises and futures",
     LOCAL_FILE_ACCESS = "Local file access",
@@ -9,11 +7,9 @@ declare enum Feature {
     NUMERIC_RANGES = "Numeric range objects",
     BINARY_BUFFERS = "Binary buffer objects",
     URL_OBJECTS = "URL objects",
-    JSON_BASE_EXCEPTIONS = "Richer exceptions in JSON mode",
     CUSTOM_EXCEPTIONS = "Custom exceptions",
     TYPE = "Type",
     TYPE_CONSTRUCTORS = "Type constructor",
-    ARBITRARY = "Arbitrary",
     VIRTUALIZATION = "Virtualization",
     UNSUPPORTED_BUILTIN_CLASS = "Unsupported builtin class",
     GENERATORS = "Generators",
@@ -22,23 +18,16 @@ declare enum Feature {
 }
 export declare class ComingSoon extends Error {
     feature: Feature;
-    mode?: ToolModeStrings;
     detail?: string;
-    constructor(feature: Feature, mode?: ToolModeStrings, detail?: string);
-}
-export declare class TryCodeMode extends Error {
-    feature: Feature;
-    detail: string;
     constructor(feature: Feature, detail?: string);
 }
-export declare const validateFeature: (thing: any, mode?: ToolModeStrings) => void;
-export declare const constructorTypes: (mode?: ToolModeStrings) => ComingSoon;
-export declare const unsupportedBultinClass: (className: string, mode?: ToolModeStrings) => ComingSoon;
-export declare const unsupportedEnum: (enumName: string, mode?: ToolModeStrings) => ComingSoon;
-export declare const interfaceReturnType: (mode?: ToolModeStrings) => ComingSoon;
-export declare const intersectionReturnType: (mode?: ToolModeStrings) => ComingSoon;
-export declare const validateReturnType: (returnType: any, context: FrameContext, mode?: ToolModeStrings) => void;
-export declare const throwNoJsonMode: () => never;
+export declare const validateFeature: (thing: any) => void;
+export declare const constructorTypes: () => ComingSoon;
+export declare const unsupportedBultinClass: (className: string) => ComingSoon;
+export declare const unsupportedEnum: (enumName: string) => ComingSoon;
+export declare const interfaceReturnType: () => ComingSoon;
+export declare const intersectionReturnType: () => ComingSoon;
+export declare const validateReturnType: (returnType: any, context: FrameContext) => void;
 export declare const throwNoVirtualization: () => never;
 export declare const throwNoBareFutures: () => never;
 export default ComingSoon;

package/dist-transformer/coming-soon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coming-soon.d.ts","sourceRoot":"","sources":["../src/coming-soon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAIxD,aAAK,OAAO;IACR,SAAS,cAAc;IACvB,WAAW,iBAAiB;IAC5B,aAAa,yBAAyB;IACtC,iBAAiB,sBAAsB;IACvC,kBAAkB,8BAA8B;IAChD,cAAc,0BAA0B;IACxC,cAAc,0BAA0B;IACxC,WAAW,gBAAgB;IAC3B,oBAAoB,mCAAmC;IACvD,iBAAiB,sBAAsB;IACvC,IAAI,SAAS;IACb,iBAAiB,qBAAqB;IACtC,SAAS,cAAc;IACvB,cAAc,mBAAmB;IACjC,yBAAyB,8BAA8B;IACvD,UAAU,eAAe;IACzB,qBAAqB,6BAA6B;IAClD,wBAAwB,gCAAgC;CAC3D;AAED,qBAAa,UAAW,SAAQ,KAAK;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;gBAEJ,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,eAAe,EAAE,MAAM,GAAE,MAAW;CAM5E;AAED,qBAAa,WAAY,SAAQ,KAAK;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;gBAEH,OAAO,EAAE,OAAO,EAAE,MAAM,GAAE,MAAW;CAKpD;AAwDD,eAAO,MAAM,eAAe,GAAI,OAAO,GAAG,EAAE,OAAM,eAAwB,KAAG,IAmD5E,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAM,eAAwB,KAAG,UAEjE,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,WAAW,MAAM,EAAE,OAAM,eAAwB,KAAG,UAE1F,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,EAAE,OAAM,eAAwB,KAAG,UAMlF,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,OAAM,eAAwB,KAAG,UAEpE,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,OAAM,eAAwB,KAAG,UAEvE,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,YAAY,GAAG,EAAE,SAAS,YAAY,EAAE,OAAM,eAAwB,KAAG,IAqC3G,CAAC;AAEF,eAAO,MAAM,eAAe,aAE3B,CAAC;AAEF,eAAO,MAAM,qBAAqB,aAEjC,CAAC;AAEF,eAAO,MAAM,kBAAkB,aAE9B,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"coming-soon.d.ts","sourceRoot":"","sources":["../src/coming-soon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAIpE,aAAK,OAAO;IACR,WAAW,iBAAiB;IAC5B,aAAa,yBAAyB;IACtC,iBAAiB,sBAAsB;IACvC,kBAAkB,8BAA8B;IAChD,cAAc,0BAA0B;IACxC,cAAc,0BAA0B;IACxC,WAAW,gBAAgB;IAC3B,iBAAiB,sBAAsB;IACvC,IAAI,SAAS;IACb,iBAAiB,qBAAqB;IACtC,cAAc,mBAAmB;IACjC,yBAAyB,8BAA8B;IACvD,UAAU,eAAe;IACzB,qBAAqB,6BAA6B;IAClD,wBAAwB,gCAAgC;CAC3D;AAED,qBAAa,UAAW,SAAQ,KAAK;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;gBAEJ,OAAO,EAAE,OAAO,EAAE,MAAM,GAAE,MAAW;CAKpD;AAwDD,eAAO,MAAM,eAAe,GAAI,OAAO,GAAG,KAAG,IA8C5C,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAO,UAEnC,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,WAAW,MAAM,KAAG,UAE1D,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,KAAG,UAKlD,CAAC;AAEF,eAAO,MAAM,mBAAmB,QAAO,UAEtC,CAAC;AAEF,eAAO,MAAM,sBAAsB,QAAO,UAEzC,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,YAAY,GAAG,EAAE,SAAS,YAAY,KAAG,IAqC3E,CAAC;AAEF,eAAO,MAAM,qBAAqB,aAEjC,CAAC;AAEF,eAAO,MAAM,kBAAkB,aAE9B,CAAC;AAEF,eAAe,UAAU,CAAC"}