@xsai/shared 0.4.4 → 0.5.0-beta.1

package/dist/index.d.ts

@@ -1,6 +1,87 @@
+interface APICallErrorOptions extends ErrorOptions {
+    requestBody?: string;
+    response: Response;
+    responseBody?: string;
+}
+interface InvalidResponseErrorOptions extends ErrorOptions {
+    body?: unknown;
+    contentType?: null | string;
+    reason: InvalidResponseReason;
+    response?: Response;
+    responseBody?: string;
+}
+type InvalidResponseReason = 'empty_body' | 'invalid_body' | 'no_choices';
+interface InvalidToolCallErrorOptions extends ErrorOptions {
+    availableTools?: string[];
+    reason: InvalidToolCallReason;
+    toolCall: unknown;
+    toolName?: string;
+}
+type InvalidToolCallReason = 'missing_arguments' | 'missing_name' | 'unknown_tool';
+interface InvalidToolInputErrorOptions extends ErrorOptions {
+    toolInput: unknown;
+    toolName: string;
+}
+interface JSONParseErrorOptions extends ErrorOptions {
+    text: string;
+}
+interface RemoteAPIErrorOptions extends ErrorOptions {
+    response?: Response;
+    responseBody: string;
+}
+interface ToolExecutionErrorOptions extends InvalidToolInputErrorOptions {
+    toolCallId?: string;
+}
+type XSAIErrorCode = 'api_call_error' | 'invalid_response' | 'invalid_tool_call' | 'invalid_tool_input' | 'json_parse_error' | 'remote_api_error' | 'tool_execution_error';
 declare class XSAIError extends Error {
+    code: XSAIErrorCode;
+    constructor(message: string, code: XSAIErrorCode, options?: ErrorOptions);
+    static isInstance<T extends abstract new (...args: any[]) => XSAIError>(this: T, error: unknown): error is InstanceType<T>;
+}
+declare class APICallError extends XSAIError {
+    requestBody?: string;
+    response: Response;
+    responseBody?: string;
+    responseHeaders: Record<string, string>;
+    statusCode: number;
+    statusText: string;
+    url: string;
+    constructor(message: string, options: APICallErrorOptions);
+}
+declare class InvalidResponseError extends XSAIError {
+    body?: unknown;
+    contentType?: null | string;
+    reason: InvalidResponseErrorOptions['reason'];
+    response?: Response;
+    responseBody?: string;
+    constructor(message: string, options: InvalidResponseErrorOptions);
+}
+declare class InvalidToolCallError extends XSAIError {
+    availableTools?: string[];
+    reason: InvalidToolCallErrorOptions['reason'];
+    toolCall: unknown;
+    toolName?: string;
+    constructor(message: string, options: InvalidToolCallErrorOptions);
+}
+declare class InvalidToolInputError extends XSAIError {
+    toolInput: unknown;
+    toolName: string;
+    constructor(message: string, options: InvalidToolInputErrorOptions);
+}
+declare class JSONParseError extends XSAIError {
+    text: string;
+    constructor(message: string, options: JSONParseErrorOptions);
+}
+declare class RemoteAPIError extends XSAIError {
     response?: Response;
-    constructor(message: string, response?: Response, cause?: unknown);
+    responseBody: string;
+    constructor(message: string, options: RemoteAPIErrorOptions);
+}
+declare class ToolExecutionError extends XSAIError {
+    toolCallId?: string;
+    toolInput: unknown;
+    toolName: string;
+    constructor(message: string, options: ToolExecutionErrorOptions);
 }
 
 type Fetch = (input: URL, init: RequestInit) => Promise<Response>;
@@ -67,5 +148,5 @@ declare const responseJSON: <T>(res: Response) => Promise<T>;
 type TrampolineFn<T> = (() => Promise<TrampolineFn<T>> | TrampolineFn<T>) | Promise<T> | T;
 declare const trampoline: <T>(fn: () => Promise<TrampolineFn<T>> | TrampolineFn<T>) => Promise<T>;
 
-export { DelayedPromise, XSAIError, clean, objCamelToSnake, requestBody, requestHeaders, requestURL, responseCatch, responseJSON, strCamelToSnake, trampoline };
-export type { CommonRequestOptions, Fetch, TrampolineFn, WithUnknown };
+export { APICallError, DelayedPromise, InvalidResponseError, InvalidToolCallError, InvalidToolInputError, JSONParseError, RemoteAPIError, ToolExecutionError, XSAIError, clean, objCamelToSnake, requestBody, requestHeaders, requestURL, responseCatch, responseJSON, strCamelToSnake, trampoline };
+export type { APICallErrorOptions, CommonRequestOptions, Fetch, InvalidResponseErrorOptions, InvalidResponseReason, InvalidToolCallErrorOptions, InvalidToolCallReason, InvalidToolInputErrorOptions, JSONParseErrorOptions, RemoteAPIErrorOptions, ToolExecutionErrorOptions, TrampolineFn, WithUnknown, XSAIErrorCode };

package/dist/index.js

