@peers-app/peers-ui 0.0.14

package/dist/globals.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groups = exports.isDesktop = exports.windowHeight = exports.windowWidth = exports.me = exports.threadViewOpen = exports.openThreads = exports.queryParams = exports.mainContentPath = exports._mainContentPath = exports.packageReloaded = void 0;
+exports.queryParam = queryParam;
+exports.openThread = openThread;
+exports.openThreadInTab = openThreadInTab;
+exports.loadGlobals = loadGlobals;
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+const tabs_state_1 = require("./tabs-layout/tabs-state");
+const utils_1 = require("./utils");
+exports.packageReloaded = (0, peers_sdk_1.observable)(0);
+exports._mainContentPath = (0, peers_sdk_1.groupUserVar)('mainContentPath', { defaultValue: '' });
+exports.mainContentPath = (0, peers_sdk_1.computed)({
+    read: () => {
+        return (0, exports._mainContentPath)();
+    },
+    write: (newPath) => {
+        const oldPath = (0, exports._mainContentPath)();
+        if (newPath === oldPath)
+            return;
+        // _mainContentPath(newPath);
+        (0, tabs_state_1.handleMainPathChanged)(oldPath, newPath, exports._mainContentPath);
+    },
+});
+exports.queryParams = (0, peers_sdk_1.computed)({
+    read: () => {
+        const queryStr = (0, exports.mainContentPath)()?.split('?')[1] || '';
+        const params = new URLSearchParams(queryStr);
+        const obj = {};
+        for (const [key, value] of params.entries()) {
+            obj[key] = value;
+        }
+        return obj;
+    },
+    write: (value) => {
+        const queryStr = (0, exports.mainContentPath)().split('?')[1] || '';
+        const params = new URLSearchParams(queryStr);
+        for (const key in value) {
+            params.set(key, value[key]);
+        }
+        (0, exports.mainContentPath)((0, exports.mainContentPath)().split('?')[0] + '?' + params.toString());
+    },
+});
+function queryParam(name, value) {
+    const params = (0, exports.queryParams)();
+    if (value !== undefined) {
+        if (params[name] === value) {
+            return value;
+        }
+        if (value === null || value === '') {
+            delete params[name];
+        }
+        else {
+            params[name] = value;
+        }
+        (0, exports.queryParams)(params);
+    }
+    return params[name];
+}
+// export const openThreads = persistentVar<(string | IMessage)[]>('openThreads', { scope: 'user', defaultValue: [] });
+exports.openThreads = (0, peers_sdk_1.groupUserVar)('openThreads', { defaultValue: [] });
+exports.threadViewOpen = (0, peers_sdk_1.groupUserVar)('threadViewOpen', { defaultValue: false });
+async function openThread(thread) {
+    openThreadInTab(thread);
+    // let threadId = typeof thread === 'string' ? thread : thread.messageId;
+    // const message = await Messages().get(threadId);
+    // if (message) {
+    //   thread = message.messageParentId || message.messageId;
+    // }
+    // const threadsWithout = openThreads().filter(t => (typeof t === 'string' && t !== threadId) || (typeof t === 'object' && t.messageId !== threadId));
+    // openThreads([thread, ...threadsWithout]);
+    // threadViewOpen(true);
+}
+// Thread opening function for tabs system
+async function openThreadInTab(thread) {
+    let threadId = typeof thread === 'string' ? thread : thread.messageId;
+    const message = await (0, peers_sdk_1.Messages)().get(threadId);
+    if (!message) {
+        console.warn('Thread message not found:', threadId);
+        return;
+    }
+    // Use parent message ID if this is a reply, otherwise use the message itself
+    const actualThreadId = message.messageParentId || message.messageId;
+    // Generate thread title from message content (strip mentions and clean formatting)
+    const cleanMessage = (0, utils_1.stripMentions)(message.message);
+    const messagePreview = cleanMessage.slice(0, 30);
+    const threadTitle = `${messagePreview}${cleanMessage.length > 30 ? '...' : ''}` || `Thread`;
+    // // Import openNewTab dynamically to avoid circular dependency
+    // const { openNewTab } = await import('./tabs-layout/tabs-layout');
+    (0, tabs_state_1.openNewTab)({
+        packageId: 'system-apps',
+        path: `threads/${actualThreadId}`,
+        title: threadTitle,
+        iconClassName: 'bi-chat-dots',
+    });
+}
+peers_sdk_1.rpcClientCalls.setClientPath = async (url) => {
+    (0, exports.mainContentPath)(url && String(url).trim() || '');
+};
+peers_sdk_1.rpcClientCalls.openThread = async (threadId) => {
+    console.warn('Opening thread:', threadId);
+    openThread(threadId);
+};
+exports.me = null;
+exports.windowWidth = (0, peers_sdk_1.observable)(window.innerWidth); //.extend({ rateLimit: 500 });
+exports.windowHeight = (0, peers_sdk_1.observable)(window.innerHeight); //.extend({ rateLimit: 500 });
+window.addEventListener("resize", (ev) => {
+    (0, exports.windowWidth)(window.innerWidth);
+    (0, exports.windowHeight)(window.innerHeight);
+});
+exports.isDesktop = (0, peers_sdk_1.computed)(() => {
+    // return windowWidth() > 1200;
+    return (0, exports.windowWidth)() > 992;
+    // return windowWidth() > 768;
+});
+exports.groups = (0, peers_sdk_1.observable)([]);
+let globalsLoaded = false;
+async function loadGlobals() {
+    if (globalsLoaded)
+        return true;
+    globalsLoaded = true;
+    exports.me = await (0, peers_sdk_1.getMe)();
+    await peers_sdk_1.reloadPackagesOnPageRefresh.loadingPromise;
+    if ((0, peers_sdk_1.reloadPackagesOnPageRefresh)()) {
+        await peers_sdk_1.rpcServerCalls.installOrUpdatePackage('all');
+    }
+    await Promise.all([
+        (0, peers_sdk_1.Groups)().list().then(exports.groups),
+        exports._mainContentPath.loadingPromise,
+        exports.openThreads.loadingPromise,
+        exports.threadViewOpen.loadingPromise,
+        (0, peers_sdk_1.sleep)(100), // hacky way to prevent some jank
+    ]);
+    function updateWindowHash() {
+        if (window.location.hash.substr(1) !== (0, exports.mainContentPath)()) {
+            window.location.hash = (0, exports.mainContentPath)() || '';
+        }
+        (0, exports.mainContentPath)((0, exports.mainContentPath)() || '');
+    }
+    exports.mainContentPath.subscribe(updateWindowHash);
+    updateWindowHash();
+    window.addEventListener('hashchange', () => (0, exports.mainContentPath)(window.location.hash.substring(1)));
+    return true;
+}
+if (typeof window !== 'undefined') {
+    // @ts-ignore
+    window.globals = module.exports;
+}

