@applica-software-guru/persona-sdk 0.0.1-preview2 → 0.0.1-preview4

package/dist/src/runtime.d.ts

@@ -0,0 +1,21 @@
+import { PropsWithChildren } from 'react';
+import { PersonaConfig, PersonaMessage, PersonaProtocol, PersonaResponse, ProtocolStatus } from './types';
+import { PersonaWebRTCProtocol } from './protocol';
+type PersonaRuntimeContextType = {
+    protocols: PersonaProtocol[];
+    protocolsStatus: Map<string, ProtocolStatus>;
+};
+declare function PersonaRuntimeProvider({ children, ...config }: PropsWithChildren<PersonaConfig>): import("react/jsx-runtime").JSX.Element;
+declare function usePersonaRuntime(): PersonaRuntimeContextType;
+/**
+ * Retrieves a specific protocol instance from the PersonaRuntimeContext.
+ *
+ * @param protocol - The name of the protocol to use.
+ * @returns {PersonaProtocol | null} - The protocol instance or null if not found.
+ * @throws {Error} - If the hook is used outside of a PersonaRuntimeProvider.
+ */
+declare function usePersonaRuntimeProtocol(protocol: string): PersonaProtocol | null;
+declare function usePersonaRuntimeWebRTCProtocol(): PersonaWebRTCProtocol | null;
+export { PersonaRuntimeProvider, usePersonaRuntime, usePersonaRuntimeProtocol, usePersonaRuntimeWebRTCProtocol };
+export type { PersonaMessage, PersonaResponse };
+//# sourceMappingURL=runtime.d.ts.map

package/dist/src/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/runtime.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAoC,iBAAiB,EAA8C,MAAM,OAAO,CAAC;AAExH,OAAO,EACL,aAAa,EACb,cAAc,EACd,eAAe,EAEf,eAAe,EACf,cAAc,EAEf,MAAM,SAAS,CAAC;AAEjB,OAAO,EAGL,qBAAqB,EAItB,MAAM,YAAY,CAAC;AAEpB,KAAK,yBAAyB,GAAG;IAC/B,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC9C,CAAC;AA0IF,iBAAS,sBAAsB,CAAC,EAAE,QAAQ,EAAE,GAAG,MAAM,EAAE,EAAE,iBAAiB,CAAC,aAAa,CAAC,2CAExF;AAED,iBAAS,iBAAiB,IAAI,yBAAyB,CAMtD;AAED;;;;;;GAMG;AACH,iBAAS,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAyB3E;AAED,iBAAS,+BAA+B,IAAI,qBAAqB,GAAG,IAAI,CAEvE;AAED,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,+BAA+B,EAAE,CAAC;AACjH,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,CAAC"}

package/dist/src/runtime.js

