@superblocksteam/sdk-api 0.0.7 → 0.0.8

package/src/integrations/base/rest-api-client-base.ts

@@ -17,6 +17,7 @@ import type { Plugin as RestApiIntegrationPlugin } from "@superblocksteam/types/
 import { RestApiValidationError } from "../../errors.js";
 import type { QueryExecutor, TraceMetadata } from "../registry.js";
 import type { IntegrationConfig, IntegrationClientImpl } from "../types.js";
+import { REST_API_RESPONSE_TYPES } from "./types.js";
 import type { ApiRequestOptions } from "./types.js";
 
 export type RestApiRequest = PartialMessage<RestApiIntegrationPlugin>;
@@ -58,7 +59,7 @@ export abstract class RestApiClientBase implements IntegrationClientImpl {
    * Returns the raw (unvalidated) response from the orchestrator.
    * Subclasses call this, then apply their own response handling.
    *
-   * @param options - HTTP method, path, body, params, headers
+   * @param options - Request configuration (see {@link ApiRequestOptions})
    * @param bodySchema - Optional Zod schema for body validation
    * @param metadata - Optional trace metadata for observability
    * @returns Raw response from the orchestrator
@@ -96,13 +97,31 @@ export abstract class RestApiClientBase implements IntegrationClientImpl {
       }
     }
 