package/dist/hooks.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+import { Observable } from "@peers-app/peers-sdk";
+/**
+ * Use this to subscribe to an observable or computed in a functional component.
+ * @param sub the observable or computed to subscribe to
+ * @param deps an array of dependencies to pass to useEffect which will trigger a re-render when any of the dependencies change
+ * @returns the current value of the observable or computed and a function to set the value
+ */
+export declare function useObservable<T>(sub: Observable<T> | T, deps?: React.DependencyList): [T, (value: T) => void];
+/**
+ * Use this to easily wait for a promise in a functional component.
+ * @param p The promise to wait for
+ * @param initialValue the initial value to return before the promise resolves
+ * @param deps the dependencies to pass to useEffect which will trigger a re-render when any of the dependencies change
+ * @returns the initial value and the resolved value of the promise
+ */
+export declare function usePromise<T>(p: Promise<T> | (() => Promise<T>), initialValue?: T, deps?: React.DependencyList): T | undefined;
+/**
+ * Use this to create an observable in a functional component.
+ * This automatically subscribes to the observable and triggers a re-render when the value changes.
+ * @param initialValue This will be the initial value of the observable
+ * @param doNotSubscribe If true, the observable will not be subscribed to automatically.
+ * This is useful if you want to create an observable that persists between rerenders but doesn't cause rerenders itself.
+ * @returns
+ */
+export declare function useObservableState<T>(initialValue?: T, doNotSubscribe?: boolean): Observable<T>;
+/**
+ * Use this to register a handler for a knockout subscribable in a functional component.
+ * The handler will be called immediately and whenever the subscribable changes.
+ * @param subscribable The observable to subscribe to
+ * @param onChange The function to call with the new value when the observable changes
+  */
+export declare function useSubscription<T>(subscribable: Observable<T>, onChange: (value: T) => any, doNotCallOnChangeDuringSetup?: boolean): void;
+export declare function useOnScreen(ref: React.RefObject<any>): boolean;

