tauri-plugin-askit-api 0.5.1 → 0.7.0

package/dist-js/index.cjs

@@ -4,113 +4,138 @@ var core = require('@tauri-apps/api/core');
 
 // agent definition
 async function getAgentDefinition() {
-    return await core.invoke('plugin:askit|get_agent_definition', {});
+    return await core.invoke("plugin:askit|get_agent_definition", {});
 }
 async function getAgentDefinitions() {
-    return await core.invoke('plugin:askit|get_agent_definitions', {});
-}
-// flow
-async function getAgentFlows() {
-    return await core.invoke('plugin:askit|get_agent_flows', {});
-}
-async function newAgentFlow(flowName) {
-    return await core.invoke('plugin:askit|new_agent_flow', { flowName });
-}
-async function renameAgentFlow(flowId, newName) {
-    return await core.invoke('plugin:askit|rename_agent_flow', { flowId, newName });
-}
-async function uniqueFlowName(name) {
-    return await core.invoke('plugin:askit|unique_flow_name', { name });
-}
-async function addAgentFlow(agentFlow) {
-    await core.invoke('plugin:askit|add_agent_flow', { agentFlow });
-}
-async function removeAgentFlow(id) {
-    await core.invoke('plugin:askit|remove_agent_flow', { id });
-}
-async function insertAgentFlow(agentFlow) {
-    await core.invoke('plugin:askit|insert_agent_flow', { agentFlow });
-}
-async function copySubFlow(nodes, edges) {
-    return await core.invoke('plugin:askit|copy_sub_flow', { nodes, edges });
-}
-async function startAgentFlow(id) {
-    await core.invoke('plugin:askit|start_agent_flow', { id });
-}
-async function stopAgentFlow(id) {
-    await core.invoke('plugin:askit|stop_agent_flow', { id });
-}
-// nodes
-async function newAgentFlowNode(defName) {
-    return await core.invoke('plugin:askit|new_agent_flow_node', { defName });
-}
-async function addAgentFlowNode(flowId, node) {
-    await core.invoke('plugin:askit|add_agent_flow_node', { flowId, node });
-}
-async function removeAgentFlowNode(flowId, nodeId) {
-    await core.invoke('plugin:askit|remove_agent_flow_node', { flowId, nodeId });
-}
-// edge
-async function addAgentFlowEdge(flowId, edge) {
-    await core.invoke('plugin:askit|add_agent_flow_edge', { flowId, edge });
-}
-async function removeAgentFlowEdge(flowId, edgeId) {
-    await core.invoke('plugin:askit|remove_agent_flow_edge', { flowId, edgeId });
+    return await core.invoke("plugin:askit|get_agent_definitions", {});
+}
+// agent spec
+async function getAgentSpec(agentId) {
+    return await core.invoke("plugin:askit|get_agent_spec", { agentId });
+}
+// stream
+async function getAgentStreams() {
+    return await core.invoke("plugin:askit|get_agent_streams", {});
+}
+async function newAgentStream(streamName) {
+    return await core.invoke("plugin:askit|new_agent_stream", { streamName });
+}
+async function renameAgentStream(streamId, newName) {
+    return await core.invoke("plugin:askit|rename_agent_stream", {
+        streamId,
+        newName,
+    });
+}
+async function uniqueStreamName(name) {
+    return await core.invoke("plugin:askit|unique_stream_name", { name });
+}
+async function addAgentStream(AgentStream) {
+    await core.invoke("plugin:askit|add_agent_stream", { AgentStream });
+}
+async function removeAgentStream(id) {
+    await core.invoke("plugin:askit|remove_agent_stream", { id });
+}
+async function insertAgentStream(AgentStream) {
+    await core.invoke("plugin:askit|insert_agent_stream", { AgentStream });
+}
+async function copySubStream(agents, channels) {
+    return await core.invoke("plugin:askit|copy_sub_stream", {
+        agents,
+        channels,
+    });
+}
+async function startAgentStream(id) {
+    await core.invoke("plugin:askit|start_agent_stream", { id });
+}
+async function stopAgentStream(id) {
+    await core.invoke("plugin:askit|stop_agent_stream", { id });
+}
+// agents
+async function newAgentSpec(defName) {
+    return await core.invoke("plugin:askit|new_agent_spec", { defName });
+}
+async function addAgent(streamId, spec) {
+    await core.invoke("plugin:askit|add_agent", {
+        streamId,
+        spec,
+    });
+}
+async function removeAgent(streamId, agentId) {
+    await core.invoke("plugin:askit|remove_agent", {
+        streamId,
+        agentId,
+    });
+}
+// channel
+async function addChannel(streamId, channel) {
+    await core.invoke("plugin:askit|add_channel", {
+        streamId,
+        channel,
+    });
+}
+async function removeChannel(streamId, channelId) {
+    await core.invoke("plugin:askit|remove_channel", {
+        streamId,
+        channelId,
+    });
 }
 // agent
 async function startAgent(agentId) {
-    await core.invoke('plugin:askit|start_agent', { agentId });
+    await core.invoke("plugin:askit|start_agent", { agentId });
 }
 async function stopAgent(agentId) {
-    await core.invoke('plugin:askit|stop_agent', { agentId });
+    await core.invoke("plugin:askit|stop_agent", { agentId });
 }
 // board
 async function writeBoard(board, message) {
-    await core.invoke('plugin:askit|write_board', { board, message });
+    await core.invoke("plugin:askit|write_board", { board, message });
 }
 // configs
 async function setAgentConfigs(agentId, configs) {
-    await core.invoke('plugin:askit|set_agent_configs', { agentId, configs });
+    await core.invoke("plugin:askit|set_agent_configs", { agentId, configs });
 }
 async function getGlobalConfigs(defName) {
-    return await core.invoke('plugin:askit|get_global_configs', { defName });
+    return await core.invoke("plugin:askit|get_global_configs", { defName });
 }
 async function getGlobalConfigsMap() {
-    return await core.invoke('plugin:askit|get_global_configs_map', {});
+    return await core.invoke("plugin:askit|get_global_configs_map", {});
 }
 async function setGlobalConfigs(defName, configs) {
-    await core.invoke('plugin:askit|set_global_configs', { defName, configs });
+    await core.invoke("plugin:askit|set_global_configs", { defName, configs });
 }
 async function setGlobalConfigsMap(configs) {
-    await core.invoke('plugin:askit|set_global_configs_map', { configs });
+    await core.invoke("plugin:askit|set_global_configs_map", { configs });
 }