@@ -1,9 +1,79 @@
 class XSAIError extends Error {
+  code;
+  constructor(message, code, options = {}) {
+    super(message, { cause: options.cause });
+    this.code = code;
+    this.name = new.target.name;
+  }
+  static isInstance(error) {
+    return error instanceof this;
+  }
+}
+class APICallError extends XSAIError {
+  requestBody;
+  response;
+  responseBody;
+  responseHeaders;
+  statusCode;
+  statusText;
+  url;
+  constructor(message, options) {
+    super(message, "api_call_error", options);
+    this.requestBody = options.requestBody;
+    this.response = options.response;
+    this.responseBody = options.responseBody;
+    this.responseHeaders = Object.fromEntries(options.response.headers.entries());
+    this.statusCode = options.response.status;
+    this.statusText = options.response.statusText;
+    this.url = options.response.url;
+  }
+}
+class InvalidResponseError extends XSAIError {
+  body;
+  contentType;
+  response;
+  responseBody;
+  constructor(message, options) {
+    super(message, "invalid_response", options);
+    Object.assign(this, options);
+  }
+}
+class InvalidToolCallError extends XSAIError {
+  availableTools;
+  toolCall;
+  toolName;
+  constructor(message, options) {
+    super(message, "invalid_tool_call", options);
+    Object.assign(this, options);
+  }
+}
+class InvalidToolInputError extends XSAIError {
+  toolInput;
+  constructor(message, options) {
+    super(message, "invalid_tool_input", options);
+    Object.assign(this, options);
+  }
+}
+class JSONParseError extends XSAIError {
+  text;
+  constructor(message, options) {
+    super(message, "json_parse_error", options);
+    this.text = options.text;
+  }
+}
+class RemoteAPIError extends XSAIError {
   response;
-  constructor(message, response, cause) {
-    super(message, { cause });
-    this.name = "XSAIError";
-    this.response = response;
+  constructor(message, options) {
+    super(message, "remote_api_error", options);
+    Object.assign(this, options);
+  }
+}
+class ToolExecutionError extends XSAIError {
+  toolCallId;
+  toolInput;
+  constructor(message, options) {
+    super(message, "tool_execution_error", options);
+    Object.assign(this, options);
   }
 }
 
@@ -67,12 +137,28 @@ const requestURL = (path, baseURL) => {
 };
 
 const responseCatch = async (res) => {
-  if (!res.ok)
-    throw new XSAIError(`Remote sent ${res.status} response: ${await res.text()}`, res);
-  if (!res.body)
-    throw new XSAIError("Response body is empty from remote server", res);
-  if (!(res.body instanceof ReadableStream))
-    throw new XSAIError(`Expected Response body to be a ReadableStream, but got ${String(res.body)}; Content Type is ${res.headers.get("Content-Type")}`, res);
+  if (!res.ok) {
+    const responseBody = await res.text();
+    throw new APICallError(`Remote sent ${res.status} response: ${responseBody}`, {
+      response: res,
+      responseBody
+    });
+  }
+  if (!res.body) {
+    throw new InvalidResponseError("Response body is empty from remote server", {
+      reason: "empty_body",
+      response: res
+    });
+  }
+  if (!(res.body instanceof ReadableStream)) {
+    const contentType = res.headers.get("Content-Type");
+    throw new InvalidResponseError(`Expected Response body to be a ReadableStream, but got ${String(res.body)}; Content Type is ${contentType}`, {
+      body: res.body,
+      contentType,
+      reason: "invalid_body",
+      response: res
+    });
+  }
   return res;
 };
 
@@ -81,7 +167,10 @@ const responseJSON = async (res) => {
   try {
     return JSON.parse(text);
   } catch (cause) {
-    throw new XSAIError(`Failed to parse response, response body: ${text}`, res, cause);
+    throw new JSONParseError(`Failed to parse response, response body: ${text}`, {
+      cause,
+      text
+    });
   }
 };
 
@@ -92,4 +181,4 @@ const trampoline = async (fn) => {
   return result;
 };
 
-export { DelayedPromise, XSAIError, clean, objCamelToSnake, requestBody, requestHeaders, requestURL, responseCatch, responseJSON, strCamelToSnake, trampoline };
+export { APICallError, DelayedPromise, InvalidResponseError, InvalidToolCallError, InvalidToolInputError, JSONParseError, RemoteAPIError, ToolExecutionError, XSAIError, clean, objCamelToSnake, requestBody, requestHeaders, requestURL, responseCatch, responseJSON, strCamelToSnake, trampoline };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xsai/shared",
   "type": "module",
-  "version": "0.4.4",
+  "version": "0.5.0-beta.1",
   "description": "extra-small AI SDK.",
   "author": "Moeru AI",
   "license": "MIT",
@@ -29,7 +29,7 @@
     "dist"
   ],
   "devDependencies": {
-    "@moeru/std": "^0.1.0-beta.15"
+    "@moeru/std": "^0.1.0-beta.17"
   },
   "scripts": {
     "build": "pkgroll"