dev-ai

package.json

@@ -97,7 +97,7 @@
 		"katex": "^0.16.21",
 		"marked": "^14.1.3",
 		"minimist": "^1.2.8",
-		"openai": "^4.28.0",
+		"openai": "^4.80.1",
 		"prosemirror-history": "^1.4.1",
 		"prosemirror-model": "^1.18.1",
 		"prosemirror-state": "^1.4.2",

src/base/common/error.ts

@@ -2,7 +2,7 @@ import { IDisposable, toDisposable } from "src/base/common/dispose";
 import { Result, err, ok } from "src/base/common/result";
 import { mixin } from "src/base/common/utilities/object";
 import { errorToMessage, panic } from "src/base/common/utilities/panic";
-import { isPromise } from "src/base/common/utilities/type";
+import { isObject, isPromise, isString } from "src/base/common/utilities/type";
 
 type IErrorCallback = (error: any) => void;
 type IErrorListener = IErrorCallback;
@@ -319,3 +319,172 @@ export class Stacktrace {
         return this;
     }
 }
+
+/**
+ * A standardized Error for LLM operations, encapsulating both
+ * provider-specific errors (e.g. OpenAI) and internal errors.
+ */
+export class AIError extends Error {
+
+    // [fields]
+
+    /** Indicates the name of the LLM model caused the error */
+    public readonly modelName: string | null;
+
+    /** Error category for quick classification */
+    public readonly errorCategory: 
+        | 'API'
+        | 'Network'
+        | 'Auth'
+        | 'Client'
+        | 'Internal'
+        | 'Unknown';
+
+    /** HTTP status code (if applicable) */
+    public readonly status?: number;
+
+    /** HTTP headers from the response (if applicable) */
+    public readonly headers?: Record<string, string>;
+
+    /** Original error object (if available) */
+    public readonly internal?: unknown;
+
+    /** Provider-specific error code (e.g. 'invalid_api_key') */
+    public readonly code?: string;
+
+    /** Request ID from response headers (if available) */
+    public readonly requestId?: string;
+
+    // [constructor]
+
+    constructor(modelName: string | null, rawError: unknown) {
+        const { message, metadata } = AIError.__parseRawError(rawError);
+        super(message);
+
+        this.modelName = modelName;
+        this.errorCategory = metadata.category;
+        this.internal = metadata.internal;
+
+        // API Error metadata
+        this.status = metadata.status;
+        this.headers = metadata.headers;
+        this.code = metadata.code;
+        this.requestId = metadata.headers?.['x-request-id'];
+    }
+
+    // [static methods]
+
+    private static __parseRawError(raw: unknown): {
+        message: string;
+        metadata: __ErrorParseMetadata;
+    } {
+
+        // raw string, simple return
+        if (isString(raw)) {
+            return { 
+                message: raw, 
+                metadata: { category: 'Unknown' } 
+            };
+        }
+
+        // non object, no can do here.
+        if (!isObject(raw)) {
+            return {
+                message: 'Unknown non-object error',
+                metadata: { 
+                    category: 'Unknown', 
+                    internal: raw 
+                }
+            };
+        }
+
+        // default metadata
+        const metadata: __ErrorParseMetadata = {
+            category: 'Unknown',
+            status: undefined,
+            headers: undefined,
+            code: undefined,
+            internal: raw
+        };
+
+        // obtain metadata
+        const status = Number(raw['status']) ?? undefined;
+        const headers = raw['headers'];
+        const code = this.__safeGetCode(raw);
+        const message = this.__getHumanMessage(raw, status, code);
+
+        // clean up
+        metadata.status = status;
+        metadata.headers = headers;
+        metadata.code = code;
+        metadata.category = this.__determineCategory(raw, status, code);
+
+        return { message, metadata };
+    }
+
+    private static __determineCategory(
+        raw: object,
+        status?: number,
+        code?: string
+    ): AIError['errorCategory'] {
+
+        // Network errors (timeout, connection issues)
+        if (raw instanceof Error && [
+            'ETIMEDOUT', 
+            'ECONNREFUSED', 
+            'ENOTFOUND'
+        ].some(code => code === raw['code'])
+        ) {
+            return 'Network';
+        }
+
+        // API errors classification
+        if (status) {
+            if (status === 401) return 'Auth';
+            if (status === 429) return 'API';
+            if (status >= 400 && status < 500) return 'Client';
+            if (status >= 500) return 'Internal';
+        }
+
+        // OpenAI-style error codes
+        if (code) {
+            if (code.includes('invalid_api')) return 'Auth';
+            if (code.includes('rate_limit')) return 'API';
+        }
+
+        return 'Unknown';
+    }
+
+    private static __getHumanMessage(
+        raw: object,
+        status?: number,
+        code?: string
+    ): string {
+        const baseMessage = raw['message'] || 'Unknown error';
+        const parts: string[] = [];
+
+        if (status) parts.push(`Status: ${status}`);
+        if (code) parts.push(`Code: ${code}`);
+
+        return parts.length > 0 
+            ? `${baseMessage} (${parts.join(', ')})` 
+            : baseMessage;
+    }
+
+    private static __safeGetCode(raw: object): string | undefined {
+        const codeSources = [
+            (<any>raw).code,
+            (<any>raw).error?.code,
+            (<any>raw).body?.error?.code
+        ];
+        return codeSources.find(v => isString(v));
+    }
+}
+
+type __ErrorParseMetadata = {
+    category: AIError['errorCategory'];
+    status?: number;
+    headers?: Record<string, string>;
+    code?: string;
+    internal?: unknown;
+};

