@xalia/agent 0.6.10 → 0.6.11

package/src/chat/utils/responseAwaiter.ts

@@ -1,181 +0,0 @@
-import { getLogger } from "@xalia/xmcp/sdk";
-
-const DEFAULT_TIMEOUT_MS: number = 10000;
-
-type ServerMsg = { type: string };
-// Messages of type S which also have a message field.  The message
-// representing an error should be of this type.
-type ServerErr<S> = Extract<S, { message: string }>;
-
-type IdExtractor<S extends ServerMsg> = (msg: S) => string | undefined;
-
-type WaitingEntry<ServerMessageT> = {
-  resolve: (s: ServerMessageT) => void;
-  error: (e: Error) => void;
-  timeoutId: NodeJS.Timeout;
-};
-
-const logger = getLogger();
-
-function defaultImmediate<T>(x: T): T {
-  return x;
-}
-
-/**
- *
- * Handles response messages and timeouts for client request messages.
- *
- * Create a ResponseAwaiter for a specific class of queries
- *
- *   this.responseHandler = new ResponseAwaiter<SomeRequest, SomeResponse>(
- *     (msg: SomeResponse) => msg.client_message_id;
- *   )
- *
- * Use as follows:
- *
- *   ```
- *   someRequest(data: string): Promise<string> {
- *     const client_message_id = uuidv4();
- *
- *     // Create a request message and send it to the backend
- *     const msg = { type: "some_request, client_message_id, ... };
- *     this.sendMessage(msg);
- *
- *     // Get a Promise representing the response to this message, which
- *     // we can await.
- *     const response =
- *       await this.responseHandler.waitForResponse(client_message_id);
- *
- *     // Perform any processing on the response
- *     return response.response_data;
- *   }
- *   ```
- *
- * ResponseAwaiter must be informed of relevant messages in order to resolve
- * responses:
- *
- *   ```
- *   onMessage(msg: ServerToClient) {
- *     switch (msg.type) {
- *       ...
- *       case "some_response":
- *         this.responseHandler.onMessage(msg); // resolve pending promises
- *         break;
- *       ...
- *     }
- *   }
- *   ```
- *
- * If some actions need to happen immediately on receipt of the message,
- * instead of when the `Promise.resolve` function is resolved, add an
- * `immediateAction` callback, which can optionally transfrom `ServerMsgT`
- * into `FinalResponseT` to be passed back by `waitForResponse`.
- */
-export class ResponseAwaiter<
-  ServerMsgT extends ServerMsg,
-  FinalResponseT = ServerMsgT,
-> {
-  readonly waiting: Map<string, WaitingEntry<FinalResponseT>>;
-  readonly idExtractor: IdExtractor<ServerMsgT>;
-  readonly immediateAction: (x: ServerMsgT) => FinalResponseT;
-  readonly timeoutMS: number;
-  readonly errorType: ServerErr<ServerMsgT>["type"] | undefined;
-
-  /**
-   * errorType: the type field of the message which represents an error.
-   */
-  private constructor(
-    // value of the `type` field of an error message type,
-    // e.g. "session_error". Compiler should ensure that the `ServerMsgT` with
-    // this `type` field at least has a `message` field.
-    errorType: undefined | ServerErr<ServerMsgT>["type"],
-    idExtractor: IdExtractor<ServerMsgT>,
-    immediateAction: (x: ServerMsgT) => FinalResponseT,
-    timeoutMS: number = DEFAULT_TIMEOUT_MS
-  ) {
-    this.waiting = new Map();
-    this.idExtractor = idExtractor;
-    this.immediateAction = immediateAction;
-    this.timeoutMS = timeoutMS;
-    this.errorType = errorType;
-  }
-
-  static init<S extends ServerMsg>(
-    errorType: undefined | ServerErr<S>["type"],
-    idExtractor: IdExtractor<S>,
-    timeoutMS: number = DEFAULT_TIMEOUT_MS
-  ): ResponseAwaiter<S, S> {
-    return new ResponseAwaiter(
-      errorType,
-      idExtractor,
-      defaultImmediate,
-      timeoutMS
-    );
-  }
-
-  static initWithImmediate<S extends ServerMsg, F>(
-    errorType: undefined | ServerErr<S>["type"],
-    idExtractor: IdExtractor<S>,
-    immediateAction: (x: S) => F,
-    timeoutMS: number = DEFAULT_TIMEOUT_MS
-  ): ResponseAwaiter<S, F> {
-    return new ResponseAwaiter(
-      errorType,
-      idExtractor,
-      immediateAction,
-      timeoutMS
-    );
-  }
-
-  /**
-   * Given a request message, return a promise representing the corresponding
-   * response message from the server.
-   */
-  waitForResponse(msgId: string): Promise<FinalResponseT> {
-    return new Promise<FinalResponseT>((resolve, error) => {
-      const timeoutId = setTimeout(() => {
-        const waiting = this.waiting.get(msgId);
-        if (!waiting) {
-          logger.warn(`[ResponseAwaiter] timeout for ${msgId} with no entry`);
-          return;
-        }
-        this.waiting.delete(msgId);
-        logger.warn(`[ResponseAwaiter] timeout for client_msg_id ${msgId}`);
-        error(new Error(`timeout for client_msg_id ${msgId}`));
-      }, this.timeoutMS);
-
-      this.waiting.set(msgId, { resolve, error, timeoutId });
-    });
-  }
-
-  waitingForId(msgId: string): boolean {
-    return this.waiting.has(msgId);
-  }
-
-  /**
-   * Pass response (and error) messages in here.  Returns `true` if the
-   * message was consumed.  Otherwise `false`.
-   */
-  onMessage(msg: ServerMsgT): boolean {
-    const msgId = this.idExtractor(msg);
-    if (!msgId) {
-      return false;
-    }
-    const waiting = this.waiting.get(msgId);
-    if (!waiting) {
-      logger.warn(
-        `[ResponseAwaiter] resolve for ${msgId} with no entry (timeout?)`
-      );
-      return false;
-    }
-
-    clearTimeout(waiting.timeoutId);
-    this.waiting.delete(msgId);
-    if (this.errorType && msg.type === this.errorType) {
-      waiting.error(new Error((msg as ServerErr<ServerMsgT>).message));
-    } else {
-      waiting.resolve(this.immediateAction(msg));
-    }
-    return true;
-  }
-}