package/dist/hooks.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useObservable = useObservable;
+exports.usePromise = usePromise;
+exports.useObservableState = useObservableState;
+exports.useSubscription = useSubscription;
+exports.useOnScreen = useOnScreen;
+const react_1 = require("react");
+const lodash_1 = require("lodash");
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+/**
+ * Use this to subscribe to an observable or computed in a functional component.
+ * @param sub the observable or computed to subscribe to
+ * @param deps an array of dependencies to pass to useEffect which will trigger a re-render when any of the dependencies change
+ * @returns the current value of the observable or computed and a function to set the value
+ */
+function useObservable(sub, deps = []) {
+    const [data, setData] = (0, react_1.useState)(() => (0, peers_sdk_1.unwrapObservable)(sub));
+    (0, react_1.useEffect)(() => {
+        if (!(0, peers_sdk_1.isSubscribable)(sub)) {
+            return;
+        }
+        const subscription = sub.subscribe(() => {
+            const newData = sub();
+            // @ts-ignore
+            if ((0, lodash_1.isArray)(newData) && newData === data) {
+                // @ts-ignore
+                setData([...newData]);
+            }
+            else {
+                setData(newData);
+            }
+        });
+        // the data might change _after_ useObservable is called but _before_ the subscription has been created
+        // this checks for that and updates the state with the new data if necessary
+        const newData = sub();
+        if (!(0, lodash_1.isEqual)(data, newData)) {
+            setData(newData);
+        }
+        return () => subscription.dispose();
+    }, deps);
+    return [data, newData => {
+            setData(newData);
+            if ((0, peers_sdk_1.isSubscribable)(sub)) {
+                sub(newData);
+            }
+        }];
+}
+/**
+ * Use this to easily wait for a promise in a functional component.
+ * @param p The promise to wait for
+ * @param initialValue the initial value to return before the promise resolves
+ * @param deps the dependencies to pass to useEffect which will trigger a re-render when any of the dependencies change
+ * @returns the initial value and the resolved value of the promise
+ */
+function usePromise(p, initialValue, deps = []) {
+    const [data, setData] = (0, react_1.useState)(initialValue);
+    (0, react_1.useEffect)(() => {
+        let disposed = false;
+        if (typeof p === 'function') {
+            p = p();
+        }
+        p.then(newData => {
+            // if (!_.isEqual(newData, data) && !disposed) {
+            if (!disposed) {
+                setData(newData);
+            }
+        });
+        return () => {
+            disposed = true;
+        };
+    }, deps);
+    return data;
+}
+/**
+ * Use this to create an observable in a functional component.
+ * This automatically subscribes to the observable and triggers a re-render when the value changes.
+ * @param initialValue This will be the initial value of the observable
+ * @param doNotSubscribe If true, the observable will not be subscribed to automatically.
+ * This is useful if you want to create an observable that persists between rerenders but doesn't cause rerenders itself.
+ * @returns
+ */
+function useObservableState(initialValue, doNotSubscribe) {
+    const [obs] = (0, react_1.useState)(() => (0, peers_sdk_1.observable)(initialValue));
+    if (!doNotSubscribe) {
+        useObservable(obs);
+    }
+    return obs;
+}
+/**
+ * Use this to register a handler for a knockout subscribable in a functional component.
+ * The handler will be called immediately and whenever the subscribable changes.
+ * @param subscribable The observable to subscribe to
+ * @param onChange The function to call with the new value when the observable changes
+  */
+function useSubscription(subscribable, onChange, doNotCallOnChangeDuringSetup) {
+    if (!doNotCallOnChangeDuringSetup) {
+        (0, react_1.useEffect)(() => onChange(subscribable()), []);
+    }
+    (0, react_1.useEffect)(() => {
+        const subscription = subscribable.subscribe(() => onChange(subscribable()));
+        return () => subscription.dispose();
+    }, [subscribable, onChange]);
+}
+function useOnScreen(ref) {
+    const [isIntersecting, setIntersecting] = (0, react_1.useState)(false);
+    const observer = new IntersectionObserver(([entry]) => setIntersecting(entry.isIntersecting));
+    (0, react_1.useEffect)(() => {
+        observer.observe(ref.current);
+        // Remove the observer as soon as the component is unmounted
+        return () => { observer.disconnect(); };
+    }, []);
+    return isIntersecting;
+}
+// /**
+//  * This creates an observable that will automatically persist its value between page reloads using localStorage.
+//  * If localStorage is not available, the observable will not persist its value.
+//  * @param initialValue the initial value of the observable
+//  * @param globalName the name to use when storing the value in localStorage
+//  * @returns the observable that will persist between page reloads
+//  */
+// export function persistentValue<T>(initialValue: T, globalName: string): Observable<T | undefined> {
+//   let q = observable<T>();
+//   if (typeof localStorage === 'undefined') {
+//     return q;
+//   }
+//   q.subscribe(newVal => {
+//     localStorage.setItem(globalName, JSON.stringify(toJSON(newVal)))
+//   })
+//   const existing = localStorage.getItem(globalName);
+//   if (existing) {
+//     q(fromJSON(JSON.parse(existing)))
+//   } else {
+//     q(initialValue);
+//   }
+//   return q;
+// }

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./app";
+export * from "./three-bar-layout/three-bar-layout";
+export * from "./screens/events/cron";
+export * from "./tabs-layout/tabs-layout";

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./app"), exports);
+__exportStar(require("./three-bar-layout/three-bar-layout"), exports);
+__exportStar(require("./screens/events/cron"), exports);
+__exportStar(require("./tabs-layout/tabs-layout"), exports);