src/base/common/json.ts

@@ -145,7 +145,7 @@ interface IJsonSchemaForString extends IJsonSchemaBase<'string'> {
     /** The maximum length of the string. */
     maxLength?: number;
 
-    /** The predefined format of the string. Example: 'email', 'phone number', 'post address' etc. */
+    /** The predefined format of the string (written Regular Expression). Example: 'email', 'phone number', 'post address' etc. */
     format?: string;
 
     /** Regular expression to match the valid string. */

src/base/common/utilities/panic.ts

@@ -1,20 +1,12 @@
+import { IpcErrorTag } from "src/base/common/error";
 import type { ArrayToUnion } from "src/base/common/utilities/type";
 
 /**
  * To prevent potential circular dependency issues due to the wide use of `panic` 
- * throughout the program, this function has been relocated to a separate file 
+ * throughout the program, these functions has been relocated to a separate file 
  * that does not import any other files.
  */
 
-function __stringifySafe(obj: unknown): string {
-    try {
-        // eslint-disable-next-line local/code-no-json-stringify
-        return JSON.stringify(obj);
-    } catch (err) {
-        return '';
-    }
-}
-
 /**
  * @description Panics the program by throwing an error with the provided message.
  *
@@ -31,7 +23,7 @@ export function panic(error: unknown): never {
         throw new Error('unknown panic error');
     }
 
-    if (error instanceof Error) {
+    if (isError(error)) {
         // eslint-disable-next-line local/code-no-throw
         throw error;
     }
@@ -40,6 +32,29 @@ export function panic(error: unknown): never {
     throw new Error(errorToMessage(error));
 }
 
+/**
+ * @description An ipc-safe function to check the given object is {@link Error} 
+ * or not.
+ */
+export function isError(obj: any): obj is Error {
+    if (obj instanceof Error) {
+        return true;
+    }
+
+    // not even object
+    if (typeof obj !== "object" || obj === null) {
+        return false;
+    }
+
+    // check for standard errors
+    if (typeof obj['name'] === 'string' && typeof obj['message'] === 'string') {
+        return true;
+    }
+
+    // check for IPC-converted errors
+    return obj?.[IpcErrorTag] === null;
+}
+
 /**
  * @description Asserts that the provided object is neither `undefined` nor 
  * `null`. 
@@ -223,3 +238,12 @@ function __stackToMessage(stack: any): string {
         return stack;
     }
 }
+
+function __stringifySafe(obj: unknown): string {
+    try {
+        // eslint-disable-next-line local/code-no-json-stringify
+        return JSON.stringify(obj);
+    } catch (err) {
+        return '';
+    }
+}

src/base/common/utilities/type.ts

@@ -1,3 +1,4 @@
+import type { Register } from "src/base/common/event";
 
 /**
  * Represents all the falsy value in JavaScript.
@@ -445,6 +446,21 @@ export type Promisify<T> = {
     : T[K]
 };
 
+/**
+ * Ensure all functions in an object all return {@link Promise} (event register
+ * are ignored).
+ */
+export type AsyncOnly<T> = {
+    [K in keyof T]: 
+      T[K] extends Register<any> 
+        ? T[K] // keep event-register
+        : T[K] extends (...args: any[]) => infer R 
+            ? R extends Promise<any> 
+                ? T[K] // only allow async function
+                : never // no sync function
+            : T[K]; // non-functional remain the same
+  };
+
 /**
  * Split string into a tuple by a deliminator.
  */

src/code/browser/browser.ts

@@ -70,7 +70,7 @@ export class BrowserInstance extends Disposable implements IBrowserService {
 
         // alert error from main process
         onMainProcess(IpcChannel.rendererAlertError, error => {
-            ErrorHandler.onUnexpectedError(error);
+            this.commandService.executeCommand(AllCommands.alertError, 'MainProcess', error);
         });
 
         // execute command request from main process

src/code/browser/inspector/inspectorItemRenderer.ts

@@ -9,6 +9,10 @@ import { FuzzyScore } from "src/base/common/fuzzy";
 import { isBoolean, isNullable, isNumber, isString } from "src/base/common/utilities/type";
 import { InspectorItem } from "src/code/browser/inspector/inspectorTree";
 import { IConfigurationService, ConfigurationModuleType } from "src/platform/configuration/common/configuration";
+import { IEncryptionService } from "src/platform/encryption/common/encryptionService";
+import { IHostService } from "src/platform/host/common/hostService";
+import { InspectorDataType } from "src/platform/inspector/common/inspector";
+import { StatusKey } from "src/platform/status/common/status";
 
 interface IInspectorItemMetadata extends IListViewMetadata {
     readonly keyElement: HTMLElement;
@@ -21,7 +25,10 @@ export class InspectorItemRenderer implements ITreeListRenderer<InspectorItem, F
     public readonly type: RendererType = InspectorRendererType;
 
     constructor(
-        private readonly configurationService: IConfigurationService,
+        private readonly getCurrentView: () => InspectorDataType | undefined,
+        @IConfigurationService private readonly configurationService: IConfigurationService,
+        @IHostService private readonly hostService: IHostService,
+        @IEncryptionService private readonly encryptionService: IEncryptionService,
     ) {}
 
     public render(element: HTMLElement): IInspectorItemMetadata {
@@ -63,7 +70,7 @@ export class InspectorItemRenderer implements ITreeListRenderer<InspectorItem, F
         }
         // editable
         else {
-            valuePart.addEventListener('change', e => {
+            valuePart.addEventListener('change', async e => {
                 const raw = valuePart.value;
                 const rawLower = raw.toLowerCase();
                 let value: any;
@@ -91,7 +98,18 @@ export class InspectorItemRenderer implements ITreeListRenderer<InspectorItem, F
                 else {
                     value = raw;
                 }
-                this.configurationService.set(data.id!, value, { type: ConfigurationModuleType.User });
+
+                const currView = this.getCurrentView();
+                if (currView === InspectorDataType.Status) {
+                    // special handling: write these values as encrypted
+                    if (data.id === StatusKey.textAPIKey) {
+                        value = await this.encryptionService.encrypt(value);
+                    }
+                    this.hostService.setApplicationStatus(data.id as StatusKey, value);
+                } else if (currView === InspectorDataType.Configuration) {
+                    this.configurationService.set(data.id!, value, { type: ConfigurationModuleType.User });
+                }
+
                 e.stopPropagation();
             });
         }