Function createRPC

packages/agent-core/src/rpc/client.ts:31–105

()

) => Promise<RPCMethods<Other>>;

export function createRPC<Left extends Record<string, any>, Right extends Record<string, any>>(): [
  RPCClient<Left, Right>,
  RPCClient<Right, Left>,
] {
  const left = createControlledPromise<PromisableMethods<Left>>();
  const right = createControlledPromise<PromisableMethods<Right>>();

  function simulateNetwork<T>(data: T): Promise<T> {
    return new Promise((resolve) => {
      setTimeout(() => {
        const serialized = JSON.stringify(data);
        resolve(serialized === undefined ? (undefined as T) : JSON.parse(serialized));
      }, 0);
    });
  }

  function abortableRpc<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> {
    return signal === undefined ? promise : abortable(promise, signal);
  }

  function mapRpcFunction(fn: Function): Function {
    return async (payload: any, options?: RPCCallOptions) => {
      const signal = options?.signal;
      const rpcPayload = await simulateNetwork(payload);
      signal?.throwIfAborted();
      let response: RpcResponse;
      try {
        const handlerResult =
          signal === undefined ? fn(rpcPayload) : fn(rpcPayload, { signal });
        const value = await abortableRpc(Promise.resolve(handlerResult), signal);
        response = { ok: true, value };
      } catch (error) {
        signal?.throwIfAborted();
        response = { ok: false, error: toKimiErrorPayload(error) };
      }
      const remoteResponse = await simulateNetwork(response);
      if (remoteResponse.ok) return remoteResponse.value;
      throw fromKimiErrorPayload(remoteResponse.error);
    };
  }

  function bindAllFunctions<T extends Record<string, any>>(obj: T): T {
    const bound: Record<string, unknown> = {};
    let current: object | null = obj;

    while (current !== null && current !== Object.prototype) {
      for (const key of Object.getOwnPropertyNames(current)) {
        if (key === 'constructor' || Object.hasOwn(bound, key)) {
          continue;
        }

        const descriptor = Object.getOwnPropertyDescriptor(current, key);
        if (typeof descriptor?.value === 'function') {
          bound[key] = descriptor.value.bind(obj);
        }
      }

      current = Object.getPrototypeOf(current);