package/src/chat/utils/userResolver.ts

@@ -1,48 +0,0 @@
-import { getLogger } from "@xalia/xmcp/sdk";
-import { Database, UserData } from "../data/database";
-
-const logger = getLogger();
-
-/**
- * Validates and resolves an email or UUID to a valid user UUID.
- * @param db - Database instance for user lookups
- * @param input - Either an email address or UUID string
- * @returns Valid user UUID if found, undefined otherwise
- */
-export async function resolveUserIdentifier(
-  db: Database,
-  input: string
-): Promise<UserData | undefined> {
-  // Check if input looks like a UUID (basic format check)
-  const uuidRegex =
-    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-
-  if (uuidRegex.test(input)) {
-    // Input looks like a UUID - verify it exists
-    try {
-      return await db.getUserFromUuid(input);
-    } catch (error) {
-      logger.debug(`UUID validation failed for ${input}: ${String(error)}`);
-    }
-  } else if (input === "chatuser0" || input === "chatuser1") {
-    // speicial case for test users
-    return {
-      uuid: input,
-      nickname: input,
-      email: `${input}@test.com`,
-      timezone: "UTC",
-    };
-  } else if (emailRegex.test(input)) {
-    // Input looks like an email - find corresponding UUID
-    try {
-      const userData = await db.getUserByEmail(input);
-      return userData;
-    } catch (error) {
-      logger.debug(`Email lookup failed for ${input}: ${String(error)}`);
-    }
-  }
-
-  // Input doesn't match expected formats or user not found
-  return undefined;
-}

package/src/chat/utils/websocket.ts

@@ -1,16 +0,0 @@
-// Browser and Node.js Universal WebSocket wrapper
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-
-let WSClass: typeof WebSocket;
-
-if (typeof window !== "undefined" && typeof window.WebSocket !== "undefined") {
-  // Running in browser
-  WSClass = window.WebSocket;
-} else {
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const ws = require("ws");
-  WSClass = ws.WebSocket as unknown as typeof WebSocket;
-}
-
-export { WSClass as WebSocket };