@lvce-editor/rpc-registry 9.9.0 → 9.11.0

package/dist/parts/AuthWorker/AuthWorker.d.ts

@@ -0,0 +1,3 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const makeApiRequest: (options: any) => Promise<any>;
+export declare const makeStreamingApiRequest: (options: any) => Promise<any>;

package/dist/parts/AuthWorker/AuthWorker.js

@@ -0,0 +1,8 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+export const { dispose, invoke, invokeAndTransfer, registerMockRpc, set } = RpcFactory.create(6010);
+export const makeApiRequest = async (options) => {
+    return invoke('ChatNetwork.makeApiRequest', options);
+};
+export const makeStreamingApiRequest = async (options) => {
+    return invoke('ChatNetwork.makeStreamingApiRequest', options);
+};

package/dist/parts/ChatStorageWorker/ChatStorageWorker.d.ts

@@ -1,3 +1,95 @@
 export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 export declare const save: (options: any) => Promise<any>;
 export declare const get: (options: any) => Promise<any>;
+export type ChatToolCallStatus = 'error' | 'not-found' | 'success';
+export interface ChatToolCall {
+    readonly arguments: string;
+    readonly errorMessage?: string;
+    readonly errorStack?: string;
+    readonly id?: string;
+    readonly name: string;
+    readonly result?: string;
+    readonly status?: ChatToolCallStatus;
+}
+export interface ChatMessage {
+    readonly id: string;
+    readonly inProgress?: boolean;
+    readonly role: 'user' | 'assistant';
+    readonly text: string;
+    readonly time: string;
+    readonly toolCalls?: readonly ChatToolCall[];
+}
+interface ChatViewEventBase {
+    readonly sessionId: string;
+    readonly timestamp: string;
+}
+export interface ChatSessionCreatedEvent extends ChatViewEventBase {
+    readonly title: string;
+    readonly type: 'chat-session-created';
+}
+export interface ChatSessionDeletedEvent extends ChatViewEventBase {
+    readonly type: 'chat-session-deleted';
+}
+export interface ChatSessionTitleUpdatedEvent extends ChatViewEventBase {
+    readonly title: string;
+    readonly type: 'chat-session-title-updated';
+}
+export interface ChatMessageAddedEvent extends ChatViewEventBase {
+    readonly message: ChatMessage;
+    readonly type: 'chat-message-added';
+}
+export interface ChatMessageUpdatedEvent extends ChatViewEventBase {
+    readonly inProgress: boolean | undefined;
+    readonly messageId: string;
+    readonly text: string;
+    readonly time: string;
+    readonly toolCalls?: ChatMessage['toolCalls'];
+    readonly type: 'chat-message-updated';
+}
+export interface ChatSessionMessagesReplacedEvent extends ChatViewEventBase {
+    readonly messages: readonly ChatMessage[];
+    readonly type: 'chat-session-messages-replaced';
+}
+export interface HandleInputEvent extends ChatViewEventBase {
+    readonly type: 'handle-input';
+    readonly value: string;
+}
+export interface HandleSubmitEvent extends ChatViewEventBase {
+    readonly type: 'handle-submit';
+    readonly value: string;
+}
+export interface ChatAttachmentAddedEvent extends ChatViewEventBase {
+    readonly attachmentId: string;
+    readonly blob: Blob;
+    readonly mimeType: string;
+    readonly name: string;
+    readonly size: number;
+    readonly type: 'chat-attachment-added';
+}
+export interface DataEvent extends ChatViewEventBase {
+    readonly type: 'sse-response-part';
+    readonly value: unknown;
+}
+export interface ResponseCompletedEvent extends ChatViewEventBase {
+    readonly type: 'sse-response-completed';
+    readonly value: unknown;
+}
+export interface EventStreamFinishedEvent extends ChatViewEventBase {
+    readonly type: 'event-stream-finished';
+    readonly value: '[DONE]';
+}
+export type ChatViewEvent = ChatSessionCreatedEvent | ChatSessionDeletedEvent | ChatSessionTitleUpdatedEvent | ChatMessageAddedEvent | ChatMessageUpdatedEvent | ChatSessionMessagesReplacedEvent | HandleInputEvent | HandleSubmitEvent | ChatAttachmentAddedEvent | DataEvent | ResponseCompletedEvent | EventStreamFinishedEvent;
+export interface ChatSession {
+    readonly id: string;
+    readonly messages: readonly ChatMessage[];
+    readonly projectId?: string;
+    readonly title: string;
+}
+export declare const appendEvent: (event: ChatViewEvent) => Promise<void>;
+export declare const clear: () => Promise<void>;
+export declare const deleteSession: (id: string) => Promise<void>;
+export declare const getEvents: (sessionId?: string) => Promise<readonly ChatViewEvent[]>;
+export declare const getSession: (sessionId: string) => Promise<ChatSession | undefined>;
+export declare const listSessions: (sessionId: string) => Promise<readonly ChatSession[]>;
+export declare const setSession: (session: ChatSession) => Promise<void>;
+export {};

