@symbolica/agentica 0.2.11-rc

package/dist-transformer/agentica-client/agentica-client.js

@@ -0,0 +1,129 @@
+import { ClientSessionManager } from '../client-session-manager/client-session-manager.js';
+import { createLogger } from '../logging/index.js';
+import { version } from '../version.js';
+import { httpToWs } from './utils.js';
+import { ServerError } from '../errors/index.js';
+const logger = createLogger('agentica-client');
+/**
+ * Agentica client for managing sandbox lifecycle and session management.
+ */
+export class Agentica {
+    constructor(baseUrl, apiKey) {
+        this.keepaliveTimers = new Map();
+        this.sessionManager = null;
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    /**
+     * Create HTTP client with proper headers and base URL.
+     */
+    async createHttpClient() {
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+            'X-Protocol': `typescript/${version}`,
+        };
+        return {
+            fetch: (url, init) => {
+                let urlStr;
+                if (typeof url === 'string') {
+                    urlStr = url;
+                }
+                else if (url instanceof Request) {
+                    urlStr = url.url;
+                }
+                else {
+                    urlStr = url.toString();
+                }
+                const fullUrl = urlStr.startsWith('http') ? urlStr : `${this.baseUrl}${urlStr}`;
+                return fetch(fullUrl, {
+                    ...init,
+                    headers: {
+                        ...headers,
+                        ...init?.headers,
+                    },
+                });
+            },
+        };
+    }
+    /**
+     * Create a session manager by provisioning a sandbox.
+     */
+    async createSessionManager() {
+        // Each client has one session manager
+        if (this.sessionManager) {
+            return this.sessionManager;
+        }
+        const httpClient = await this.createHttpClient();
+        // Create sandbox
+        const response = await httpClient.fetch('/sandbox', {
+            method: 'POST',
+            body: JSON.stringify({}),
+        });
+        if (!response.ok) {
+            throw new ServerError(`Failed to create sandbox: ${response.status} "${await response.text()}"`);
+        }
+        const responseData = await response.json();
+        const sandboxId = responseData.sandbox_id;
+        const sandboxUrl = responseData.http_url || `${this.baseUrl}/sb-${sandboxId}`;
+        const keepaliveIntervalS = responseData.keepalive_interval_s;
+        logger.debug(`Created sandbox ${sandboxId} with keepalive interval ${keepaliveIntervalS}s`);
+        const sessionManager = new ClientSessionManager({ apiKey: this.apiKey });
+        sessionManager.setEndpoints(sandboxUrl, httpToWs(sandboxUrl));
+        // Start keepalive timer
+        this.startKeepalive(sandboxId, keepaliveIntervalS);
+        // Store cleanup callback
+        sessionManager.__cleanup = () => this.deleteSandbox(sandboxId);
+        this.sessionManager = sessionManager;
+        return sessionManager;
+    }
+    /**
+     * Start keepalive timer for a sandbox.
+     */
+    startKeepalive(sandboxId, intervalS) {
+        const timer = setInterval(async () => {
+            try {
+                const httpClient = await this.createHttpClient();
+                await httpClient.fetch(`/sandbox/${sandboxId}/keepalive`, {
+                    method: 'POST',
+                });
+            }
+            catch (error) {
+                logger.warn(`Keepalive request failed for sandbox ${sandboxId} with error:`, error);
+            }
+        }, intervalS * 1000);
+        this.keepaliveTimers.set(sandboxId, timer);
+        if (typeof timer === 'object' && 'unref' in timer) {
+            timer.unref();
+        }
+    }
+    /**
+     * Delete a sandbox synchronously.
+     */
+    async deleteSandbox(sandboxId) {
+        try {
+            const httpClient = await this.createHttpClient();
+            await httpClient.fetch(`/sandbox/${sandboxId}`, {
+                method: 'DELETE',
+            });
+            const timer = this.keepaliveTimers.get(sandboxId);
+            if (timer) {
+                clearInterval(timer);
+                this.keepaliveTimers.delete(sandboxId);
+            }
+        }
+        catch (error) {
+            logger.warn(`Failed to delete sandbox ${sandboxId} with error:`, error);
+        }
+    }
+    /**
+     * Cleanup all resources.
+     */
+    async close() {
+        // Clear all keepalive timers
+        for (const [_sandboxId, timer] of this.keepaliveTimers) {
+            clearInterval(timer);
+        }
+        this.keepaliveTimers.clear();
+    }
+}