package/dist/layout-vars.d.ts

@@ -0,0 +1,6 @@
+export declare const leftBarCollapsed: import("@peers-app/peers-sdk").PersistentVar<boolean>;
+export declare const rightBarCollapsed: import("@peers-app/peers-sdk").PersistentVar<boolean>;
+export declare const leftBarWidth: import("@peers-app/peers-sdk").PersistentVar<number>;
+export declare const rightBarWidth: import("@peers-app/peers-sdk").PersistentVar<number>;
+export declare const leftBarWidthPrev: import("@peers-app/peers-sdk").PersistentVar<number>;
+export declare const rightBarWidthPrev: import("@peers-app/peers-sdk").PersistentVar<number>;

package/dist/layout-vars.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rightBarWidthPrev = exports.leftBarWidthPrev = exports.rightBarWidth = exports.leftBarWidth = exports.rightBarCollapsed = exports.leftBarCollapsed = void 0;
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+exports.leftBarCollapsed = (0, peers_sdk_1.deviceVar)('leftBarCollapsed', { defaultValue: false, });
+exports.rightBarCollapsed = (0, peers_sdk_1.deviceVar)('rightBarCollapsed', { defaultValue: false, });
+exports.leftBarWidth = (0, peers_sdk_1.deviceVar)('leftBarWidth', { defaultValue: 250, });
+exports.rightBarWidth = (0, peers_sdk_1.deviceVar)('rightBarWidth', { defaultValue: 250, });
+exports.leftBarWidthPrev = (0, peers_sdk_1.deviceVar)('leftBarWidthPrev', { defaultValue: 250, });
+exports.rightBarWidthPrev = (0, peers_sdk_1.deviceVar)('rightBarWidthPrev', { defaultValue: 250, });

package/dist/mention-configs.d.ts

@@ -0,0 +1,18 @@
+import { IMentionData } from "@peers-app/peers-sdk";
+export interface IMentionConfig {
+    iconClass: string;
+    styleClass?: string;
+    kind: string;
+    query: (text: string) => Promise<IMentionData[]>;
+    getById: (id: string) => Promise<IMentionData | undefined>;
+    picture?: (data: IMentionData) => JSX.Element;
+    onClick?: ((data: IMentionData) => void);
+}
+export declare const toolMentionConfig: IMentionConfig;
+export declare const userMentionConfig: IMentionConfig;
+export declare const assistantMentionConfig: IMentionConfig;
+export declare const workflowMentionConfig: IMentionConfig;
+export declare const peerEventTypeMentionConfig: IMentionConfig;
+export declare const predicateMentionConfig: IMentionConfig;
+export declare const valueTypeMentionConfig: IMentionConfig;
+export declare const mentionConfigs: IMentionConfig[];

