get_data_latency

Instructions

Implementation Reference

• src/index.ts:2029-2038 (registration)

  Tool registration for 'get_data_latency' using registerTool. Defined at line 2029 with description at 2031, inputSchema {} (no params) at 2032, outputSchema ObjectOutputSchema at 2033, and handler at lines 2034-2037 that calls api().dataQuality.latency() and formats the response.

  registerTool(
    "get_data_latency",
    "Get current latency metrics for supported venue APIs. Returns WebSocket latency (current, 1h avg, 24h avg), REST API latency, and data freshness lag per data type (orderbook, fills, funding, OI).",
    {},
    ObjectOutputSchema,
    async () => {
      const data = await api().dataQuality.latency();
      return formatResponse(data);
    }
  );

• src/index.ts:2034-2037 (handler)

  The actual handler function for get_data_latency. It calls the SDK method api().dataQuality.latency() and wraps the result via formatResponse() which formats as both text and structured content.

  async () => {
    const data = await api().dataQuality.latency();
    return formatResponse(data);
  }

• src/index.ts:139-141 (schema)

  Output schema ObjectOutputSchema used by get_data_latency: returns a single object with a 'data' field.

  const ObjectOutputSchema: ZodRawShape = {
    data: z.record(z.unknown()).describe("Result data object"),
  };

• src/index.ts:328-358 (helper)

  The registerTool helper function that wraps the SDK call and adds API key guard, error handling, and schema validation for every tool including get_data_latency.

  function registerTool(
    name: string,
    description: string,
    inputSchema: ZodRawShape,
    outputSchema: ZodRawShape,
    handler: (params: any) => Promise<McpContent>
  ): void {
    server.registerTool(
      name,
      {
        description,
        inputSchema,
        outputSchema,
        annotations: TOOL_ANNOTATIONS,
      },
      async (params: any) => {
        if (!client) {
          return {
            content: [{ type: "text" as const, text: MISSING_KEY_MESSAGE }],
            isError: true,
          };
        }
        try {
          return await handler(params);
        } catch (err) {
          const error = err instanceof OxArchiveError ? err : new OxArchiveError(String(err), 500);
          return formatError(error);
        }
      }
    );
  }

• src/index.ts:244-280 (helper)

  The formatResponse helper used by the handler to format the latency data into both text and structuredContent output.

  function formatResponse(
    data: unknown,
    meta?: { nextCursor?: string; paginated?: boolean }
  ): McpContent {
    let header = "";
    let body: unknown = data;
  
    if (Array.isArray(data)) {
      header = `Returned ${data.length} record${data.length !== 1 ? "s" : ""}`;
      // Only truncate paginated endpoints — the user can cursor for more.
      // Non-paginated results (instruments, current snapshots) return everything.
      if (meta?.paginated && data.length > MAX_PAGINATED_ITEMS) {
        header += ` (showing first ${MAX_PAGINATED_ITEMS}; use cursor to get more)`;
        body = data.slice(0, MAX_PAGINATED_ITEMS);
      }
    }
  
    if (meta?.nextCursor) {
      header += header
        ? `\nNext page cursor: "${meta.nextCursor}"`
        : `Use cursor: "${meta.nextCursor}" to get the next page`;
    }
  
    const json = JSON.stringify(body, null, 2);
    const text = header ? `${header}\n\n${json}` : json;
  
    // Build structuredContent matching ListOutputSchema or ObjectOutputSchema
    const structuredContent: Record<string, unknown> = Array.isArray(data)
      ? {
          records: body,
          count: data.length,
          ...(meta?.nextCursor && { nextCursor: meta.nextCursor }),
        }
      : { data };
  
    return { content: [{ type: "text", text }], structuredContent };
  }