package/dist-transformer/agentica-client/global-csm.d.ts

@@ -0,0 +1,20 @@
+import { ClientSessionManager } from '../client-session-manager/client-session-manager.js';
+/**
+ * Environment-based connection management
+ * - If AGENTICA_API_KEY is set, use the platform service
+ * - Otherwise, use the session manager directly
+ */
+export declare function getGlobalSessionManager(): Promise<ClientSessionManager>;
+/**
+ * Get uid from iid
+ */
+export declare function getUidForIid(iid: string, sm?: ClientSessionManager): string | undefined;
+/**
+ * Sentinel for agent call id (substituted at runtime)
+ */
+export declare const AGENTICA_CALL_ID = "AGENTICA_AGENT_CALL_ID";
+/**
+ * Sentinel for agent's elapsed time (substituted at runtime)
+ */
+export declare const AGENTICA_ELAPSED_TIME = "AGENTICA_AGENT_ELAPSED_TIME";
+//# sourceMappingURL=global-csm.d.ts.map

package/dist-transformer/agentica-client/global-csm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-csm.d.ts","sourceRoot":"","sources":["../../src/agentica-client/global-csm.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,gDAAgD,CAAC;AAWtF;;;;GAIG;AACH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAqB7E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,oBAAoB,GAAG,MAAM,GAAG,SAAS,CAEvF;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,2BAA2B,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,qBAAqB,gCAAgC,CAAC"}

package/dist-transformer/agentica-client/global-csm.js

@@ -0,0 +1,46 @@
+import { getAgenticaApiKey, getAgenticaBaseUrl, getSessionManagerBaseUrl } from '../bundlers/utils.js';
+import { ClientSessionManager } from '../client-session-manager/client-session-manager.js';
+import { createLogger } from '../logging/index.js';
+import { Agentica } from './agentica-client.js';
+import { httpToWs } from './utils.js';
+const logger = createLogger('global-csm');
+let GLOBAL_AGENTICA_SM = null;
+const DEFAULT_BASE_URL = 'https://api.platform.symbolica.ai';
+/**
+ * Environment-based connection management
+ * - If AGENTICA_API_KEY is set, use the platform service
+ * - Otherwise, use the session manager directly
+ */
+export async function getGlobalSessionManager() {
+    if (GLOBAL_AGENTICA_SM) {
+        return GLOBAL_AGENTICA_SM;
+    }
+    const apiKey = getAgenticaApiKey();
+    if (apiKey) {
+        logger.debug('Found API key in environment');
+        const baseUrl = getAgenticaBaseUrl() || DEFAULT_BASE_URL;
+        logger.debug(`Using platform service, base_url=${baseUrl}`);
+        const client = new Agentica(baseUrl, apiKey);
+        GLOBAL_AGENTICA_SM = await client.createSessionManager();
+        return GLOBAL_AGENTICA_SM;
+    }
+    const sessionManagerBaseUrl = getSessionManagerBaseUrl() || 'http://localhost:2345';
+    logger.debug(`Using session manager, base_url=${sessionManagerBaseUrl}`);
+    GLOBAL_AGENTICA_SM = new ClientSessionManager({});
+    GLOBAL_AGENTICA_SM.setEndpoints(sessionManagerBaseUrl, httpToWs(sessionManagerBaseUrl));
+    return GLOBAL_AGENTICA_SM;
+}
+/**
+ * Get uid from iid
+ */
+export function getUidForIid(iid, sm) {
+    return (sm ?? GLOBAL_AGENTICA_SM)?.getUidForIid(iid);
+}
+/**
+ * Sentinel for agent call id (substituted at runtime)
+ */
+export const AGENTICA_CALL_ID = 'AGENTICA_AGENT_CALL_ID';
+/**
+ * Sentinel for agent's elapsed time (substituted at runtime)
+ */
+export const AGENTICA_ELAPSED_TIME = 'AGENTICA_AGENT_ELAPSED_TIME';