package/dist/mention-configs.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mentionConfigs = exports.valueTypeMentionConfig = exports.predicateMentionConfig = exports.peerEventTypeMentionConfig = exports.workflowMentionConfig = exports.assistantMentionConfig = exports.userMentionConfig = exports.toolMentionConfig = void 0;
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+// import { MENTIONS_MAX_RESULTS } from "../client/components/markdown-editor/mentions-plugin";
+const MENTIONS_MAX_RESULTS = 10;
+exports.toolMentionConfig = {
+    kind: 'tool',
+    iconClass: 'bi bi-tools',
+    styleClass: 'mention-tool',
+    query: async (search) => {
+        const results = await (0, peers_sdk_1.Tools)().list({ name: { $matchWords: search } }, { pageSize: MENTIONS_MAX_RESULTS });
+        return results.map(p => ({
+            kind: 'tool',
+            id: p.toolId,
+            name: p.name
+        }));
+    },
+    getById: id => (0, peers_sdk_1.Tools)().get(id).then(item => item && {
+        kind: 'tool',
+        id: item.toolId,
+        name: item.name
+    })
+};
+exports.userMentionConfig = {
+    kind: 'user',
+    iconClass: 'bi-person-fill',
+    styleClass: 'mention-user',
+    query: async (search) => {
+        return (0, peers_sdk_1.Users)().list({ name: { $matchWords: search } }, { pageSize: MENTIONS_MAX_RESULTS })
+            .then((users) => users.map((user) => ({
+            kind: 'user',
+            id: user.userId,
+            name: user.name,
+        })));
+    },
+    getById: id => (0, peers_sdk_1.Users)().get(id).then(item => item && {
+        kind: 'user',
+        id: item.userId,
+        name: item.name
+    }),
+};
+exports.assistantMentionConfig = {
+    kind: 'assistant',
+    iconClass: 'bi bi-person-fill-gear',
+    styleClass: 'mention-assistant',
+    query: async (search) => {
+        return (0, peers_sdk_1.Assistants)().list({ name: { $matchWords: search } }, { pageSize: MENTIONS_MAX_RESULTS })
+            .then((assistants) => assistants.map((assistant) => ({
+            kind: 'assistant',
+            id: assistant.assistantId,
+            name: assistant.name,
+        })));
+    },
+    getById: id => (0, peers_sdk_1.Assistants)().get(id).then(item => item && {
+        kind: 'assistant',
+        id: item.assistantId,
+        name: item.name
+    }),
+};
+exports.workflowMentionConfig = {
+    kind: 'workflow',
+    iconClass: 'bi bi-database-fill-gear',
+    styleClass: 'mention-workflow',
+    query: async (search) => {
+        return (0, peers_sdk_1.Workflows)().list({ name: { $matchWords: search } }, { pageSize: MENTIONS_MAX_RESULTS })
+            .then((workflows) => workflows.map((workflow) => ({
+            kind: 'workflow',
+            id: workflow.workflowId,
+            name: workflow.name,
+        })));
+    },
+    getById: id => (0, peers_sdk_1.Workflows)().get(id).then(item => item && {
+        kind: 'workflow',
+        id: item.workflowId,
+        name: item.name
+    }),
+};
+exports.peerEventTypeMentionConfig = {
+    kind: 'event',
+    iconClass: 'bi bi-lightning-charge-fill',
+    styleClass: 'mention-event',
+    query: async (search) => {
+        return (0, peers_sdk_1.PeerEventTypes)().list({ name: { $matchWords: search } }, { pageSize: MENTIONS_MAX_RESULTS })
+            .then((events) => events.map((event) => ({
+            kind: 'event',
+            id: event.peerEventTypeId,
+            name: event.name,
+        })));
+    },
+    getById: id => (0, peers_sdk_1.PeerEventTypes)().get(id).then(item => item && {
+        kind: 'event',
+        id: item.peerEventTypeId,
+        name: item.name
+    }),
+};
+exports.predicateMentionConfig = {
+    kind: 'predicate',
+    iconClass: 'bi bi-node-plus-fill',
+    query: async (search) => {
+        const results = await (0, peers_sdk_1.Predicates)().list({ name: { $matchWords: search } }, { pageSize: MENTIONS_MAX_RESULTS });
+        return results.map(p => ({
+            kind: 'predicate',
+            id: p.predicateId,
+            name: p.name
+        }));
+    },
+    getById: id => (0, peers_sdk_1.Predicates)().get(id).then(item => item && {
+        kind: 'predicate',
+        id: item.predicateId,
+        name: item.name
+    }),
+};
+exports.valueTypeMentionConfig = {
+    kind: 'type',
+    iconClass: 'bi bi-code-square',
+    query: async (search) => {
+        const results = await (0, peers_sdk_1.PeerTypes)().list({ name: { $matchWords: search } }, { pageSize: MENTIONS_MAX_RESULTS });
+        return results.map(item => ({
+            kind: 'type',
+            id: item.peerTypeId,
+            name: item.name
+        }));
+    },
+    getById: id => (0, peers_sdk_1.PeerTypes)().get(id).then(item => item && {
+        kind: 'type',
+        id: item.peerTypeId,
+        name: item.name
+    }),
+    onClick(data) {
+        peers_sdk_1.rpcClientCalls.setClientPath(`value-types/${data.id}`);
+    },
+};
+// Tasks().list({ title: { $matchWords: mentionString }, completeDT: { $exists: searchCompletedTasks } }, { pageSize: MAX_RESULTS })
+//   .then((tasks) => tasks.map((task) => ({
+//     kind: 'task' as const,
+//     id: task.taskId,
+//     name: task.title,
+//   }))),
+// picture = <i className="bi bi-list-task pe-1" />;
+exports.mentionConfigs = [
+    exports.toolMentionConfig,
+    exports.userMentionConfig,
+    exports.assistantMentionConfig,
+    exports.workflowMentionConfig,
+    exports.peerEventTypeMentionConfig,
+    exports.predicateMentionConfig,
+    exports.valueTypeMentionConfig,
+];

