feat(connectors): cover host selection and binary responses in callApi

The proxy grew two capabilities after this module was written, and `proxyCall`
builds its payload field by field — so `host` was dropped on the floor even when
a caller passed it, and a binary response arrived with `data: null` and no way to
reach the bytes.

- `host` is forwarded when set and omitted when not, so the proxy applies the
  connector's declared default rather than receiving an explicit null.
- `dataBase64` / `contentType` are mapped from the wire, for the media types a
  connector declares as binary. Set instead of `data`, never alongside it.
- `body` no longer claims to be ignored for DELETE; the proxy forwards it, and
  several provider APIs require it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: ChenMachBase

src/modules/connectors.ts

@@ -172,6 +172,9 @@ async function proxyCall<T>(
 
   const response = await axios.post(url, {
     method,
+    // Omitted rather than sent as null so the proxy applies the connector's
+    // declared default host.
+    ...(request.host === undefined ? {} : { host: request.host }),
     path: request.path,
     query: request.query ?? {},
     headers: request.headers ?? {},
@@ -184,6 +187,8 @@ async function proxyCall<T>(
     phase: data.phase,
     status: data.status_code ?? null,
     data: data.data as T,
+    dataBase64: data.data_base64 ?? null,
+    contentType: data.content_type ?? null,
     headers: data.headers ?? {},
     creditsCharged: data.credits_charged ?? 0,
   };

src/modules/connectors.types.ts

@@ -67,6 +67,12 @@ export type ConnectorApiResponsePhase =
 export interface ConnectorApiRequest {
   /** HTTP method for the upstream request. Defaults to `'GET'`. */
   method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
+  /**
+   * Which of the connector's API hosts to call, by the name it declares.
+   * Omit for its default host (the first one declared). Only relevant for
+   * connectors that expose more than one host.
+   */
+  host?: string;
   /**
    * Path relative to the connector's API root, starting with `/`, such as `'/2/tweets'`.
    *
@@ -78,7 +84,7 @@ export interface ConnectorApiRequest {
   query?: Record<string, string | number | boolean | Array<string | number>>;
   /** Extra request headers. Only headers the connector explicitly allows are forwarded; the rest are dropped. */
   headers?: Record<string, string>;
-  /** JSON request body. Ignored for `GET`, `HEAD`, and `DELETE`. */
+  /** JSON request body. Ignored for `GET` and `HEAD`. */
   body?: unknown;
 }
 
@@ -92,8 +98,18 @@ export interface ConnectorApiResponse<T = unknown> {
   phase: ConnectorApiResponsePhase;
   /** The upstream HTTP status code, or `null` when no response was received. */
   status: number | null;
-  /** The parsed upstream response body, or proxy error details when no response was received. */
+  /**
+   * The parsed upstream response body, or proxy error details when no response
+   * was received. `null` when the response was binary — see {@link dataBase64}.
+   */
   data: T;
+  /**
+   * The response body base64-encoded, for the media types the connector declares
+   * as binary (images, PDFs). Set instead of {@link data}, never alongside it.
+   */
+  dataBase64: string | null;
+  /** The response media type, set only alongside {@link dataBase64}. */
+  contentType: string | null;
   /** The subset of upstream response headers the connector exposes, typically rate-limit counters. */
   headers: Record<string, string>;
   /** Integration credits billed to the workspace for this call. */
@@ -109,6 +125,8 @@ export interface ConnectorProxyRawResponse {
   phase: ConnectorApiResponsePhase;
   status_code: number | null;
   data: unknown;
+  data_base64: string | null;
+  content_type: string | null;
   headers: Record<string, string>;
   credits_charged: number;
 }

tests/types/connectors.types.ts

@@ -16,10 +16,31 @@ const response = {
   phase,
   status: null,
   data: { error: "request outcome unknown" },
+  dataBase64: null,
+  contentType: null,
   headers: {},
   creditsCharged: 3,
 } satisfies ConnectorApiResponse;
 
+// A binary response carries the bytes instead of a parsed body.
+const binaryResponse = {
+  success: true,
+  phase: "responded",
+  status: 200,
+  data: null,
+  dataBase64: "iVBORw0KGgo=",
+  contentType: "image/png",
+  headers: {},
+  creditsCharged: 1,
+} satisfies ConnectorApiResponse;
+
+// Host selection is optional and named, not a URL.
+const hostedRequest = {
+  method: "GET",
+  host: "places",
+  path: "/v1/places:searchText",
+} satisfies ConnectorApiRequest;
+
 const rejectsLowercaseMethod = {
   // @ts-expect-error Connector methods use the uppercase wire values.
   method: "post",
@@ -28,4 +49,6 @@ const rejectsLowercaseMethod = {
 
 void request;
 void response;
+void binaryResponse;
+void hostedRequest;
 void rejectsLowercaseMethod;

tests/unit/connectors-proxy.test.ts

@@ -51,6 +51,63 @@ describe("Connectors module – metered connector proxy", () => {
     expect(received.headers).toEqual({});
   });
 
+  test("forwards a named host, and omits it entirely when unset", async () => {
+    // The payload is built field by field, so anything not explicitly forwarded
+    // is silently dropped — which is what happened to `host` before this.
+    const bodies: any[] = [];
+    scope
+      .post(`/api/apps/${appId}/connectors/googlemaps/call`, (body) => {
+        bodies.push(body);
+        return true;
+      })
+      .twice()
+      .reply(200, proxyResponse);
+
+    await base44.asServiceRole.connectors.callApi("googlemaps", {
+      host: "places",
+      path: "/v1/places:searchText",
+    });
+    await base44.asServiceRole.connectors.callApi("googlemaps", {
+      path: "/maps/api/geocode/json",
+    });
+
+    expect(bodies[0].host).toBe("places");
+    // Absent rather than null, so the proxy picks the connector's default host.
+    expect("host" in bodies[1]).toBe(false);
+  });
+
+  test("maps a binary response to dataBase64 + contentType", async () => {
+    scope.post(`/api/apps/${appId}/connectors/googlemaps/call`).reply(200, {
+      success: true,
+      phase: "responded",
+      status_code: 200,
+      data: null,
+      data_base64: "iVBORw0KGgo=",
+      content_type: "image/png",
+      headers: {},
+      credits_charged: 1,
+    });
+
+    const res = await base44.asServiceRole.connectors.callApi("googlemaps", {
+      path: "/maps/api/staticmap",
+    });
+
+    expect(res.dataBase64).toBe("iVBORw0KGgo=");
+    expect(res.contentType).toBe("image/png");
+    expect(res.data).toBeNull();
+  });
+
+  test("leaves dataBase64 and contentType null for a JSON response", async () => {
+    scope.post(`/api/apps/${appId}/connectors/x/call`).reply(200, proxyResponse);
+
+    const res = await base44.asServiceRole.connectors.callApi("x", {
+      path: "/2/users/me",
+    });
+
+    expect(res.dataBase64).toBeNull();
+    expect(res.contentType).toBeNull();
+  });
+
   test("defaults the method to GET", async () => {
     let received: any;
     scope