@mycadet/assistant 0.12.10 → 0.13.0

package/src/tools/network/__tests__/cloud-search-proxy.test.ts

@@ -1,282 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-interface MockCloudClient {
-  cloudAssistantId: string;
-  fetch: ReturnType<typeof mock>;
-}
-
-let mockClient: MockCloudClient | null = null;
-
-mock.module("../../../cloud/client.js", () => ({
-  CadetCloudClient: {
-    create: async () => mockClient,
-  },
-}));
-
-import { callManagedSearchProxy } from "../cloud-search-proxy.js";
-
-describe("callManagedSearchProxy", () => {
-  beforeEach(() => {
-    mockClient = {
-      cloudAssistantId: "asst-123",
-      fetch: mock(async () => {
-        return new Response(
-          JSON.stringify({
-            status: 200,
-            headers: { "content-type": "application/json" },
-            body: { web: { results: [] } },
-          }),
-          { status: 200, headers: { "content-type": "application/json" } },
-        );
-      }),
-    };
-  });
-
-  afterEach(() => {
-    mockClient = null;
-  });
-
-  test("posts to the cloud search proxy endpoint for the assistant and provider", async () => {
-    await callManagedSearchProxy("brave", {
-      method: "GET",
-      path: "/res/v1/web/search",
-    });
-
-    expect(mockClient!.fetch).toHaveBeenCalledTimes(1);
-    expect(mockClient!.fetch.mock.calls[0][0]).toBe(
-      "/v1/assistants/asst-123/cloud-search-proxy/brave/",
-    );
-  });
-
-  test("encodes URL path segments", async () => {
-    mockClient!.cloudAssistantId = "asst/123";
-
-    await callManagedSearchProxy("brave", {
-      method: "GET",
-      path: "/res/v1/web/search",
-    });
-
-    expect(mockClient!.fetch.mock.calls[0][0]).toBe(
-      "/v1/assistants/asst%2F123/cloud-search-proxy/brave/",
-    );
-  });
-
-  test("sends the cloud contract request envelope", async () => {
-    await callManagedSearchProxy("brave", {
-      method: "GET",
-      path: "/res/v1/web/search",
-      query: {
-        q: "kimi k2 fireworks web search",
-        count: "10",
-        offset: "0",
-        freshness: "pw",
-      },
-      headers: {
-        Accept: "application/json",
-      },
-      body: null,
-    });
-
-    const init = mockClient!.fetch.mock.calls[0][1] as RequestInit;
-    expect(init.method).toBe("POST");
-    expect(new Headers(init.headers).get("Content-Type")).toBe(
-      "application/json",
-    );
-    expect(JSON.parse(init.body as string)).toEqual({
-      request: {
-        method: "GET",
-        path: "/res/v1/web/search",
-        query: {
-          q: "kimi k2 fireworks web search",
-          count: "10",
-          offset: "0",
-          freshness: "pw",
-        },
-        headers: {
-          Accept: "application/json",
-        },
-        body: null,
-      },
-    });
-  });
-
-  test("fills absent query, headers, and body with contract defaults", async () => {
-    await callManagedSearchProxy("brave", {
-      method: "GET",
-      path: "/res/v1/web/search",
-    });
-
-    const init = mockClient!.fetch.mock.calls[0][1] as RequestInit;
-    expect(JSON.parse(init.body as string)).toEqual({
-      request: {
-        method: "GET",
-        path: "/res/v1/web/search",
-        query: {},
-        headers: {},
-        body: null,
-      },
-    });
-  });
-
-  test("passes the abort signal through to platform fetch", async () => {
-    const controller = new AbortController();
-
-    await callManagedSearchProxy(
-      "brave",
-      {
-        method: "GET",
-        path: "/res/v1/web/search",
-      },
-      controller.signal,
-    );
-
-    const init = mockClient!.fetch.mock.calls[0][1] as RequestInit;
-    expect(init.signal).toBe(controller.signal);
-  });
-
-  test("parses the response envelope and preserves provider JSON body", async () => {
-    const providerBody = {
-      web: {
-        results: [{ title: "Result", url: "https://example.com" }],
-      },
-    };
-    mockClient!.fetch = mock(async () => {
-      return new Response(
-        JSON.stringify({
-          status: 200,
-          headers: {
-            "content-type": "application/json",
-            "x-request-id": "req-123",
-          },
-          body: providerBody,
-        }),
-        { status: 200, headers: { "content-type": "application/json" } },
-      );
-    });
-
-    const result = await callManagedSearchProxy("brave", {
-      method: "GET",
-      path: "/res/v1/web/search",
-    });
-
-    expect(result).toEqual({
-      ok: true,
-      status: 200,
-      headers: {
-        "content-type": "application/json",
-        "x-request-id": "req-123",
-      },
-      body: providerBody,
-    });
-  });
-
-  test("returns a typed platform error for non-2xx platform responses", async () => {
-    mockClient!.fetch = mock(async () => {
-      return new Response(
-        JSON.stringify({ detail: "unsupported cloud search provider" }),
-        {
-          status: 400,
-          headers: {
-            "content-type": "application/json",
-            "x-platform-request-id": "platform-req-123",
-          },
-        },
-      );
-    });
-
-    const result = await callManagedSearchProxy("brave", {
-      method: "GET",
-      path: "/res/v1/web/search",
-    });
-
-    expect(result).toEqual({
-      ok: false,
-      kind: "platform-error",
-      status: 400,
-      headers: {
-        "content-type": "application/json",
-        "x-platform-request-id": "platform-req-123",
-      },
-      body: { detail: "unsupported cloud search provider" },
-      message:
-        "Cloud search proxy returned status 400: unsupported cloud search provider",
-    });
-  });
-
-  test("preserves insufficient-balance platform errors", async () => {
-    mockClient!.fetch = mock(async () => {
-      return new Response(JSON.stringify({ detail: "Insufficient balance" }), {
-        status: 402,
-        headers: { "content-type": "application/json" },
-      });
-    });
-
-    const result = await callManagedSearchProxy("brave", {
-      method: "GET",
-      path: "/res/v1/web/search",
-    });
-
-    expect(result).toEqual({
-      ok: false,
-      kind: "platform-error",
-      status: 402,
-      headers: {
-        "content-type": "application/json",
-      },
-      body: { detail: "Insufficient balance" },
-      message: "Cloud search proxy returned status 402: Insufficient balance",
-    });
-  });
-
-  test("returns unavailable when platform context is missing", async () => {
-    mockClient = null;
-
-    const result = await callManagedSearchProxy("brave", {
-      method: "GET",
-      path: "/res/v1/web/search",
-    });
-
-    expect(result).toEqual({
-      ok: false,
-      kind: "unavailable",
-      message: "Cloud search proxy is unavailable in this environment.",
-    });
-  });
-
-  test("returns unavailable when platform assistant ID is missing", async () => {
-    mockClient!.cloudAssistantId = "";
-
-    const result = await callManagedSearchProxy("brave", {
-      method: "GET",
-      path: "/res/v1/web/search",
-    });
-
-    expect(result).toEqual({
-      ok: false,
-      kind: "unavailable",
-      message:
-        "Cloud search proxy is unavailable: platform assistant ID is missing.",
-    });
-  });
-
-  test("returns an invalid-response result for malformed platform envelopes", async () => {
-    mockClient!.fetch = mock(async () => {
-      return new Response(JSON.stringify({ ok: true }), {
-        status: 200,
-        headers: { "content-type": "application/json" },
-      });
-    });
-
-    const result = await callManagedSearchProxy("brave", {
-      method: "GET",
-      path: "/res/v1/web/search",
-    });
-
-    expect(result).toEqual({
-      ok: false,
-      kind: "invalid-response",
-      body: { ok: true },
-      message: "Cloud search proxy returned an invalid response envelope.",
-    });
-  });
-});