package/dist/screens/assistants/assistant-config.d.ts

@@ -0,0 +1,5 @@
+import { IAssistant, IDoc } from "@peers-app/peers-sdk";
+import React from "react";
+export declare const AssistantConfig: (props: {
+    assistant: IDoc<IAssistant>;
+}) => React.JSX.Element;

package/dist/screens/assistants/assistant-config.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssistantConfig = void 0;
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+const react_1 = __importDefault(require("react"));
+const io_schema_values_1 = require("../../components/io-schema-values");
+const loading_indicator_1 = require("../../components/loading-indicator");
+const hooks_1 = require("../../hooks");
+const AssistantConfig = (props) => {
+    const { assistant } = props;
+    const assistantRunnerTool = (0, hooks_1.usePromise)(async () => {
+        return await (0, peers_sdk_1.Tools)().get(assistant.assistantRunnerToolId);
+    });
+    if (assistantRunnerTool === undefined) {
+        return react_1.default.createElement(loading_indicator_1.LoadingIndicator, null);
+    }
+    if (assistantRunnerTool === null) {
+        return (react_1.default.createElement("div", null,
+            react_1.default.createElement("div", { className: 'mt-2' },
+                react_1.default.createElement("small", null, "Assistant Runner Tool:"),
+                react_1.default.createElement(AssistantRunnersDropdown, { selectedToolId: assistant.qs.assistantRunnerToolId }))));
+    }
+    assistantRunnerTool.configSchema = assistantRunnerTool.configSchema ?? {
+        type: peers_sdk_1.IOSchemaType.complex,
+        fields: []
+    };
+    return (react_1.default.createElement("div", null,
+        react_1.default.createElement("div", { className: 'mt-2' },
+            react_1.default.createElement("small", null, "Assistant Runner Tool:"),
+            react_1.default.createElement(AssistantRunnersDropdown, { selectedToolId: assistant.qs.assistantRunnerToolId })),
+        react_1.default.createElement(io_schema_values_1.IOSchemaValues, { ioSchema: assistantRunnerTool.configSchema, values: assistant.assistantRunnerConfig, q: assistant.q })));
+};
+exports.AssistantConfig = AssistantConfig;
+const AssistantRunnersDropdown = (props) => {
+    const [selectedToolId] = (0, hooks_1.useObservable)(props.selectedToolId);
+    const modelTools = (0, hooks_1.usePromise)(async () => {
+        const modelTools = await (0, peers_sdk_1.Tools)().list({ isAssistantRunner: true });
+        return modelTools;
+    });
+    if (!modelTools) {
+        return react_1.default.createElement(loading_indicator_1.LoadingIndicator, null);
+    }
+    return (react_1.default.createElement("div", { className: "dropdown" },
+        react_1.default.createElement("button", { className: "btn btn-secondary dropdown-toggle", type: "button", "data-bs-toggle": "dropdown", "aria-expanded": "false" }, modelTools.find(tool => tool.toolId === selectedToolId)?.name ?? 'Select Tool'),
+        react_1.default.createElement("ul", { className: "dropdown-menu" }, modelTools.map(tool => {
+            return (react_1.default.createElement("li", { key: tool.toolId, onClick: () => props.selectedToolId(tool.toolId) },
+                react_1.default.createElement("span", { className: "dropdown-item" }, tool.name)));
+        }))));
+};

package/dist/screens/assistants/assistant-details.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const AssistantDetails: (props: {
+    assistantId: string;
+}) => React.JSX.Element;