+    // The RestApiResponseType union is erased in the bundled JS user APIs
+    // run as, so values outside it (including wire values the orchestrator
+    // implements but the SDK deliberately does not expose, like "auto")
+    // must also be rejected at runtime, before the request is issued.
+    const responseTypeResult = z
+      .enum(REST_API_RESPONSE_TYPES)
+      .safeParse(options.responseType ?? "json");
+    if (!responseTypeResult.success) {
+      throw new RestApiValidationError(
+        `Unsupported responseType ${JSON.stringify(options.responseType)} — expected one of: ${REST_API_RESPONSE_TYPES.join(", ")}`,
+        {
+          zodError: responseTypeResult.error,
+          data: options.responseType,
+        },
+      );
+    }
+    const responseType = responseTypeResult.data;
+
     const request: RestApiRequest = {
       openApiAction: "genericHttpRequest",
       httpMethod: options.method.toUpperCase(),
       urlPath: options.path,
       headers,
       params,
-      responseType: "json",
+      responseType,
     };
 
     if (options.body !== undefined) {
@@ -116,11 +135,16 @@ export abstract class RestApiClientBase implements IntegrationClientImpl {
       metadata,
     );
 
+    // Neither `null` nor `undefined` is a legitimate decode result for the
+    // exposed response types: JSON parses to a value the schema sees, and
+    // an empty text body decodes to "". Either value only arises from a
+    // broken execution contract, so both throw. (If "auto" is ever exposed,
+    // `null` becomes legitimate — it parses a literal `null` JSON body.)
     if (result === null || result === undefined) {
       const nonNullResult = z.object({}).safeParse(result);
       if (!nonNullResult.success) {
         throw new RestApiValidationError(
-          `Integration query returned ${String(result)} — expected a JSON response object`,
+          `Integration query returned ${String(result)} for responseType "${responseType}" — expected a response value`,
           {
             zodError: nonNullResult.error,
             data: result,

package/src/integrations/base/rest-api-integration-client.ts

@@ -3,10 +3,13 @@
  *
  * Extends RestApiClientBase with an apiRequest() that validates the
  * full response against a caller-supplied Zod schema and throws
- * RestApiValidationError on mismatch.
+ * RestApiValidationError on mismatch. When no response schema is
+ * provided, the raw result is returned without validation — useful for
+ * non-JSON responses (e.g. XML), which can alternatively be validated
+ * with a schema matching the decoded value (e.g. z.string()).
  */
 
-import type { z } from "zod";
+import { z } from "zod";
 
 import { RestApiValidationError } from "../../errors.js";
 import type { TraceMetadata } from "../registry.js";
@@ -14,6 +17,7 @@ import { RestApiClientBase } from "./rest-api-client-base.js";
 import type {
   ApiRequestOptions,
   ApiRequestSchema,
+  RestApiResponseType,
   SupportsApiRequest,
 } from "./types.js";
 
@@ -34,10 +38,55 @@ export abstract class RestApiIntegrationClient
       response: z.ZodSchema<TResponse>;
     },
     metadata?: TraceMetadata,
-  ): Promise<TResponse> {
-    const result = await this.executeApiRequest(options, schema.body, metadata);
+  ): Promise<TResponse>;
+  async apiRequest<TBody>(
+    options: ApiRequestOptions<TBody> & {
+      responseType: Exclude<RestApiResponseType, "json">;
+    },
+    schema?: ApiRequestSchema<TBody, unknown>,
+    metadata?: TraceMetadata,
+  ): Promise<unknown>;
+  async apiRequest<TBody, TResponse>(
+    options: ApiRequestOptions<TBody>,
+    schema?: ApiRequestSchema<TBody, TResponse>,
+    metadata?: TraceMetadata,
+  ): Promise<TResponse | unknown> {
+    // The overloads make schema-less JSON unrepresentable in TypeScript,
+    // but user API code executes as bundled JS with no type enforcement —
+    // enforce the same contract at runtime, before issuing the request.
+    if ((options.responseType ?? "json") === "json" && !schema?.response) {
+      throw new RestApiValidationError(
+        'apiRequest() with responseType "json" requires a response schema — provide one, or set responseType: "text" to receive a non-JSON payload unvalidated',
+        {
+          zodError: new z.ZodError([
+            {
+              code: z.ZodIssueCode.custom,
+              message: "response schema is required for JSON responses",
+              path: ["response"],
+            },
+          ]),
+          data: undefined,
+        },
+      );
+    }
+
+    const result = await this.executeApiRequest(
+      options,
+      schema?.body,
+      metadata,
+    );
+
+    // Without a response schema the raw result is returned as-is (typed
+    // unknown). Non-JSON responses (e.g. responseType "text" returning
+    // XML) can either omit the schema or pass one matching the decoded
+    // value, such as z.string(). Request-body validation is opt-in:
+    // executeApiRequest only validates options.body when schema.body is
+    // provided (unchanged from the previous contract, where schema.body
+    // was already optional).
+    if (!schema?.response) {
+      return result;
+    }
 
-    // Response schema is REQUIRED - always validate
     const responseParseResult = schema.response.safeParse(result);
 
     if (!responseParseResult.success) {

package/src/integrations/base/types.ts

@@ -9,6 +9,32 @@ import type { TraceMetadata } from "../registry.js";
 // Re-export for backwards compatibility
 export type { TraceMetadata };
 
+/**
+ * How the orchestrator should decode the HTTP response body.
+ *
+ * - `"json"` (default): parse the response as JSON; fails on non-JSON bodies
+ * - `"text"`: return the decoded response body as a string (XML, CSV, HTML, ...)
+ *
+ * The orchestrator also implements `"auto"`, `"binary"`, and `"raw"` wire
+ * values; they are deliberately not exposed here (widening this union later
+ * is backward-compatible, narrowing it is not):
+ *
+ * - `"auto"` returns parsed JSON whenever the body happens to parse, which
+ *   would let JSON responses bypass schema validation via the schema-less
+ *   overload
+ * - `"binary"` would freeze the worker's internal Buffer JSON encoding
+ *   (`{ type: "Buffer", data: number[] }`, ~4x payload inflation) into the
+ *   public SDK contract
+ * - `"raw"` is rejected by the orchestrator for non-streaming requests
+ *
+ * The runtime tuple backs the request-time guard in `executeApiRequest`:
+ * the type-level union is erased in the bundled JS user APIs run as, so
+ * values outside it must also be rejected at runtime.
+ */
+export const REST_API_RESPONSE_TYPES = ["json", "text"] as const;
+
+export type RestApiResponseType = (typeof REST_API_RESPONSE_TYPES)[number];
+
 /**
  * Options for making a generic REST API request.
  */
@@ -38,6 +64,15 @@ export interface ApiRequestOptions<TBody = unknown> {
    * Optional HTTP headers
    */
   headers?: Record<string, string>;
+
+  /**
+   * How the response body should be decoded. Defaults to `"json"`.
+   *
+   * Use `"text"` for endpoints that return non-JSON payloads such as
+   * XML. When requesting a text response, omit the response schema (or
+   * use one matching the decoded string, e.g. `z.string()`).
+   */
+  responseType?: RestApiResponseType;
 }
 
 /**
@@ -46,7 +81,7 @@ export interface ApiRequestOptions<TBody = unknown> {
 export interface ApiRequestSchema<TBody = unknown, TResponse = unknown> {
   /**
    * Optional Zod schema for request body validation.
-   * Required if body is provided in options.
+   * When omitted, `options.body` is sent without validation.
    */
   body?: z.ZodSchema<TBody>;
 
@@ -60,14 +95,18 @@ export interface ApiRequestSchema<TBody = unknown, TResponse = unknown> {
 /**
  * Interface for integration clients that support generic API requests.
  *
- * All API requests require response schema validation for type safety.
+ * Providing a response schema gives type-safe, validated results. Omitting
+ * it returns the raw response as `unknown`. For non-JSON payloads (e.g.
+ * `responseType: "text"` for XML), either omit the schema or supply one
+ * matching the decoded value (e.g. `z.string()` for text) — object schemas
+ * only make sense for JSON-shaped results.
  */
 export interface SupportsApiRequest {
   /**
    * Execute a generic API request with type-safe validation.
    *
    * @param options - Request configuration including method, path, params, and body
-   * @param schema - Zod schemas for request body and response validation (response schema REQUIRED)
+   * @param schema - Zod schemas for request body and response validation
    * @param metadata - Optional trace metadata for observability (label, description)
    * @returns Validated response data
    *
@@ -103,4 +142,39 @@ export interface SupportsApiRequest {
     },
     metadata?: TraceMetadata,
   ): Promise<TResponse>;
+
+  /**
+   * Execute a generic API request without response validation.
+   *
+   * This overload requires an explicit non-JSON `responseType` — JSON
+   * responses must always be consumed through the schema overload above,
+   * so "unvalidated JSON" is unrepresentable. The decoded non-JSON
+   * response is returned as-is, typed `unknown`.
+   *
+   * Note: request-body validation is opt-in — it runs only when
+   * `schema.body` is provided. Omitting `schema` sends `options.body`
+   * without validation.
+   *
+   * @param options - Request configuration; `responseType` must be "text"
+   * @param schema - Optional Zod schema for request body validation
+   * @param metadata - Optional trace metadata for observability (label, description)
+   * @returns The raw response from the integration
+   *
+   * @example
+   * ```typescript
+   * const xml = await ctx.integrations.legacyApi.apiRequest({
+   *   method: 'GET',
+   *   path: '/report.xml',
+   *   responseType: 'text',
+   * });
+   * // xml is the raw XML string
+   * ```
+   */
+  apiRequest<TBody>(
+    options: ApiRequestOptions<TBody> & {
+      responseType: Exclude<RestApiResponseType, "json">;
+    },
+    schema?: ApiRequestSchema<TBody, unknown>,
+    metadata?: TraceMetadata,
+  ): Promise<unknown>;
 }

package/src/integrations/documentation-resolver.test.ts

@@ -659,7 +659,27 @@ describe("resolveIntegrationDocumentation", () => {
       }
     });
 
-    it("throws when overlay entry has empty versionRange", async () => {
+    it("throws when overlay entry has neither versionRange nor sdkVersionRange", async () => {
+      const integrationsDirectory = createPluginDocsFixture("dropbox", {
+        "README.md": "base",
+        "docs.manifest.json": JSON.stringify({
+          overlays: [{ file: "overlays/01.md" }],
+        }),
+      });
+
+      try {
+        await expect(
+          resolveIntegrationDocumentation("dropbox", {
+            pluginVersion: "0.4.0",
+            integrationsDirectory,
+          }),
+        ).rejects.toThrowError(/Invalid overlay entry/);
+      } finally {
+        rmSync(integrationsDirectory, { recursive: true, force: true });
+      }
+    });
+
+    it("throws when overlay entry has empty versionRange and no sdkVersionRange", async () => {
       const integrationsDirectory = createPluginDocsFixture("dropbox", {
         "README.md": "base",
         "docs.manifest.json": JSON.stringify({
@@ -680,6 +700,175 @@ describe("resolveIntegrationDocumentation", () => {
     });
   });
 
+  describe("sdkVersionRange", () => {
+    it("applies overlay when sdkVersion matches sdkVersionRange", async () => {
+      const integrationsDirectory = createPluginDocsFixture("graphql", {
+        "README.md": "base-graphql-docs",
+        "docs.manifest.json": JSON.stringify({
+          overlays: [
+            { file: "overlays/headers.md", sdkVersionRange: ">=0.0.2" },
+          ],
+        }),
+        "overlays/headers.md": "dynamic-headers-docs",
+      });
+
+      try {
+        const docs = await resolveIntegrationDocumentation("graphql", {
+          sdkVersion: "0.0.2",
+          integrationsDirectory,
+        });
+        expect(docs).toBe("base-graphql-docs\n\ndynamic-headers-docs");
+      } finally {
+        rmSync(integrationsDirectory, { recursive: true, force: true });
+      }
+    });
+
+    it("skips overlay when sdkVersion does not match sdkVersionRange", async () => {
+      const integrationsDirectory = createPluginDocsFixture("graphql", {
+        "README.md": "base-graphql-docs",
+        "docs.manifest.json": JSON.stringify({
+          overlays: [
+            { file: "overlays/headers.md", sdkVersionRange: ">=0.0.2" },
+          ],
+        }),
+        "overlays/headers.md": "dynamic-headers-docs",
+      });
+
+      try {
+        const docs = await resolveIntegrationDocumentation("graphql", {
+          sdkVersion: "0.0.1",
+          integrationsDirectory,
+        });
+        expect(docs).toBe("base-graphql-docs");
+      } finally {
+        rmSync(integrationsDirectory, { recursive: true, force: true });
+      }
+    });
+
+    it("skips overlay when sdkVersion is not provided", async () => {
+      const integrationsDirectory = createPluginDocsFixture("graphql", {
+        "README.md": "base-graphql-docs",
+        "docs.manifest.json": JSON.stringify({
+          overlays: [
+            { file: "overlays/headers.md", sdkVersionRange: ">=0.0.2" },
+          ],
+        }),
+        "overlays/headers.md": "dynamic-headers-docs",
+      });
+
+      try {
+        const docs = await resolveIntegrationDocumentation("graphql", {
+          pluginVersion: "0.0.10",
+          integrationsDirectory,
+        });
+        expect(docs).toBe("base-graphql-docs");
+      } finally {
+        rmSync(integrationsDirectory, { recursive: true, force: true });
+      }
+    });
+
+    it("requires both versionRange and sdkVersionRange to match when both are specified", async () => {
+      const integrationsDirectory = createPluginDocsFixture("graphql", {
+        "README.md": "base",
+        "docs.manifest.json": JSON.stringify({
+          overlays: [
+            {
+              file: "overlays/both.md",
+              versionRange: ">=0.0.10",
+              sdkVersionRange: ">=0.0.2",
+            },
+          ],
+        }),
+        "overlays/both.md": "both-match-overlay",
+      });
+
+      try {
+        // Both match
+        expect(
+          await resolveIntegrationDocumentation("graphql", {
+            pluginVersion: "0.0.10",
+            sdkVersion: "0.0.2",
+            integrationsDirectory,
+          }),
+        ).toBe("base\n\nboth-match-overlay");
+
+        // Only plugin matches
+        expect(
+          await resolveIntegrationDocumentation("graphql", {
+            pluginVersion: "0.0.10",
+            sdkVersion: "0.0.1",
+            integrationsDirectory,
+          }),
+        ).toBe("base");
+
+        // Only sdk matches
+        expect(
+          await resolveIntegrationDocumentation("graphql", {
+            pluginVersion: "0.0.9",
+            sdkVersion: "0.0.2",
+            integrationsDirectory,
+          }),
+        ).toBe("base");
+      } finally {
+        rmSync(integrationsDirectory, { recursive: true, force: true });
+      }
+    });
+
+    it("allows overlay with only sdkVersionRange (no versionRange)", async () => {
+      const integrationsDirectory = createPluginDocsFixture("graphql", {
+        "README.md": "base",
+        "docs.manifest.json": JSON.stringify({
+          overlays: [
+            { file: "overlays/sdk-only.md", sdkVersionRange: ">=0.0.2" },
+          ],
+        }),
+        "overlays/sdk-only.md": "sdk-gated-overlay",
+      });
+
+      try {
+        // No pluginVersion needed — only sdkVersion matters
+        const docs = await resolveIntegrationDocumentation("graphql", {
+          sdkVersion: "0.0.3",
+          integrationsDirectory,
+        });
+        expect(docs).toBe("base\n\nsdk-gated-overlay");
+      } finally {
+        rmSync(integrationsDirectory, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe("restapiintegration responseType gating (real docs)", () => {
+    // These resolve the actual shipped docs, not a fixture: the overlay
+    // gating is the discoverability guard for the responseType feature
+    // (agents whose worker sdk-api predates it must never be told the
+    // option exists), so the real manifest content is the contract.
+
+    it("documents responseType for agents whose sdk-api supports it", async () => {
+      const docs = await resolveIntegrationDocumentation("restapiintegration", {
+        sdkVersion: "0.0.3",
+      });
+
+      expect(docs).toContain('responseType: "text"');
+      expect(docs).not.toContain("does not support the `responseType`");
+    });
+
+    it("notes non-support instead of documenting responseType on older agents", async () => {
+      const docs = await resolveIntegrationDocumentation("restapiintegration", {
+        sdkVersion: "0.0.2",
+      });
+
+      expect(docs).toContain("does not support the `responseType`");
+      expect(docs).not.toContain('responseType: "text"');
+    });
+
+    it("stays silent about responseType when the agent reports no sdk-api version", async () => {
+      const docs = await resolveIntegrationDocumentation("restapiintegration");
+
+      expect(docs).not.toContain("responseType");
+    });
+  });
+
   it("blocks overlay paths outside the plugin directory", async () => {
     const integrationsDirectory = createPluginDocsFixture("dropbox", {
       "README.md": "base",

package/src/integrations/documentation.ts

@@ -11,7 +11,13 @@ const DOC_DIRECTORY_ALIASES = {
 
 interface DocumentationOverlay {
   file: string;
-  versionRange: string;
+  versionRange?: string;
+  /** When set, checks against the sdk-api version ("javascriptsdkapi") running
+   *  in the orchestrator instead of the plugin-specific version. Use this to
+   *  gate overlays on sdk-api features that ship independently of plugin
+   *  version bumps. Both versionRange and sdkVersionRange can be specified
+   *  together — the overlay is applied only when all specified ranges match. */
+  sdkVersionRange?: string;
 }
 
 interface DocumentationManifest {
@@ -32,6 +38,7 @@ type OverlayOperation =
 
 export interface ResolveIntegrationDocumentationOptions {
   pluginVersion?: SemVer;
+  sdkVersion?: SemVer;
   integrationsDirectory?: string;
 }
 
@@ -82,16 +89,17 @@ async function parseDocumentationManifest(
         typeof overlay !== "object" ||
         overlay === null ||
         !("file" in overlay) ||
-        !("versionRange" in overlay)
+        (!("versionRange" in overlay) && !("sdkVersionRange" in overlay))
       ) {
         throw new Error(
           `Invalid overlay entry at index ${index} in ${manifestPath}.`,
         );
       }
 
-      const { file, versionRange } = overlay as {
+      const { file, versionRange, sdkVersionRange } = overlay as {
         file: unknown;
         versionRange: unknown;
+        sdkVersionRange: unknown;
       };
 
       if (typeof file !== "string" || file.trim().length === 0) {
@@ -99,18 +107,35 @@ async function parseDocumentationManifest(
           `Invalid "file" for overlay index ${index} in ${manifestPath}.`,
         );
       }
-      if (
-        typeof versionRange !== "string" ||
-        versionRange.trim().length === 0
-      ) {
+
+      const hasVersionRange =
+        typeof versionRange === "string" && versionRange.trim().length > 0;
+      const hasSdkVersionRange =
+        typeof sdkVersionRange === "string" &&
+        sdkVersionRange.trim().length > 0;
+
+      if ("versionRange" in overlay && !hasVersionRange) {
         throw new Error(
           `Invalid "versionRange" for overlay index ${index} in ${manifestPath}.`,
         );
       }
+      if ("sdkVersionRange" in overlay && !hasSdkVersionRange) {
+        throw new Error(
+          `Invalid "sdkVersionRange" for overlay index ${index} in ${manifestPath}.`,
+        );
+      }
+      if (!hasVersionRange && !hasSdkVersionRange) {
+        throw new Error(
+          `Overlay at index ${index} in ${manifestPath} must specify at least one of "versionRange" or "sdkVersionRange".`,
+        );
+      }
 
       return {
         file,
-        versionRange,
+        ...(hasVersionRange ? { versionRange: versionRange as string } : {}),
+        ...(hasSdkVersionRange
+          ? { sdkVersionRange: sdkVersionRange as string }
+          : {}),
       };
     },
   );
@@ -380,11 +405,38 @@ function ensureOverlayPathIsWithinPluginDir(
   }
 }
 
+function overlayMatchesVersions(
+  overlay: DocumentationOverlay,
+  pluginVersion: SemVer | undefined,
+  sdkVersion: SemVer | undefined,
+): boolean {
+  if (
+    overlay.versionRange &&
+    (!pluginVersion ||
+      !versionMatchesRange(pluginVersion, overlay.versionRange))
+  ) {
+    return false;
+  }
+
+  if (
+    overlay.sdkVersionRange &&
+    (!sdkVersion || !versionMatchesRange(sdkVersion, overlay.sdkVersionRange))
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
 export async function resolveIntegrationDocumentation(
   pluginId: string,
   options: ResolveIntegrationDocumentationOptions = {},
 ): Promise<string> {
-  const { pluginVersion, integrationsDirectory = INTEGRATIONS_DIR } = options;
+  const {
+    pluginVersion,
+    sdkVersion,
+    integrationsDirectory = INTEGRATIONS_DIR,
+  } = options;
 
   const pluginDirectory = resolve(
     integrationsDirectory,
@@ -397,13 +449,13 @@ export async function resolveIntegrationDocumentation(
   const baseDocumentationPath = resolve(pluginDirectory, baseFileName);
   const baseDocumentation = await readFile(baseDocumentationPath, "utf8");
 
-  if (!manifest || !pluginVersion) {
+  if (!manifest) {
     return baseDocumentation;
   }
 
   let resolvedDocumentation = baseDocumentation;
   for (const overlay of manifest.overlays) {
-    if (!versionMatchesRange(pluginVersion, overlay.versionRange)) {
+    if (!overlayMatchesVersions(overlay, pluginVersion, sdkVersion)) {
       continue;
     }
 

package/src/integrations/graphql/docs.manifest.json

@@ -1,5 +1,10 @@
 {
   "pluginId": "graphql",
   "base": "README.md",
-  "overlays": []
+  "overlays": [
+    {
+      "file": "overlays/dynamic-headers.md",
+      "sdkVersionRange": ">=0.0.2"
+    }
+  ]
 }

package/src/integrations/graphql/overlays/dynamic-headers.md

@@ -0,0 +1,34 @@
+## @replace: Methods
+
+| Method                                                           | Description                                                |
+| ---------------------------------------------------------------- | ---------------------------------------------------------- |
+| `query<T>(query, schema, variables?, metadata?, headers?)`       | Execute a GraphQL query with required schema validation    |
+| `mutation<T>(mutation, schema, variables?, metadata?, headers?)` | Execute a GraphQL mutation with required schema validation |
+
+## @replace: Trace Metadata
+
+All methods accept an optional `metadata` parameter for diagnostics labeling. See the [root SDK README](../../../README.md#trace-metadata) for details.
+
+## Dynamic Headers
+
+Static headers (e.g. a fixed `X-API-Version`) and auth headers (e.g. Bearer tokens, API keys) should be configured on the GraphQL integration in the Superblocks UI so they apply to every call automatically.
+
+For values that change per request — for example a bearer token derived from the API's input or from `ctx.env` — pass an optional `headers` map as the final argument to `query()` or `mutation()`:
+
+```typescript
+const MeResponseSchema = z.object({
+  data: z.object({
+    me: z.object({ id: z.string(), email: z.string() }),
+  }),
+});
+
+const result = await ctx.integrations.graphql.query(
+  `query { me { id email } }`,
+  { response: MeResponseSchema },
+  undefined, // no variables
+  undefined, // no trace metadata
+  { Authorization: `Bearer ${ctx.env.UPSTREAM_TOKEN}` },
+);
+```
+
+Since both `variables` and `metadata` accept plain objects, pass `undefined` for any of them that you do not need.

package/src/integrations/postgres/client.ts

@@ -20,7 +20,7 @@ import type { PostgresClient } from "./types.js";
  * PostgreSQL request type derived from proto definition.
  * Using PartialMessage allows optional fields.
  */
-export type PostgresRequest = PartialMessage<PostgresPlugin>;
+type PostgresRequest = PartialMessage<PostgresPlugin>;
 
 /**
  * Internal implementation of PostgresClient.