package/dist/parts/ChatStorageWorker/ChatStorageWorker.js

@@ -7,3 +7,24 @@ export const save = async (options) => {
 export const get = async (options) => {
     return invoke('ChatStorage.get', options);
 };
+export const appendEvent = async (event) => {
+    return invoke('ChatStorage.appendEvent', event);
+};
+export const clear = async () => {
+    return invoke('ChatStorage.clear');
+};
+export const deleteSession = async (id) => {
+    return invoke('ChatStorage.deleteSession', id);
+};
+export const getEvents = async (sessionId) => {
+    return invoke('ChatStorage.getEvents', sessionId);
+};
+export const getSession = async (sessionId) => {
+    return invoke('ChatStorage.getSession', sessionId);
+};
+export const listSessions = async (sessionId) => {
+    return invoke('ChatStorage.listSessions', sessionId);
+};
+export const setSession = async (session) => {
+    return invoke('ChatStorage.setSession', session);
+};

package/dist/parts/ChatToolWorker/ChatToolWorker.d.ts

@@ -1,3 +1,20 @@
 export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
-export declare const save: (options: any) => Promise<any>;
-export declare const get: (options: any) => Promise<any>;
+export type ChatTool = {
+    readonly type: 'function';
+    readonly function: {
+        readonly name: string;
+        readonly description: string;
+        readonly parameters: {
+            readonly type: 'object';
+            readonly properties: Record<string, unknown>;
+            readonly required?: readonly string[];
+            readonly additionalProperties: boolean;
+        };
+    };
+};
+export type ExecuteToolOptions = {
+    readonly assetDir: string;
+    readonly platform: number;
+};
+export declare const execute: (name: string, rawArguments: unknown, options: ExecuteToolOptions) => Promise<any>;
+export declare const getTools: () => Promise<readonly ChatTool[]>;

package/dist/parts/ChatToolWorker/ChatToolWorker.js

@@ -1,8 +1,9 @@
+import { RpcId } from '@lvce-editor/constants';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { dispose, invoke, invokeAndTransfer, registerMockRpc, set } = RpcFactory.create(6005);
-export const save = async (options) => {
-    return invoke('ChatStorage.getTools', options);
+export const { dispose, invoke, invokeAndTransfer, registerMockRpc, set } = RpcFactory.create(RpcId.ChatToolWorker);
+export const execute = async (name, rawArguments, options) => {
+    return invoke('ChatTool.execute', name, rawArguments, options);
 };
-export const get = async (options) => {
-    return invoke('ChatStorage.executeTool', options);
+export const getTools = async () => {
+    return invoke('ChatTool.getTools');
 };

package/dist/parts/Main/Main.d.ts

@@ -1,4 +1,5 @@
 export type { Rpc, MockRpc } from '@lvce-editor/rpc';
+export * as AuthWorker from '../AuthWorker/AuthWorker.ts';
 export * as ChatCoordinatorWorker from '../ChatCoordinatorWorker/ChatCoordinatorWorker.ts';
 export * as ChatDebugWorker from '../ChatDebugWorker/ChatDebugWorker.ts';
 export * as ChatMathWorker from '../ChatMathWorker/ChatMathWorker.ts';
@@ -30,6 +31,7 @@ export * as RendererProcess from '../RendererProcess/RendererProcess.ts';
 export * as RendererWorker from '../RendererWorker/RendererWorker.ts';
 export * as SourceControlWorker from '../SourceControlWorker/SourceControlWorker.ts';
 export * as TextMeasurementWorker from '../TextMeasurementWorker/TextMeasurementWorker.ts';
+export * as TextSearchWorker from '../TextSearchWorker/TextSearchWorker.ts';
 export { RpcId } from '@lvce-editor/constants';
 export * as SearchProcess from '../SearchProcess/SearchProcess.ts';
 export * as SharedProcess from '../SharedProcess/SharedProcess.ts';

package/dist/parts/Main/Main.js

@@ -1,3 +1,4 @@
+export * as AuthWorker from "../AuthWorker/AuthWorker.js";
 export * as ChatCoordinatorWorker from "../ChatCoordinatorWorker/ChatCoordinatorWorker.js";
 export * as ChatDebugWorker from "../ChatDebugWorker/ChatDebugWorker.js";
 export * as ChatMathWorker from "../ChatMathWorker/ChatMathWorker.js";
@@ -29,6 +30,7 @@ export * as RendererProcess from "../RendererProcess/RendererProcess.js";
 export * as RendererWorker from "../RendererWorker/RendererWorker.js";
 export * as SourceControlWorker from "../SourceControlWorker/SourceControlWorker.js";
 export * as TextMeasurementWorker from "../TextMeasurementWorker/TextMeasurementWorker.js";
+export * as TextSearchWorker from "../TextSearchWorker/TextSearchWorker.js";
 export { RpcId } from '@lvce-editor/constants';
 export * as SearchProcess from "../SearchProcess/SearchProcess.js";
 export * as SharedProcess from "../SharedProcess/SharedProcess.js";

package/dist/parts/RendererWorker/RendererWorker.d.ts

@@ -24,6 +24,7 @@ export declare const sendMessagePortToOpenerWorker: (port: MessagePort, rpcId: n
 export declare const sendMessagePortToChatMathWorker: (port: MessagePort, rpcId: number) => Promise<void>;
 export declare const sendMessagePortToChatCoordinatorWorkerWorker: (port: MessagePort, rpcId: number) => Promise<void>;
 export declare const sendMessagePortToMainAreaWorker: (port: MessagePort, rpcId: number) => Promise<void>;
+export declare const sendMessagePortToTextSearchWorker: (port: MessagePort, rpcId: number) => Promise<void>;
 export declare const sendMessagePortToErrorWorker: (port: MessagePort, rpcId: number) => Promise<void>;
 export declare const sendMessagePortToMarkdownWorker: (port: MessagePort, rpcId: number) => Promise<void>;
 export declare const sendMessagePortToIconThemeWorker: (port: MessagePort, rpcId: number) => Promise<void>;
@@ -54,6 +55,7 @@ export declare const sendMessagePortToQuickPickWorker: (port: MessagePort, rpcId
 export declare const sendMessagePortToSearchProcess: (port: MessagePort) => Promise<void>;
 export declare const sendMessagePortToChatNetworkWorker: (port: MessagePort) => Promise<void>;
 export declare const sendMessagePortToChatToolWorker: (port: MessagePort) => Promise<void>;
+export declare const sendMessagePortToChatStorageWorker: (port: MessagePort) => Promise<void>;
 export declare const sendMessagePortToChatDebugViewWorker: (port: MessagePort) => Promise<void>;
 export declare const confirm: (message: string, options?: any) => Promise<boolean>;
 export declare const getRecentlyOpened: () => Promise<readonly string[]>;

package/dist/parts/RendererWorker/RendererWorker.js

@@ -82,6 +82,10 @@ export const sendMessagePortToMainAreaWorker = async (port, rpcId) => {
     const command = 'HandleMessagePort.handleMessagePort';
     await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToMainAreaWorker', port, command, rpcId);
 };
+export const sendMessagePortToTextSearchWorker = async (port, rpcId) => {
+    const command = 'HandleMessagePort.handleMessagePort';
+    await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextSearchWorker', port, command, rpcId);
+};
 export const sendMessagePortToErrorWorker = async (port, rpcId) => {
     const command = 'Errors.handleMessagePort';
     await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
@@ -179,6 +183,9 @@ export const sendMessagePortToChatNetworkWorker = async (port) => {
 export const sendMessagePortToChatToolWorker = async (port) => {
     await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatToolWorker', port, 'HandleMessagePort.handleMessagePort');
 };
+export const sendMessagePortToChatStorageWorker = async (port) => {
+    await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatStorageWorker', port, 'HandleMessagePort.handleMessagePort');
+};
 export const sendMessagePortToChatDebugViewWorker = async (port) => {
     await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatDebugViewWorker', port, 'HandleMessagePort.handleMessagePort');
 };

package/dist/parts/TextSearchWorker/TextSearchWorker.d.ts

@@ -0,0 +1,3 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const makeApiRequest: (options: any) => Promise<any>;
+export declare const makeStreamingApiRequest: (options: any) => Promise<any>;

package/dist/parts/TextSearchWorker/TextSearchWorker.js

@@ -0,0 +1,9 @@
+import { RpcId } from '@lvce-editor/constants';
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+export const { dispose, invoke, invokeAndTransfer, registerMockRpc, set } = RpcFactory.create(RpcId.TextSearchWorker);
+export const makeApiRequest = async (options) => {
+    return invoke('ChatNetwork.makeApiRequest', options);
+};
+export const makeStreamingApiRequest = async (options) => {
+    return invoke('ChatNetwork.makeStreamingApiRequest', options);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/rpc-registry",
-  "version": "9.9.0",
+  "version": "9.11.0",
   "description": "Rpc Registry",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
   "main": "dist/index.js",
   "dependencies": {
     "@lvce-editor/assert": "^1.5.1",
-    "@lvce-editor/constants": "^5.5.0",
+    "@lvce-editor/constants": "^5.7.0",
     "@lvce-editor/rpc": "^5.5.0"
   },
   "exports": "./dist/index.js",