package/dist-transformer/agentica-client/index.d.ts

@@ -0,0 +1,3 @@
+export { Agentica } from './agentica-client.js';
+export { getGlobalSessionManager as getGlobalCsm, getUidForIid } from './global-csm.js';
+//# sourceMappingURL=index.d.ts.map

package/dist-transformer/agentica-client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agentica-client/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,uBAAuB,IAAI,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC"}

package/dist-transformer/agentica-client/index.js

@@ -0,0 +1,2 @@
+export { Agentica } from './agentica-client.js';
+export { getGlobalSessionManager as getGlobalCsm, getUidForIid } from './global-csm.js';

package/dist-transformer/agentica-client/utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert HTTP URL to WebSocket URL.
+ */
+export declare function httpToWs(url: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist-transformer/agentica-client/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/agentica-client/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE5C"}

package/dist-transformer/agentica-client/utils.js

@@ -0,0 +1,6 @@
+/**
+ * Convert HTTP URL to WebSocket URL.
+ */
+export function httpToWs(url) {
+    return url.replace('http://', 'ws://').replace('https://', 'wss://');
+}

package/dist-transformer/bundlers/utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Bundler-aware environment variable access.
+ *
+ * Supports:
+ * - Node.js: process.env.VAR
+ * - Vite: import.meta.env.VITE_VAR (browser) or process.env.VAR (SSR)
+ * - Next.js: process.env.NEXT_PUBLIC_VAR (client) or process.env.VAR (server)
+ * - Webpack: process.env.VAR (replaced via DefinePlugin at build time)
+ * - Rollup: process.env.VAR (replaced via @rollup/plugin-replace at build time)
+ * - esbuild: process.env.VAR (replaced via define option at build time)
+ *
+ * Vite and Next.js require completely static access with no intermediate variables.
+ */
+export declare function getAgenticaApiKey(): string | undefined;
+export declare function getAgenticaBaseUrl(): string | undefined;
+export declare function getSessionManagerBaseUrl(): string | undefined;
+export declare function getLogLevel(): string | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/dist-transformer/bundlers/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/bundlers/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,wBAAgB,iBAAiB,IAAI,MAAM,GAAG,SAAS,CAQtD;AAED,wBAAgB,kBAAkB,IAAI,MAAM,GAAG,SAAS,CAQvD;AAED,wBAAgB,wBAAwB,IAAI,MAAM,GAAG,SAAS,CAQ7D;AAED,wBAAgB,WAAW,IAAI,MAAM,GAAG,SAAS,CAQhD"}

package/dist-transformer/bundlers/utils.js

@@ -0,0 +1,49 @@
+/**
+ * Bundler-aware environment variable access.
+ *
+ * Supports:
+ * - Node.js: process.env.VAR
+ * - Vite: import.meta.env.VITE_VAR (browser) or process.env.VAR (SSR)
+ * - Next.js: process.env.NEXT_PUBLIC_VAR (client) or process.env.VAR (server)
+ * - Webpack: process.env.VAR (replaced via DefinePlugin at build time)
+ * - Rollup: process.env.VAR (replaced via @rollup/plugin-replace at build time)
+ * - esbuild: process.env.VAR (replaced via define option at build time)
+ *
+ * Vite and Next.js require completely static access with no intermediate variables.
+ */
+export function getAgenticaApiKey() {
+    if (typeof import.meta !== 'undefined' && import.meta.env?.VITE_AGENTICA_API_KEY) {
+        return import.meta.env.VITE_AGENTICA_API_KEY;
+    }
+    if (typeof process !== 'undefined') {
+        return process.env.NEXT_PUBLIC_AGENTICA_API_KEY || process.env.AGENTICA_API_KEY;
+    }
+    return undefined;
+}
+export function getAgenticaBaseUrl() {
+    if (typeof import.meta !== 'undefined' && import.meta.env?.VITE_AGENTICA_BASE_URL) {
+        return import.meta.env.VITE_AGENTICA_BASE_URL;
+    }
+    if (typeof process !== 'undefined') {
+        return process.env.NEXT_PUBLIC_AGENTICA_BASE_URL || process.env.AGENTICA_BASE_URL;
+    }
+    return undefined;
+}
+export function getSessionManagerBaseUrl() {
+    if (typeof import.meta !== 'undefined' && import.meta.env?.VITE_S_M_BASE_URL) {
+        return import.meta.env.VITE_S_M_BASE_URL;
+    }
+    if (typeof process !== 'undefined') {
+        return process.env.NEXT_PUBLIC_S_M_BASE_URL || process.env.S_M_BASE_URL;
+    }
+    return undefined;
+}
+export function getLogLevel() {
+    if (typeof import.meta !== 'undefined' && import.meta.env?.VITE_TS_LOG_LEVEL) {
+        return import.meta.env.VITE_TS_LOG_LEVEL;
+    }
+    if (typeof process !== 'undefined') {
+        return process.env.NEXT_PUBLIC_TS_LOG_LEVEL || process.env.TS_LOG_LEVEL;
+    }
+    return undefined;
+}

package/dist-transformer/client-session-manager/at-exit.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Platform-agnostic cleanup handler for async resources at shutdown.
+ *
+ * Supports:
+ * - Node.js: process.on('SIGTERM', 'SIGINT', 'beforeExit')
+ * - Browser: window.addEventListener('beforeunload')
+ */
+type AsyncCleanupCallback = () => Promise<void>;
+type SyncCleanupCallback = () => void;
+/**
+ * Register cleanup callbacks to be called at process/page shutdown.
+ * @param obj - The object to track (weak reference)
+ * @param asyncCallback - Async cleanup function (used when event loop is healthy)
+ * @param syncFallback - Optional sync fallback (used when async fails)
+ */
+export declare function registerCleanup(obj: any, asyncCallback: AsyncCleanupCallback, syncFallback?: SyncCleanupCallback): void;
+export declare const registerAsyncCleanup: typeof registerCleanup;
+export {};
+//# sourceMappingURL=at-exit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"at-exit.d.ts","sourceRoot":"","sources":["../../src/client-session-manager/at-exit.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,KAAK,oBAAoB,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAChD,KAAK,mBAAmB,GAAG,MAAM,IAAI,CAAC;AAYtC;;;;;GAKG;AACH,wBAAgB,eAAe,CAC3B,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,oBAAoB,EACnC,YAAY,CAAC,EAAE,mBAAmB,GACnC,IAAI,CAcN;AAGD,eAAO,MAAM,oBAAoB,wBAAkB,CAAC"}

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

@@ -0,0 +1,140 @@
+/**
+ * Platform-agnostic cleanup handler for async resources at shutdown.
+ *
+ * Supports:
+ * - Node.js: process.on('SIGTERM', 'SIGINT', 'beforeExit')
+ * - Browser: window.addEventListener('beforeunload')
+ */
+import { createLogger } from '../logging/index.js';
+const logger = createLogger('at-exit');
+const cleanupEntries = [];
+let cleanupDone = false;
+const knownResources = new WeakSet();
+/**
+ * Register cleanup callbacks to be called at process/page shutdown.
+ * @param obj - The object to track (weak reference)
+ * @param asyncCallback - Async cleanup function (used when event loop is healthy)
+ * @param syncFallback - Optional sync fallback (used when async fails)
+ */
+export function registerCleanup(obj, asyncCallback, syncFallback) {
+    if (knownResources.has(obj)) {
+        logger.warn(`Resource ${obj.constructor?.name || obj} already registered for cleanup. Ignoring.`);
+        return;
+    }
+    knownResources.add(obj);
+    cleanupEntries.push({
+        objRef: new WeakRef(obj),
+        asyncCallback,
+        syncFallback,
+    });
+    registerExitHandlers();
+}
+// Backwards compatibility
+export const registerAsyncCleanup = registerCleanup;
+let exitHandlersRegistered = false;
+function registerExitHandlers() {
+    if (exitHandlersRegistered) {
+        return;
+    }
+    const isNode = typeof process !== 'undefined' && process.versions?.node;
+    const isBrowser = typeof window !== 'undefined';
+    if (isNode) {
+        // SIGINT (Ctrl+C) - run async cleanup, then exit
+        process.on('SIGINT', async () => {
+            logger.debug('SIGINT received (Ctrl+C), running cleanup');
+            await runAsyncCleanup();
+            process.exit(130);
+        });
+        // SIGTERM - run async cleanup, then exit
+        process.on('SIGTERM', async () => {
+            logger.debug('SIGTERM received, running cleanup');
+            await runAsyncCleanup();
+            process.exit(128 + 15);
+        });
+        // beforeExit - runs when event loop is empty, async still works
+        process.on('beforeExit', async () => {
+            logger.debug('beforeExit event, running cleanup');
+            await runAsyncCleanup();
+        });
+        // exit - sync only, last resort
+        process.on('exit', () => {
+            logger.debug('exit event, running sync fallback cleanup');
+            runSyncFallback();
+        });
+    }
+    else if (isBrowser) {
+        // Browser: beforeunload is our best bet
+        window.addEventListener('beforeunload', () => {
+            logger.debug('Browser beforeunload, running sync cleanup');
+            runSyncFallback();
+        });
+        // Page hidden - precautionary cleanup
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'hidden') {
+                logger.debug('Page hidden, running sync cleanup as precaution');
+                runSyncFallback();
+            }
+        });
+    }
+    exitHandlersRegistered = true;
+    logger.debug('Cleanup handlers registered');
+}
+async function runAsyncCleanup() {
+    if (cleanupDone) {
+        return;
+    }
+    const activeEntries = cleanupEntries.filter((e) => e.objRef.deref() !== undefined);
+    if (activeEntries.length === 0) {
+        cleanupDone = true;
+        return;
+    }
+    logger.debug(`Running async cleanup for ${activeEntries.length} resource(s)`);
+    for (const entry of activeEntries) {
+        const obj = entry.objRef.deref();
+        if (obj) {
+            try {
+                await entry.asyncCallback();
+                logger.debug(`Cleanup completed for ${obj.constructor?.name || 'unknown'}`);
+            }
+            catch (error) {
+                logger.error(`Async cleanup failed for ${obj.constructor?.name}:`, error);
+                // Try sync fallback
+                if (entry.syncFallback) {
+                    try {
+                        entry.syncFallback();
+                    }
+                    catch (syncError) {
+                        logger.error(`Sync fallback also failed:`, syncError);
+                    }
+                }
+            }
+        }
+    }
+    cleanupEntries.length = 0;
+    cleanupDone = true;
+}
+function runSyncFallback() {
+    if (cleanupDone) {
+        return;
+    }
+    const activeEntries = cleanupEntries.filter((e) => e.objRef.deref() !== undefined);
+    if (activeEntries.length === 0) {
+        cleanupDone = true;
+        return;
+    }
+    logger.debug(`Running sync fallback cleanup for ${activeEntries.length} resource(s)`);
+    for (const entry of activeEntries) {
+        const obj = entry.objRef.deref();
+        if (obj && entry.syncFallback) {
+            try {
+                entry.syncFallback();
+                logger.debug(`Sync cleanup completed for ${obj.constructor?.name || 'unknown'}`);
+            }
+            catch (error) {
+                logger.error(`Sync cleanup failed for ${obj.constructor?.name}:`, error);
+            }
+        }
+    }
+    cleanupEntries.length = 0;
+    cleanupDone = true;
+}

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