@@ -0,0 +1,160 @@
+'use strict';
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, createContext, useContext, useMemo, useRef } from 'react';
+import { useExternalStoreRuntime, AssistantRuntimeProvider } from '@assistant-ui/react';
+import { parseMessages, convertMessage } from './messages';
+import { PersonaRESTProtocol, PersonaWebRTCProtocol, PersonaWebSocketProtocol, } from './protocol';
+const PersonaRuntimeContext = createContext(undefined);
+function PersonaRuntimeProviderInner({ dev = false, protocols: _protocols, logger, children, session: defaultSession = 'new', ...config }) {
+    const [isRunning, setIsRunning] = useState(false);
+    const [messages, setMessages] = useState([]);
+    const [session, setSession] = useState(defaultSession);
+    const [protocolsStatus, setProtocolsStatus] = useState(new Map());
+    const didMount = useRef(false);
+    const protocols = useMemo(() => {
+        if (Array.isArray(_protocols)) {
+            return _protocols;
+        }
+        if (typeof _protocols === 'object' && _protocols !== null) {
+            const baseEndpoint = dev ? 'localhost:8000' : 'persona.applica.guru/api';
+            const baseEndpointProtocol = dev ? 'http' : 'https';
+            const baseWebSocketProtocol = dev ? 'ws' : 'wss';
+            const availableProtocols = Object.keys(_protocols).map((key) => {
+                switch (key) {
+                    case 'rest':
+                        const restConfig = _protocols[key];
+                        if (restConfig === true) {
+                            return new PersonaRESTProtocol({
+                                apiUrl: `${baseEndpointProtocol}://${baseEndpoint}`,
+                                apiKey: config.apiKey,
+                                agentId: config.agentId,
+                                logger,
+                            });
+                        }
+                        return new PersonaRESTProtocol(restConfig);
+                    case 'webrtc':
+                        const webrtcConfig = _protocols[key];
+                        if (webrtcConfig === true) {
+                            return new PersonaWebRTCProtocol({
+                                webrtcUrl: `${baseWebSocketProtocol}://${baseEndpoint}/webrtc`,
+                                apiKey: config.apiKey,
+                                agentId: config.agentId,
+                                logger,
+                            });
+                        }
+                        return new PersonaWebRTCProtocol(webrtcConfig);
+                    case 'websocket':
+                        const websocketConfig = _protocols[key];
+                        if (websocketConfig === true) {
+                            return new PersonaWebSocketProtocol({
+                                webSocketUrl: `${baseWebSocketProtocol}://${baseEndpoint}/websocket`,
+                                apiKey: config.apiKey,
+                                agentId: config.agentId,
+                                logger,
+                            });
+                        }
+                        return new PersonaWebSocketProtocol(websocketConfig);
+                    default:
+                        throw new Error(`Unknown protocol: ${key}`);
+                }
+            });
+            return availableProtocols;
+        }
+        throw new Error('Invalid protocols configuration');
+    }, []);
+    useEffect(() => {
+        if (didMount.current)
+            return;
+        didMount.current = true;
+        logger?.debug('Initializing protocols: ', protocols.map((protocol) => protocol.getName()));
+        protocols.forEach((protocol) => {
+            protocol.setSession(session);
+            protocol.clearListeners();
+            protocol.addStatusChangeListener((status) => {
+                logger?.debug(`${protocol.getName()} has notified new status: ${status}`);
+                protocolsStatus.set(protocol.getName(), status);
+                setProtocolsStatus(new Map(protocolsStatus));
+            });
+            protocol.addMessageListener((message) => {
+                setMessages((currentConversation) => parseMessages([...currentConversation, ...[{ ...message, protocol: protocol.getName() }]]));
+            });
+            if (protocol.autostart && protocol.status === 'disconnected') {
+                logger?.debug(`Connecting to protocol: ${protocol.getName()}`);
+                protocol.connect(session);
+            }
+        });
+    }, [session, protocols, logger, protocolsStatus]);
+    const onNew = async (message) => {
+        if (message.content[0]?.type !== 'text')
+            throw new Error('Only text messages are supported');
+        const input = message.content[0].text;
+        setMessages((currentConversation) => [...currentConversation, { role: 'user', type: 'text', text: input }]);
+        setIsRunning(true);
+        const protocol = protocols.sort((a, b) => b.getPriority() - a.getPriority()).find((protocol) => protocol.status === 'connected');
+        await protocol?.send(input);
+        setIsRunning(false);
+    };
+    const onCancel = useCallback(() => {
+        setIsRunning(false);
+        setMessages([]);
+        setSession('new');
+        return Promise.resolve();
+    }, []);
+    const onReload = useCallback(() => {
+        return Promise.resolve();
+    }, []);
+    const runtime = useExternalStoreRuntime({
+        isRunning,
+        messages,
+        convertMessage,
+        onNew,
+        onCancel,
+        onReload,
+    });
+    return (_jsx(PersonaRuntimeContext.Provider, { value: { protocols, protocolsStatus }, children: _jsx(AssistantRuntimeProvider, { runtime: runtime, children: children }) }));
+}
+function PersonaRuntimeProvider({ children, ...config }) {
+    return _jsx(PersonaRuntimeProviderInner, { ...config, children: children });
+}
+function usePersonaRuntime() {
+    const context = useContext(PersonaRuntimeContext);
+    if (!context) {
+        throw new Error('usePersonaRuntime must be used within a PersonaRuntimeProvider');
+    }
+    return context;
+}
+/**
+ * Retrieves a specific protocol instance from the PersonaRuntimeContext.
+ *
+ * @param protocol - The name of the protocol to use.
+ * @returns {PersonaProtocol | null} - The protocol instance or null if not found.
+ * @throws {Error} - If the hook is used outside of a PersonaRuntimeProvider.
+ */
+function usePersonaRuntimeProtocol(protocol) {
+    const context = useContext(PersonaRuntimeContext);
+    if (!context) {
+        throw new Error('usePersonaRuntimeProtocol must be used within a PersonaRuntimeProvider');
+    }
+    const protocolInstance = context.protocols.find((p) => p.getName() === protocol);
+    if (!protocolInstance) {
+        return null;
+    }
+    const status = context.protocolsStatus.get(protocolInstance.getName());
+    return {
+        ...protocolInstance,
+        connect: protocolInstance.connect.bind(protocolInstance),
+        disconnect: protocolInstance.disconnect.bind(protocolInstance),
+        send: protocolInstance.send.bind(protocolInstance),
+        setSession: protocolInstance.setSession.bind(protocolInstance),
+        addStatusChangeListener: protocolInstance.addStatusChangeListener.bind(protocolInstance),
+        addMessageListener: protocolInstance.addMessageListener.bind(protocolInstance),
+        getName: protocolInstance.getName.bind(protocolInstance),
+        getPriority: protocolInstance.getPriority.bind(protocolInstance),
+        status: status || protocolInstance.status,
+    };
+}
+function usePersonaRuntimeWebRTCProtocol() {
+    return usePersonaRuntimeProtocol('webrtc');
+}
+export { PersonaRuntimeProvider, usePersonaRuntime, usePersonaRuntimeProtocol, usePersonaRuntimeWebRTCProtocol };