-async function getAgentDefaultConfigs(defName) {
-    return await core.invoke('plugin:askit|get_agent_default_configs', { defName });
+async function getAgentConfigSpecs(defName) {
+    return await core.invoke("plugin:askit|get_agent_config_specs", {
+        defName,
+    });
 }
 
-exports.addAgentFlow = addAgentFlow;
-exports.addAgentFlowEdge = addAgentFlowEdge;
-exports.addAgentFlowNode = addAgentFlowNode;
-exports.copySubFlow = copySubFlow;
-exports.getAgentDefaultConfigs = getAgentDefaultConfigs;
+exports.addAgent = addAgent;
+exports.addAgentStream = addAgentStream;
+exports.addChannel = addChannel;
+exports.copySubStream = copySubStream;
+exports.getAgentConfigSpecs = getAgentConfigSpecs;
 exports.getAgentDefinition = getAgentDefinition;
 exports.getAgentDefinitions = getAgentDefinitions;
-exports.getAgentFlows = getAgentFlows;
+exports.getAgentSpec = getAgentSpec;
+exports.getAgentStreams = getAgentStreams;
 exports.getGlobalConfigs = getGlobalConfigs;
 exports.getGlobalConfigsMap = getGlobalConfigsMap;
-exports.insertAgentFlow = insertAgentFlow;
-exports.newAgentFlow = newAgentFlow;
-exports.newAgentFlowNode = newAgentFlowNode;
-exports.removeAgentFlow = removeAgentFlow;
-exports.removeAgentFlowEdge = removeAgentFlowEdge;
-exports.removeAgentFlowNode = removeAgentFlowNode;
-exports.renameAgentFlow = renameAgentFlow;
+exports.insertAgentStream = insertAgentStream;
+exports.newAgentSpec = newAgentSpec;
+exports.newAgentStream = newAgentStream;
+exports.removeAgent = removeAgent;
+exports.removeAgentStream = removeAgentStream;
+exports.removeChannel = removeChannel;
+exports.renameAgentStream = renameAgentStream;
 exports.setAgentConfigs = setAgentConfigs;
 exports.setGlobalConfigs = setGlobalConfigs;
 exports.setGlobalConfigsMap = setGlobalConfigsMap;
 exports.startAgent = startAgent;
-exports.startAgentFlow = startAgentFlow;
+exports.startAgentStream = startAgentStream;
 exports.stopAgent = stopAgent;
-exports.stopAgentFlow = stopAgentFlow;
-exports.uniqueFlowName = uniqueFlowName;
+exports.stopAgentStream = stopAgentStream;
+exports.uniqueStreamName = uniqueStreamName;
 exports.writeBoard = writeBoard;

package/dist-js/index.d.ts

@@ -3,56 +3,48 @@ export type AgentGlobalConfigsMap = Record<string, AgentConfigs>;
 export type AgentDefinition = {
     kind: string;
     name: string;
-    title: string | null;
-    description: string | null;
-    category: string | null;
-    path: string;
-    inputs: string[] | null;
-    outputs: string[] | null;
-    default_configs: AgentDefaultConfigs | null;
-    global_configs: AgentGlobalConfigs | null;
-    display_configs: AgentDisplayConfigs | null;
+    title?: string | null;
+    description?: string | null;
+    category?: string | null;
+    inputs?: string[] | null;
+    outputs?: string[] | null;
+    configs?: AgentConfigSpecs | null;
+    global_configs?: AgentGlobalConfigSpecs | null;
+    native_thread?: boolean | null;
 };
-export type AgentDefaultConfigs = [string, AgentConfigEntry][];
-export type AgentGlobalConfigs = [string, AgentConfigEntry][];
-export type AgentConfigEntry = {
+export type AgentConfigSpecs = Record<string, AgentConfigSpec>;
+export type AgentGlobalConfigSpecs = Record<string, AgentConfigSpec>;
+export type AgentConfigSpec = {
     value: any;
     type: AgentConfigValueType | null;
     title?: string | null;
+    hideTitle?: boolean | null;
     description?: string | null;
     hidden?: boolean | null;
+    readonly?: boolean | null;
 };
-export type AgentConfigValueType = "unit" | "boolean" | "integer" | "number" | "string" | "password" | "text" | "object";
-export type AgentDisplayConfigs = [string, AgentDisplayConfigEntry][];
-export type AgentDisplayConfigEntry = {
-    type: AgentDisplayConfigType | null;
-    title?: string | null;
-    description?: string | null;
-    hideTitle?: boolean | null;
-};
-export type AgentDisplayConfigType = "*" | "boolean" | "integer" | "number" | "string" | "text" | "object" | "messages";
-export type AgentFlows = Record<string, AgentFlow>;
-export type AgentFlow = {
+export type AgentConfigValueType = string;
+export type AgentStreams = Record<string, AgentStream>;
+export type AgentStream = {
     id: string;
     name: string;
-    nodes: AgentFlowNode[];
-    edges: AgentFlowEdge[];
+    agents: AgentSpec[];
+    channels: ChannelSpec[];
     viewport: Viewport | null;
 };
 export type AgentConfigsMap = Record<string, AgentConfigs>;
 export type AgentConfigs = Record<string, any>;
-export type AgentFlowNode = {
-    id: string;
+export type AgentSpecExtensions = Record<string, any>;
+export type AgentSpec = {
+    id?: string | null;
     def_name: string;
-    enabled: boolean;
-    configs: AgentConfigs | null;
-    title: string | null;
-    x: number;
-    y: number;
-    width?: number;
-    height?: number;
-};
-export type AgentFlowEdge = {
+    inputs?: string[] | null;
+    outputs?: string[] | null;
+    configs?: AgentConfigs | null;
+    config_specs?: AgentConfigSpecs | null;
+    enabled?: boolean | null;
+} & AgentSpecExtensions;
+export type ChannelSpec = {
     id: string;
     source: string;
     source_handle: string | null;
@@ -71,49 +63,36 @@ export type CoreSettings = {
 export type Settings = {
     core: CoreSettings;
     agents: Record<string, AgentDefinition>;
-    agent_flows: AgentFlow[];
-};
-export type ConfigMessage = {
-    agent_id: string;
-    key: string;
-    value: any;
+    agent_streams: AgentStream[];
 };
-export type DisplayMessage = {
-    agent_id: string;
+export type BoardMessage = {
     key: string;
     value: any;
 };
-export type ErrorMessage = {
-    agent_id: string;
-    message: string;
-};
-export type InputMessage = {
-    agent_id: string;
-    ch: string;
-};
 export declare function getAgentDefinition(): Promise<AgentDefinition | null>;
 export declare function getAgentDefinitions(): Promise<AgentDefinitions>;
-export declare function getAgentFlows(): Promise<AgentFlows>;
-export declare function newAgentFlow(flowName: string): Promise<AgentFlow>;
-export declare function renameAgentFlow(flowId: string, newName: string): Promise<string>;
-export declare function uniqueFlowName(name: string): Promise<string>;
-export declare function addAgentFlow(agentFlow: AgentFlow): Promise<void>;
-export declare function removeAgentFlow(id: string): Promise<void>;
-export declare function insertAgentFlow(agentFlow: AgentFlow): Promise<void>;
-export declare function copySubFlow(nodes: AgentFlowNode[], edges: AgentFlowEdge[]): Promise<[AgentFlowNode[], AgentFlowEdge[]]>;
-export declare function startAgentFlow(id: string): Promise<void>;
-export declare function stopAgentFlow(id: string): Promise<void>;
-export declare function newAgentFlowNode(defName: string): Promise<AgentFlowNode>;
-export declare function addAgentFlowNode(flowId: string, node: AgentFlowNode): Promise<void>;
-export declare function removeAgentFlowNode(flowId: string, nodeId: string): Promise<void>;
-export declare function addAgentFlowEdge(flowId: string, edge: AgentFlowEdge): Promise<void>;
-export declare function removeAgentFlowEdge(flowId: string, edgeId: string): Promise<void>;
+export declare function getAgentSpec(agentId: string): Promise<AgentSpec | null>;
+export declare function getAgentStreams(): Promise<AgentStreams>;
+export declare function newAgentStream(streamName: string): Promise<AgentStream>;
+export declare function renameAgentStream(streamId: string, newName: string): Promise<string>;
+export declare function uniqueStreamName(name: string): Promise<string>;
+export declare function addAgentStream(AgentStream: AgentStream): Promise<void>;
+export declare function removeAgentStream(id: string): Promise<void>;
+export declare function insertAgentStream(AgentStream: AgentStream): Promise<void>;
+export declare function copySubStream(agents: AgentSpec[], channels: ChannelSpec[]): Promise<[AgentSpec[], ChannelSpec[]]>;
+export declare function startAgentStream(id: string): Promise<void>;
+export declare function stopAgentStream(id: string): Promise<void>;
+export declare function newAgentSpec(defName: string): Promise<AgentSpec>;
+export declare function addAgent(streamId: string, spec: AgentSpec): Promise<void>;
+export declare function removeAgent(streamId: string, agentId: string): Promise<void>;
+export declare function addChannel(streamId: string, channel: ChannelSpec): Promise<void>;
+export declare function removeChannel(streamId: string, channelId: string): Promise<void>;
 export declare function startAgent(agentId: string): Promise<void>;
 export declare function stopAgent(agentId: string): Promise<void>;
 export declare function writeBoard(board: string, message: string): Promise<void>;
-export declare function setAgentConfigs(agentId: string, configs: Record<string, any>): Promise<void>;
+export declare function setAgentConfigs(agentId: string, configs: AgentConfigs): Promise<void>;
 export declare function getGlobalConfigs(defName: string): Promise<AgentConfigs | null>;
 export declare function getGlobalConfigsMap(): Promise<AgentConfigsMap>;
 export declare function setGlobalConfigs(defName: string, configs: AgentConfigs): Promise<void>;
 export declare function setGlobalConfigsMap(configs: AgentConfigsMap): Promise<void>;
-export declare function getAgentDefaultConfigs(defName: string): Promise<AgentDefaultConfigs | null>;
+export declare function getAgentConfigSpecs(defName: string): Promise<AgentConfigSpecs | null>;

package/dist-js/index.js

@@ -2,88 +2,112 @@ import { invoke } from '@tauri-apps/api/core';
 
 // agent definition
 async function getAgentDefinition() {
-    return await invoke('plugin:askit|get_agent_definition', {});
+    return await invoke("plugin:askit|get_agent_definition", {});
 }
 async function getAgentDefinitions() {
-    return await invoke('plugin:askit|get_agent_definitions', {});
-}
-// flow
-async function getAgentFlows() {
-    return await invoke('plugin:askit|get_agent_flows', {});
-}
-async function newAgentFlow(flowName) {
-    return await invoke('plugin:askit|new_agent_flow', { flowName });
-}
-async function renameAgentFlow(flowId, newName) {
-    return await invoke('plugin:askit|rename_agent_flow', { flowId, newName });
-}
-async function uniqueFlowName(name) {
-    return await invoke('plugin:askit|unique_flow_name', { name });
-}
-async function addAgentFlow(agentFlow) {
-    await invoke('plugin:askit|add_agent_flow', { agentFlow });
-}
-async function removeAgentFlow(id) {
-    await invoke('plugin:askit|remove_agent_flow', { id });
-}
-async function insertAgentFlow(agentFlow) {
-    await invoke('plugin:askit|insert_agent_flow', { agentFlow });
-}
-async function copySubFlow(nodes, edges) {
-    return await invoke('plugin:askit|copy_sub_flow', { nodes, edges });
-}
-async function startAgentFlow(id) {
-    await invoke('plugin:askit|start_agent_flow', { id });
-}
-async function stopAgentFlow(id) {
-    await invoke('plugin:askit|stop_agent_flow', { id });
-}
-// nodes
-async function newAgentFlowNode(defName) {
-    return await invoke('plugin:askit|new_agent_flow_node', { defName });
-}
-async function addAgentFlowNode(flowId, node) {
-    await invoke('plugin:askit|add_agent_flow_node', { flowId, node });
-}
-async function removeAgentFlowNode(flowId, nodeId) {
-    await invoke('plugin:askit|remove_agent_flow_node', { flowId, nodeId });
-}
-// edge
-async function addAgentFlowEdge(flowId, edge) {
-    await invoke('plugin:askit|add_agent_flow_edge', { flowId, edge });
-}
-async function removeAgentFlowEdge(flowId, edgeId) {
-    await invoke('plugin:askit|remove_agent_flow_edge', { flowId, edgeId });
+    return await invoke("plugin:askit|get_agent_definitions", {});
+}
+// agent spec
+async function getAgentSpec(agentId) {
+    return await invoke("plugin:askit|get_agent_spec", { agentId });
+}
+// stream
+async function getAgentStreams() {
+    return await invoke("plugin:askit|get_agent_streams", {});
+}
+async function newAgentStream(streamName) {
+    return await invoke("plugin:askit|new_agent_stream", { streamName });
+}
+async function renameAgentStream(streamId, newName) {
+    return await invoke("plugin:askit|rename_agent_stream", {
+        streamId,
+        newName,
+    });
+}
+async function uniqueStreamName(name) {
+    return await invoke("plugin:askit|unique_stream_name", { name });
+}
+async function addAgentStream(AgentStream) {
+    await invoke("plugin:askit|add_agent_stream", { AgentStream });
+}
+async function removeAgentStream(id) {
+    await invoke("plugin:askit|remove_agent_stream", { id });
+}
+async function insertAgentStream(AgentStream) {
+    await invoke("plugin:askit|insert_agent_stream", { AgentStream });
+}
+async function copySubStream(agents, channels) {
+    return await invoke("plugin:askit|copy_sub_stream", {
+        agents,
+        channels,
+    });
+}
+async function startAgentStream(id) {
+    await invoke("plugin:askit|start_agent_stream", { id });
+}
+async function stopAgentStream(id) {
+    await invoke("plugin:askit|stop_agent_stream", { id });
+}
+// agents
+async function newAgentSpec(defName) {
+    return await invoke("plugin:askit|new_agent_spec", { defName });
+}
+async function addAgent(streamId, spec) {
+    await invoke("plugin:askit|add_agent", {
+        streamId,
+        spec,
+    });
+}
+async function removeAgent(streamId, agentId) {
+    await invoke("plugin:askit|remove_agent", {
+        streamId,
+        agentId,
+    });
+}
+// channel
+async function addChannel(streamId, channel) {
+    await invoke("plugin:askit|add_channel", {
+        streamId,
+        channel,
+    });
+}
+async function removeChannel(streamId, channelId) {
+    await invoke("plugin:askit|remove_channel", {
+        streamId,
+        channelId,
+    });
 }
 // agent
 async function startAgent(agentId) {
-    await invoke('plugin:askit|start_agent', { agentId });
+    await invoke("plugin:askit|start_agent", { agentId });
 }
 async function stopAgent(agentId) {
-    await invoke('plugin:askit|stop_agent', { agentId });
+    await invoke("plugin:askit|stop_agent", { agentId });
 }
 // board
 async function writeBoard(board, message) {
-    await invoke('plugin:askit|write_board', { board, message });
+    await invoke("plugin:askit|write_board", { board, message });
 }
 // configs
 async function setAgentConfigs(agentId, configs) {
-    await invoke('plugin:askit|set_agent_configs', { agentId, configs });
+    await invoke("plugin:askit|set_agent_configs", { agentId, configs });
 }
 async function getGlobalConfigs(defName) {
-    return await invoke('plugin:askit|get_global_configs', { defName });
+    return await invoke("plugin:askit|get_global_configs", { defName });
 }
 async function getGlobalConfigsMap() {
-    return await invoke('plugin:askit|get_global_configs_map', {});
+    return await invoke("plugin:askit|get_global_configs_map", {});
 }
 async function setGlobalConfigs(defName, configs) {
-    await invoke('plugin:askit|set_global_configs', { defName, configs });
+    await invoke("plugin:askit|set_global_configs", { defName, configs });
 }
 async function setGlobalConfigsMap(configs) {
-    await invoke('plugin:askit|set_global_configs_map', { configs });
+    await invoke("plugin:askit|set_global_configs_map", { configs });
 }
-async function getAgentDefaultConfigs(defName) {
-    return await invoke('plugin:askit|get_agent_default_configs', { defName });
+async function getAgentConfigSpecs(defName) {
+    return await invoke("plugin:askit|get_agent_config_specs", {
+        defName,
+    });
 }
 
-export { addAgentFlow, addAgentFlowEdge, addAgentFlowNode, copySubFlow, getAgentDefaultConfigs, getAgentDefinition, getAgentDefinitions, getAgentFlows, getGlobalConfigs, getGlobalConfigsMap, insertAgentFlow, newAgentFlow, newAgentFlowNode, removeAgentFlow, removeAgentFlowEdge, removeAgentFlowNode, renameAgentFlow, setAgentConfigs, setGlobalConfigs, setGlobalConfigsMap, startAgent, startAgentFlow, stopAgent, stopAgentFlow, uniqueFlowName, writeBoard };
+export { addAgent, addAgentStream, addChannel, copySubStream, getAgentConfigSpecs, getAgentDefinition, getAgentDefinitions, getAgentSpec, getAgentStreams, getGlobalConfigs, getGlobalConfigsMap, insertAgentStream, newAgentSpec, newAgentStream, removeAgent, removeAgentStream, removeChannel, renameAgentStream, setAgentConfigs, setGlobalConfigs, setGlobalConfigsMap, startAgent, startAgentStream, stopAgent, stopAgentStream, uniqueStreamName, writeBoard };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tauri-plugin-askit-api",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "license": "MIT OR Apache-2.0",
   "author": "Akira Ishino",
   "description": "Tauri plugin for Agent Stream Kit",