@@ -0,0 +1,148 @@
+import type { CreateAgentRequest, PromptTemplate } from './types.js';
+import { Chunk, Usage } from '../agentica/common.js';
+import { type ScopedLogger } from '../logging/index.js';
+/**
+ * Configuration options for ClientSessionManager
+ */
+export interface ClientSessionManagerConfig {
+    /** API key for authentication (optional) */
+    apiKey?: string | null;
+    /** Enable OpenTelemetry logging to send logs to session manager's collector */
+    enableOtelLogging?: boolean;
+}
+export interface AgentInvocationHandle {
+    send_message: (data: Uint8Array) => Promise<void>;
+    recv_message: () => Promise<Uint8Array>;
+    exception: Promise<void>;
+    iid: string;
+}
+export interface InvokeAgentParams {
+    uid: string;
+    warpLocalsPayload: Uint8Array;
+    taskDesc: string | PromptTemplate;
+    streaming: boolean;
+    parentUid?: string;
+    parentIid?: string;
+}
+/**
+ * ClientSessionManager - TypeScript equivalent of the Python ClientSessionManager
+ * Maintains identical structure and method signatures
+ */
+export declare class ClientSessionManager {
+    private websocket;
+    private tasks;
+    private sendQueue;
+    private uidIidRecvQueue;
+    private uidIidException;
+    private matchIid;
+    private iidToUid;
+    private knownUids;
+    private baseHttp;
+    private baseWs;
+    private apiKey;
+    private idIssuer;
+    private uidToLogger;
+    private isStopped;
+    private isStopping;
+    private logger;
+    private sessionSpan;
+    private clientSessionId;
+    private activeConnectionCount;
+    private invocationGuard;
+    constructor(config?: ClientSessionManagerConfig);
+    /**
+     * Increment active connection count and create guard if needed.
+     * The guard is a ref'd interval that keeps the process alive during active connections.
+     */
+    private refConnection;
+    /**
+     * Decrement active connection count and clear guard if no more connections.
+     */
+    private unrefConnection;
+    setEndpoints(baseHttp: string, baseWs: string): void;
+    /**
+     * Register this client session with the server.
+     * Throws an error if registration fails.
+     */
+    private registerSession;
+    /**
+     * Build authentication headers for HTTP requests.
+     */
+    private buildHeaders;
+    /**
+     * Background task for writing messages to WebSocket - matches Python _ws_background_task_writer
+     */
+    private wsBackgroundTaskWriter;
+    /**
+     * Background task for reading messages from WebSocket - matches Python _ws_background_task_reader
+     */
+    private wsBackgroundTaskReader;
+    /**
+     * Ensure WebSocket connection exists, creating it if needed.
+     */
+    private _ensureWebSocketConnection;
+    /**
+     * Initialize per-agent data structures.
+     */
+    private _initAgentState;
+    /**
+     * Create new agent - matches Python new_agent
+     */
+    newAgent(cmar: CreateAgentRequest, parentLogger?: ScopedLogger): Promise<string>;
+    /**
+     * Create new agent invocation - matches Python invoke_agent
+     */
+    invokeAgent(params: InvokeAgentParams, parentLogger?: ScopedLogger): Promise<AgentInvocationHandle>;
+    /**
+     * Echo streaming endpoint
+     */
+    echo(cancelSignal: AbortSignal, uid: string, iid?: string): AsyncGenerator<Chunk, void, unknown>;
+    /**
+     * Fetch logs for a specific agent and optionally a specific invocation.
+     * Matches Python logs() method.
+     */
+    logs(uid: string, iid?: string, params?: Record<string, any>): Promise<Array<Record<string, any>>>;
+    /**
+     * Fetch and calculate usage for a specific invocation.
+     * Handles chat-completions API's cumulative token reporting by subtracting previous totals.
+     *
+     * @param uid - Agent UID
+     * @param iid - Invocation ID
+     * @param lastTotal - Previous cumulative total (for cross-invocation adjustment)
+     * @returns Object containing the usage for this invocation and the new cumulative total
+     */
+    fetchUsage(uid: string, iid: string, lastTotal?: Usage): Promise<{
+        usage: Usage;
+        newTotal: Usage;
+    }>;
+    /**
+     * Check if agent exists - matches Python agent_exists
+     */
+    agentExists(uid: string): boolean;
+    /**
+     * Get uid from iid (used for parent-child agent tracking)
+     */
+    getUidForIid(iid: string): string | undefined;
+    /**
+     * Destroy an agent on the server
+     */
+    destroyAgent(uid: string): Promise<void>;
+    /**
+     * Close a specific agent's resources (does not close the shared WebSocket)
+     */
+    closeAgent(uid: string): Promise<void>;
+    /**
+     * Stop all connections and cleanup resources
+     */
+    stop(): Promise<void>;
+    /**
+     * Close all connections and cleanup resources
+     */
+    close(): Promise<void>;
+}
+declare global {
+    var __AGENTICA_AGENTIC_MANAGER: ClientSessionManager | undefined;
+}
+export declare const __AGENTIC_MANAGER: ClientSessionManager;
+export declare const __AGENTIC_PROTO_VER = "typescript/0.2.11-rc";
+//# sourceMappingURL=client-session-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client-session-manager.d.ts","sourceRoot":"","sources":["../../src/client-session-manager/client-session-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,kBAAkB,EAKlB,cAAc,EACjB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAY,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EAAE,KAAK,YAAY,EAA+B,MAAM,gBAAgB,CAAC;AA0DhF;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACvC,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,+EAA+E;IAC/E,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAGD,MAAM,WAAW,qBAAqB;IAClC,YAAY,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,YAAY,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC;IACxC,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,GAAG,EAAE,MAAM,CAAC;CACf;AAGD,MAAM,WAAW,iBAAiB;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,iBAAiB,EAAE,UAAU,CAAC;IAC9B,QAAQ,EAAE,MAAM,GAAG,cAAc,CAAC;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAUD;;;GAGG;AACH,qBAAa,oBAAoB;IAC7B,OAAO,CAAC,SAAS,CAA8B;IAC/C,OAAO,CAAC,KAAK,CAA2C;IACxD,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,eAAe,CAA8C;IACrE,OAAO,CAAC,eAAe,CAGrB;IACF,OAAO,CAAC,QAAQ,CAAoF;IACpG,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,SAAS,CAAc;IAE/B,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,WAAW,CAAwC;IAC3D,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,WAAW,CAAsD;IAGzE,OAAO,CAAC,eAAe,CAAS;IAGhC,OAAO,CAAC,qBAAqB,CAAa;IAC1C,OAAO,CAAC,eAAe,CAA+C;gBAE1D,MAAM,GAAE,0BAA+B;IAqCnD;;;OAGG;IACH,OAAO,CAAC,aAAa;IAQrB;;OAEG;IACH,OAAO,CAAC,eAAe;IAQvB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAkBpD;;;OAGG;YACW,eAAe;IAqC7B;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;OAEG;YACW,sBAAsB;IAuDpC;;OAEG;YACW,sBAAsB;IAmJpC;;OAEG;YACW,0BAA0B;IAuFxC;;OAEG;IACH,OAAO,CAAC,eAAe;IAYvB;;OAEG;IACG,QAAQ,CAAC,IAAI,EAAE,kBAAkB,EAAE,YAAY,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAsFtF;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,iBAAiB,EAAE,YAAY,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAgGzG;;OAEG;IACI,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,CAAC;IA2KvG;;;OAGG;IACG,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IA8BxG;;;;;;;;OAQG;IACG,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,QAAQ,EAAE,KAAK,CAAA;KAAE,CAAC;IAsBzG;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIjC;;OAEG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI7C;;OAEG;IACG,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiC9C;;OAEG;IACG,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiC5C;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAiE3B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B;AAED,OAAO,CAAC,MAAM,CAAC;IACX,IAAI,0BAA0B,EAAE,oBAAoB,GAAG,SAAS,CAAC;CACpE;AAGD,eAAO,MAAM,iBAAiB,EAAE,oBAE6C,CAAC;AAE9E,eAAO,MAAM,mBAAmB,yBAA0B,CAAC"}