package/dist/src/types.d.ts

@@ -0,0 +1,79 @@
+import { PersonaLogger } from './logging';
+import { ReactNode } from 'react';
+export type ReadonlyJSONObject = {
+    readonly [key: string]: string | number | boolean | null | ReadonlyJSONObject | ReadonlyArray<ReadonlyJSONObject>;
+};
+export type FunctionCall = {
+    id?: string;
+    name: string;
+    args: ReadonlyJSONObject;
+};
+export type FunctionResponse = {
+    name: string;
+    result: unknown;
+    function_call_id: string;
+};
+export type PersonaMessage = {
+    id?: string | null;
+    protocol?: string;
+    text: string;
+    type: 'reasoning' | 'text';
+    role: 'user' | 'assistant' | 'function';
+    sessionId?: string;
+    finishReason?: 'stop' | 'function_call';
+    functionCalls?: FunctionCall[];
+    functionResponse?: FunctionResponse;
+};
+export type ModelResponse = {
+    messages: PersonaMessage[];
+};
+export type PersonaResponse = {
+    sessionId: string;
+    response: ModelResponse;
+};
+export type PersonaBaseConfig = {
+    logger?: PersonaLogger;
+};
+export type PersonaWebRTCConfig = PersonaBaseConfig & {
+    webrtcUrl: string;
+    iceServers?: RTCIceServer[];
+    onDataMessage?: (msg: MessageEvent) => void;
+};
+export type Session = string | null | undefined;
+export type Message = string;
+export type MessageListenerCallback = (message: PersonaMessage) => void;
+export type StatusChangeCallback = (status: ProtocolStatus) => void;
+export type ProtocolStatus = 'disconnected' | 'connecting' | 'connected';
+export type PersonaProtocolBaseConfig = {
+    logger?: PersonaLogger;
+    apiKey: string;
+    agentId: string;
+};
+export interface PersonaProtocol {
+    status: ProtocolStatus;
+    autostart: boolean;
+    getName: () => string;
+    getPriority: () => number;
+    connect: (session?: Session) => Promise<Session>;
+    disconnect: () => Promise<void>;
+    setSession: (session: Session) => Promise<void>;
+    send: (message: Message) => Promise<void>;
+    clearListeners: () => void;
+    addStatusChangeListener: (callback: StatusChangeCallback) => void;
+    addMessageListener: (callback: MessageListenerCallback) => void;
+}
+export type PersonaConfig = PersonaBaseConfig & PersonaProtocolBaseConfig & {
+    /**
+     * In 'dev' mode the endpoint is set to localhost:8000,
+     * use it only for development purposes.
+     */
+    dev?: boolean;
+    session?: Session;
+    children: ReactNode;
+    protocols: PersonaProtocol[] | {
+        rest?: PersonaProtocolBaseConfig | true;
+        webrtc?: PersonaProtocolBaseConfig | true;
+        websocket?: PersonaProtocolBaseConfig | true;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@applica-software-guru/persona-sdk",
   "private": false,
-  "version": "0.0.1-preview2",
+  "version": "0.0.1-preview4",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -19,8 +19,6 @@
     "@types/inflection": "^1.13.2",
     "@types/lodash": "^4.17.15",
     "@types/node": "^20.12.13",
-    "@types/react": "^18.3.3",
-    "@types/react-dom": "^18.3.0",
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
     "@vitejs/plugin-react": "^4.3.0",
@@ -58,8 +56,8 @@
     "tailwindcss": "^4.0.17"
   },
   "peerDependencies": {
-    "react": ">=19",
-    "react-dom": ">=19"
+    "@assistant-ui/react": "0.8.17",
+    "react": "^18 || ^19 || ^19.0.0-rc"
   },
   "keywords": [
     "persona-sdk"

package/src/runtime.tsx

@@ -1,3 +1,6 @@
+'use strict';
+'use client';
+
 import { useState, useEffect, useCallback, PropsWithChildren, createContext, useContext, useMemo, useRef } from 'react';
 import { useExternalStoreRuntime, AppendMessage, AssistantRuntimeProvider } from '@assistant-ui/react';
 import {