package/src/tools/network/cloud-search-proxy.ts

@@ -1,211 +0,0 @@
-import { CadetCloudClient } from "../../cloud/client.js";
-
-export type ManagedSearchProxyProvider = "brave";
-
-export interface ManagedSearchProxyRequest {
-  method: string;
-  path: string;
-  query?: Record<string, string>;
-  headers?: Record<string, string>;
-  body?: unknown;
-}
-
-export interface ManagedSearchProxyResponse {
-  status: number;
-  headers: Record<string, string>;
-  body: unknown;
-}
-
-export type ManagedSearchProxyResult =
-  | ({ ok: true } & ManagedSearchProxyResponse)
-  | {
-      ok: false;
-      kind: "unavailable";
-      message: string;
-    }
-  | {
-      ok: false;
-      kind: "platform-error";
-      status: number;
-      headers: Record<string, string>;
-      body: unknown;
-      message: string;
-    }
-  | {
-      ok: false;
-      kind: "invalid-response";
-      body: unknown;
-      message: string;
-    };
-
-interface ManagedSearchProxyEnvelope {
-  request: {
-    method: string;
-    path: string;
-    query: Record<string, string>;
-    headers: Record<string, string>;
-    body: unknown;
-  };
-}
-
-/**
- * Whether the cloud search proxy can be dialed at all: a cloud client
- * exists and carries an assistant id. Mirrors `managedSpeechAvailable()`.
- * Callers use this to decide between the proxy and the BYOK chain *before*
- * attempting a call — the same two conditions `callManagedSearchProxy`
- * reports as `kind: "unavailable"`.
- */
-export async function managedSearchAvailable(): Promise<boolean> {
-  const client = await CadetCloudClient.create();
-  return client !== null && Boolean(client.cloudAssistantId);
-}
-
-export async function callManagedSearchProxy(
-  provider: ManagedSearchProxyProvider,
-  request: ManagedSearchProxyRequest,
-  signal?: AbortSignal,
-): Promise<ManagedSearchProxyResult> {
-  const client = await CadetCloudClient.create();
-  if (!client) {
-    return {
-      ok: false,
-      kind: "unavailable",
-      message: "Cloud search proxy is unavailable in this environment.",
-    };
-  }
-
-  if (!client.cloudAssistantId) {
-    return {
-      ok: false,
-      kind: "unavailable",
-      message:
-        "Cloud search proxy is unavailable: platform assistant ID is missing.",
-    };
-  }
-
-  const path = `/v1/assistants/${encodeURIComponent(
-    client.cloudAssistantId,
-  )}/cloud-search-proxy/${encodeURIComponent(provider)}/`;
-
-  const envelope: ManagedSearchProxyEnvelope = {
-    request: {
-      method: request.method,
-      path: request.path,
-      query: request.query ?? {},
-      headers: request.headers ?? {},
-      body: request.body ?? null,
-    },
-  };
-
-  const response = await client.fetch(path, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(envelope),
-    signal,
-  });
-
-  if (!response.ok) {
-    const body = await readResponseBody(response);
-    return {
-      ok: false,
-      kind: "platform-error",
-      status: response.status,
-      headers: responseHeadersToRecord(response.headers),
-      body,
-      message: platformErrorMessage(response.status, body),
-    };
-  }
-
-  const body = await readResponseBody(response);
-  if (!isManagedSearchProxyResponse(body)) {
-    return {
-      ok: false,
-      kind: "invalid-response",
-      body,
-      message: "Cloud search proxy returned an invalid response envelope.",
-    };
-  }
-
-  return {
-    ok: true,
-    status: body.status,
-    headers: body.headers,
-    body: body.body,
-  };
-}
-
-function isManagedSearchProxyResponse(
-  value: unknown,
-): value is ManagedSearchProxyResponse {
-  if (!isRecord(value)) {
-    return false;
-  }
-  if (typeof value.status !== "number") {
-    return false;
-  }
-  if (!isStringRecord(value.headers)) {
-    return false;
-  }
-  return "body" in value;
-}
-
-async function readResponseBody(response: Response): Promise<unknown> {
-  const text = await response.text().catch(() => "");
-  if (!text) {
-    return null;
-  }
-
-  const contentType = response.headers.get("content-type") ?? "";
-  if (contentType.includes("application/json")) {
-    try {
-      return JSON.parse(text);
-    } catch {
-      return text;
-    }
-  }
-
-  return text;
-}
-
-function responseHeadersToRecord(headers: Headers): Record<string, string> {
-  return Object.fromEntries(headers.entries());
-}
-
-function platformErrorMessage(status: number, body: unknown): string {
-  const detail = extractErrorDetail(body);
-  if (detail) {
-    return `Cloud search proxy returned status ${status}: ${detail}`;
-  }
-  return `Cloud search proxy returned status ${status}.`;
-}
-
-function extractErrorDetail(body: unknown): string | undefined {
-  if (typeof body === "string") {
-    return body || undefined;
-  }
-  if (!isRecord(body)) {
-    return undefined;
-  }
-
-  for (const key of ["detail", "error", "message"]) {
-    const value = body[key];
-    if (typeof value === "string" && value) {
-      return value;
-    }
-  }
-
-  return undefined;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isStringRecord(value: unknown): value is Record<string, string> {
-  if (!isRecord(value)) {
-    return false;
-  }
-  return Object.values(value).every((entry) => typeof entry === "string");
-}