zuplo 7.4.4 → 7.4.6

package/docs/mcp-gateway/server-registry.mdx

@@ -0,0 +1,179 @@
+---
+title: "MCP Server Registry"
+sidebar_label: "Server Registry"
+description:
+  The read-only MCP Server Registry API (v0.1) the gateway serves by default —
+  advertises every MCP route so clients and subregistries can discover them
+  without authentication.
+---
+
+The MCP Gateway serves a read-only
+[MCP Server Registry API](https://github.com/modelcontextprotocol/registry)
+(v0.1 freeze) that advertises every MCP route on the gateway. MCP clients and
+mirroring subregistries can discover the gateway's registered servers without
+authentication, per the registry specification.
+
+The registry is enabled by default and mounted at `/__zuplo/mcp-registry` (with
+the default `basePath`). Configure or disable it through the
+[`registry` option](../programmable-api/mcp-gateway-plugin.mdx#registry) on
+`McpGatewayPlugin`.
+
+## What gets listed
+
+The registry projects one entry per MCP-serving route — both:
+
+- **Gateway virtual servers** — routes that carry MCP gateway policies
+  (`mcp-oauth-inbound` / `mcp-token-exchange-inbound`) and use
+  [`McpProxyHandler`](./code-config/mcp-proxy-handler.mdx) to proxy to an
+  upstream MCP server.
+- **Standalone MCP servers** — routes that use the built-in `mcpServerHandler`
+  or a bare `McpProxyHandler` without gateway policies.
+
+Each entry includes:
+
+| Field         | Source                                                                                                            |
+| ------------- | ----------------------------------------------------------------------------------------------------------------- |
+| `name`        | `<reverse-DNS of request host>/<operationId>` (for example, `com.example.gateway/linear-mcp-server`)              |
+| `remotes`     | The gateway route URL, using the `streamable-http` transport.                                                     |
+| `description` | OpenAPI operation `description` or `summary`, clamped to 100 code points per the spec.                            |
+| `title`       | `mcpServerHandler` options or the OpenAPI operation `summary`.                                                    |
+| `version`     | `mcpServerHandler` options or upstream connection config. Range-like values (`^1.2.3`, `1.x`) project as `0.0.0`. |
+| `websiteUrl`  | Upstream connection config, canonicalized to a valid URI.                                                         |
+| `icons`       | Upstream connection config. Only HTTPS URLs are included; `src` is clamped to 255 characters.                     |
+
+:::note
+
+Server names are derived from the request host — the same posture as the OAuth
+issuer and Protected Resource Metadata. Names vary with the hostname the gateway
+is reached on, so a custom domain produces different names than the default
+`*.zuplo.dev` origin.
+
+:::
+
+The projection never throws. Every spec constraint is enforced by sanitizing or
+omitting: names longer than 200 characters are truncated with a hash suffix,
+descriptions are clamped, non-HTTPS icons are dropped, and version ranges are
+replaced with `0.0.0`. One malformed route can't take down discovery for the
+rest.
+
+Parameterized routes (for example, `/mcp/{server}`) are omitted from the
+directory — a templated path is not a concretely connectable remote.
+
+## Endpoints
+
+All paths are relative to the registry mount (default: `/__zuplo/mcp-registry`).
+Discovery GETs are unauthenticated and CORS-permissive
+(`Access-Control-Allow-Origin: *`).
+
+### `GET {path}/v0.1/servers`
+
+Lists all MCP servers registered on the gateway.
+
+| Query parameter | Type    | Default | Description                                                                                     |
+| --------------- | ------- | ------- | ----------------------------------------------------------------------------------------------- |
+| `cursor`        | string  | —       | Opaque pagination cursor from a previous response.                                              |
+| `limit`         | integer | `30`    | Maximum servers to return. Clamped to `100`.                                                    |
+| `search`        | string  | —       | Case-insensitive substring filter on server name.                                               |
+| `version`       | string  | —       | Filter to servers matching a specific version.                                                  |
+| `updated_since` | string  | —       | RFC 3339 date-time. Validated but never filters — every entry conservatively counts as changed. |
+
+Response:
+
+```json
+{
+  "servers": [
+    {
+      "name": "com.example.gateway/linear-mcp-server",
+      "description": "Linear MCP proxy",
+      "title": "Linear",
+      "version": "1.0.0",
+      "remotes": [
+        {
+          "type": "streamable-http",
+          "url": "https://gateway.example.com/mcp/linear-v1"
+        }
+      ],
+      "websiteUrl": "https://linear.app",
+      "icons": []
+    }
+  ],
+  "metadata": { "count": 1 }
+}
+```
+
+When `cursor` is present in the response, more results are available. Pass it
+back as the `cursor` query parameter on the next request.
+
+### `GET {path}/v0.1/servers/{serverName}/versions`
+
+Lists versions for a single server. With the current read-only projection, every
+server has exactly one version entry.
+
+`{serverName}` is URL-encoded — the slash in the reverse-DNS name is sent as
+`%2F` (for example, `com.example.gateway%2Flinear-mcp-server`).
+
+### `GET {path}/v0.1/servers/{serverName}/versions/{version}`
+
+Returns a single server version. The special alias `latest` resolves to the
+server's current version.
+
+### Write endpoints (refused)
+
+The registry is read-only. Write endpoints are refused per the spec:
+
+| Endpoint                                                     | Method   | Status | Reason                                                                                       |
+| ------------------------------------------------------------ | -------- | ------ | -------------------------------------------------------------------------------------------- |
+| `{path}/v0.1/publish`                                        | `POST`   | `501`  | Spec marks publishing optional and documents `501`.                                          |
+| `{path}/v0.1/servers/{serverName}/versions/{version}`        | `PUT`    | `501`  | Spec marks version update optional.                                                          |
+| `{path}/v0.1/servers/{serverName}/versions/{version}`        | `DELETE` | `501`  | Spec marks version deletion optional.                                                        |
+| `{path}/v0.1/servers/{serverName}/versions/{version}/status` | `PATCH`  | `403`  | Spec defines no `501` for status operations; returns `403` with a permissions error message. |
+| `{path}/v0.1/servers/{serverName}/status`                    | `PATCH`  | `403`  | Same as above.                                                                               |
+
+All error bodies use the spec's `{"error": "..."}` shape — not RFC 7807 problem
+details — so off-the-shelf registry clients can parse them. A catch-all under
+the mount ensures even unrecognized requests get the spec-shaped `404`.
+
+## Configuration
+
+The registry is configured through the `McpGatewayPlugin` constructor. See the
+[`registry` option](../programmable-api/mcp-gateway-plugin.mdx#registry) for the
+full options reference.
+
+```ts title="modules/zuplo.runtime.ts"
+import { RuntimeExtensions } from "@zuplo/runtime";
+import { McpGatewayPlugin } from "@zuplo/runtime/mcp-gateway";
+
+export function runtimeInit(runtime: RuntimeExtensions) {
+  runtime.addPlugin(
+    new McpGatewayPlugin({
+      registry: {
+        enabled: true, // default
+        path: "/mcp-registry", // default: "{basePath}/mcp-registry"
+      },
+    }),
+  );
+}
+```
+
+## Limitations
+
+- **No publishing.** The registry is a read-only projection of the gateway's
+  live route configuration. There is no write path, no namespace-ownership
+  model, and no stored `publishedAt` or `updatedAt` timestamps.
+- **`updated_since` validates but never filters.** Because the registry is
+  derived from route config with no stored timestamps, every entry
+  conservatively counts as changed. This keeps mirroring subregistries correct
+  at the cost of re-reading everything.
+- **No deployment-pinned server identity.** Server names are derived from the
+  request host, not from a stable deployment-level identifier.
+
+## Related
+
+- [`McpGatewayPlugin` reference](../programmable-api/mcp-gateway-plugin.mdx) —
+  the full plugin options, including `basePath` and `registry`.
+- [Gateway reference](./reference.mdx) — the full URL catalog, including the
+  registry mount.
+- [How the MCP Gateway works](./how-it-works.mdx) — architecture and request
+  lifecycle.
+- [MCP Server Registry specification](https://github.com/modelcontextprotocol/registry)
+  — the v0.1 freeze the gateway implements.

package/docs/mcp-gateway/test-clients.mdx

@@ -102,8 +102,8 @@ Whichever tool you pick, exercise these gateway behaviors during a smoke test:
    `WWW-Authenticate: Bearer resource_metadata=...`. If it doesn't, the route is
    missing an MCP OAuth policy.
 2. **OAuth handshake completes.** Confirm the inspector lands on the gateway's
-   `/oauth/setup` consent page (rendered HTML), that the upstream's **Connect**
-   button works, and that the inspector receives an access token.
+   `/__zuplo/oauth/setup` consent page (rendered HTML), that the upstream's
+   **Connect** button works, and that the inspector receives an access token.
 3. **`tools/list` returns the expected curated set.** If you've attached
    `mcp-capability-filter-inbound`, verify the filter is working — only
    allow-listed tools should appear.

package/docs/mcp-server/custom-tools.mdx

@@ -432,6 +432,36 @@ export default async function (request: ZuploRequest, context: ZuploContext) {
 }
 ```
 
+## Controlling tool results with ZuploMcpSdk
+
+By default, the MCP Server handler serializes the downstream response body into
+a single text content block and, when `includeStructuredContent` is enabled,
+derives `structuredContent` from it. The `ZuploMcpSdk` class gives you
+programmatic control over what the AI client receives — without changing the
+response your handler returns.
+
+The most common use case is a **compact summary**: replace the full serialized
+body in `content` with a short human-readable summary, while the gateway still
+auto-derives `structuredContent` from the downstream response. This reduces the
+token count in the model's context without losing data.
+
+```typescript
+import { ZuploContext, ZuploMcpSdk, ZuploRequest } from "@zuplo/runtime";
+
+export default async function (request: ZuploRequest, context: ZuploContext) {
+  const response = await context.invokeRoute("/todos");
+  new ZuploMcpSdk(context).setRawCallToolResult({
+    content: [{ type: "text", text: "Fetched the todo list" }],
+  });
+  return response;
+}
+```
+
+You can also read metadata from the incoming `tools/call` request using
+`getRawCallToolRequest()`, and override `structuredContent` and `_meta`
+independently. For the full API reference, see
+[ZuploMcpSdk](../programmable-api/mcp-sdk.mdx).
+
 ## Best Practices
 
 ### Tool Design
@@ -479,6 +509,8 @@ export default async function (request: ZuploRequest, context: ZuploContext) {
 
 ## Learn More
 
+- [ZuploMcpSdk](../programmable-api/mcp-sdk.mdx) - Programmatic control over MCP
+  tool results
 - [MCP Server Handler](../handlers/mcp-server.mdx) - For simple route-to-tool
   mapping
 - [Model Context Protocol Overview](../mcp-server/introduction.mdx) -

package/docs/programmable-api/mcp-gateway-plugin.mdx

@@ -0,0 +1,137 @@
+---
+title: "MCP Gateway Plugin"
+sidebar_label: "MCP Gateway Plugin"
+description:
+  Reference for the McpGatewayPlugin runtime plugin — options for the base path,
+  OAuth endpoints, and the read-only MCP Server Registry.
+---
+
+`McpGatewayPlugin` activates the MCP Gateway internal routes on the runtime
+router: the OAuth authorization server, upstream connection management,
+well-known metadata endpoints, and the read-only
+[MCP Server Registry](../mcp-gateway/server-registry.mdx). When no MCP-related
+policy is present, the plugin registers no OAuth routes — it still records
+`plugin.mcp-gateway` feature usage on construction so gateway adoption is
+visible in telemetry.
+
+Importing from `@zuplo/runtime/mcp-gateway` is the opt-in: the runtime core
+doesn't depend on MCP Gateway code until the plugin is added.
+
+## Registration
+
+Register the plugin in `modules/zuplo.runtime.ts`:
+
+```ts title="modules/zuplo.runtime.ts"
+import { RuntimeExtensions } from "@zuplo/runtime";
+import { McpGatewayPlugin } from "@zuplo/runtime/mcp-gateway";
+
+export function runtimeInit(runtime: RuntimeExtensions) {
+  runtime.addPlugin(new McpGatewayPlugin());
+}
+```
+
+The plugin accepts an optional configuration object. All options have defaults,
+so the no-argument form works for most projects.
+
+```ts title="modules/zuplo.runtime.ts"
+import { RuntimeExtensions } from "@zuplo/runtime";
+import { McpGatewayPlugin } from "@zuplo/runtime/mcp-gateway";
+
+export function runtimeInit(runtime: RuntimeExtensions) {
+  runtime.addPlugin(
+    new McpGatewayPlugin({
+      basePath: "/__zuplo",
+      registry: {
+        enabled: true,
+        path: "/mcp-registry",
+      },
+    }),
+  );
+}
+```
+
+## Options
+
+| Option     | Type                        | Default      | Description                                                                                                                      |
+| ---------- | --------------------------- | ------------ | -------------------------------------------------------------------------------------------------------------------------------- |
+| `basePath` | `string`                    | `"/__zuplo"` | Base path for all gateway internal routes (OAuth, well-known, registry). Must start with `/` and can't collide with route paths. |
+| `registry` | `McpGatewayRegistryOptions` | See below    | Configures the read-only [MCP Server Registry](../mcp-gateway/server-registry.mdx).                                              |
+
+### `basePath`
+
+The base path prefixes every internal URL the gateway serves — OAuth endpoints
+(`/oauth/*`), well-known metadata (`/.well-known/*`), and the registry mount
+(`/mcp-registry`). With the default `"/__zuplo"`, the token endpoint lives at
+`/__zuplo/oauth/token` and the registry at `/__zuplo/mcp-registry`.
+
+```ts
+new McpGatewayPlugin({ basePath: "/internal" });
+// OAuth token:  /internal/oauth/token
+// Registry:     /internal/mcp-registry
+```
+
+### `registry`
+
+Configures the read-only MCP Server Registry API (v0.1) that advertises the
+gateway's registered MCP routes. See
+[MCP Server Registry](../mcp-gateway/server-registry.mdx) for the endpoint
+reference and behavior.
+
+| Option    | Type      | Default                     | Description                                                                                                                                               |
+| --------- | --------- | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `enabled` | `boolean` | `true`                      | Set to `false` to disable the registry entirely. No registry routes are registered when disabled.                                                         |
+| `path`    | `string`  | `"{basePath}/mcp-registry"` | Absolute URL path where the registry API mounts. Registry endpoints live below this path (for example, `{path}/v0.1/servers`). Validated like `basePath`. |
+
+The registry path is validated with the same schema as `basePath`, plus a
+boot-time guard that rejects mounts shadowing the OAuth discovery
+(`/.well-known`) or authorize wildcard routes.
+
+:::note
+
+When `registry.enabled` is `false`, the path collision guard is skipped — a
+disabled registry registers no routes and must not fail boot over a mount that
+will never exist.
+
+:::
+
+#### Default mount
+
+With the default `basePath` of `"/__zuplo"` and no `registry` override, the
+registry is served at:
+
+```text
+/__zuplo/mcp-registry/v0.1/servers
+```
+
+#### Custom registry path
+
+Set `registry.path` to mount the registry independently of `basePath`:
+
+```ts
+new McpGatewayPlugin({
+  registry: { path: "/registry" },
+});
+// Registry:  /registry/v0.1/servers
+// OAuth:     /__zuplo/oauth/token  (basePath unchanged)
+```
+
+#### Disabled registry
+
+Turn off the registry if you don't need server discovery:
+
+```ts
+new McpGatewayPlugin({
+  registry: { enabled: false },
+});
+```
+
+## Related
+
+- [MCP Server Registry](../mcp-gateway/server-registry.mdx) — the read-only
+  registry API the plugin serves by default.
+- [Set up an MCP Gateway](../mcp-gateway/code-config/overview.mdx) — the how-to
+  that puts this plugin into a project with policies and routes.
+- [How the MCP Gateway works](../mcp-gateway/how-it-works.mdx) — the
+  architecture and request lifecycle.
+- [Gateway reference](../mcp-gateway/reference.mdx) — the full URL catalog,
+  default TTLs, and configuration constants.

package/docs/programmable-api/mcp-sdk.mdx

@@ -0,0 +1,240 @@
+---
+title: ZuploMcpSdk
+sidebar_label: MCP SDK
+description:
+  Reference for the ZuploMcpSdk class, which gives custom MCP tool handlers
+  access to the incoming tool call request and control over the tool result sent
+  back to the AI client.
+---
+
+The `ZuploMcpSdk` class provides a helper API for custom MCP tool handlers to
+interact with the MCP runtime. Use it to read metadata from the incoming
+`tools/call` request and to override fields of the tool result the gateway sends
+back to the AI client.
+
+```ts
+import { ZuploContext, ZuploMcpSdk, ZuploRequest } from "@zuplo/runtime";
+
+export default async function (request: ZuploRequest, context: ZuploContext) {
+  const sdk = new ZuploMcpSdk(context);
+
+  // Read the incoming tool call request
+  const mcpRequest = sdk.getRawCallToolRequest();
+  context.log.info(`Tool called: ${mcpRequest?.params.name}`);
+
+  // Invoke a route on your gateway
+  const response = await context.invokeRoute("/todos");
+
+  // Override the content the model sees, keeping auto-derived structuredContent
+  sdk.setRawCallToolResult({
+    content: [{ type: "text", text: "Fetched the todo list" }],
+  });
+
+  return response;
+}
+```
+
+`ZuploMcpSdk` is available in custom tool handlers for both the
+[MCP Server handler](../handlers/mcp-server.mdx) and the
+[MCP Gateway](../mcp-gateway/introduction.mdx). It is exported from
+`@zuplo/runtime`.
+
+## Methods
+
+### `setRawCallToolResult(result)`
+
+Overrides fields of the MCP tool result the gateway is about to send to the AI
+client. Every field is independently optional — an absent field keeps the value
+the gateway derives from the downstream response.
+
+```ts
+setRawCallToolResult(result: ZuploMcpToolResultOverride): void
+```
+
+#### Parameters
+
+The `result` argument is a `ZuploMcpToolResultOverride` object with the
+following optional fields:
+
+| Field               | Type                        | Description                                                                                                                  |
+| ------------------- | --------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
+| `content`           | `CallToolResult["content"]` | Content blocks the model reads. Replaces the gateway's default (the serialized downstream body in a text block).             |
+| `structuredContent` | `Record<string, unknown>`   | The structured form of the tool's output. Must be a JSON object — the MCP 2025-11-25 wire format rejects arrays and scalars. |
+| `_meta`             | `Record<string, unknown>`   | Per-call metadata. Replaces the gateway's default of `{}`.                                                                   |
+
+#### Compact summary example
+
+The most useful combination is `content` alone: a human-readable summary
+replaces the raw serialized body in the model's context, while
+`structuredContent` is still auto-derived from the downstream response. This
+reduces token consumption without losing data.
+
+```ts
+import { ZuploContext, ZuploMcpSdk, ZuploRequest } from "@zuplo/runtime";
+
+export default async function (request: ZuploRequest, context: ZuploContext) {
+  const response = await context.invokeRoute("/todos");
+  new ZuploMcpSdk(context).setRawCallToolResult({
+    content: [{ type: "text", text: "Fetched the todo list" }],
+  });
+  return response;
+}
+```
+
+The model sees `"Fetched the todo list"` instead of the full JSON body, but the
+`structuredContent` field still carries the complete payload for spec-compliant
+clients that read it.
+
+#### Full override example
+
+Override all available fields at once:
+
+```ts
+import { ZuploContext, ZuploMcpSdk, ZuploRequest } from "@zuplo/runtime";
+
+export default async function (request: ZuploRequest, context: ZuploContext) {
+  const response = await context.invokeRoute("/orders");
+  const orders = await response.json();
+
+  new ZuploMcpSdk(context).setRawCallToolResult({
+    content: [
+      {
+        type: "text",
+        text: `Found ${orders.length} orders totaling $${orders.total}`,
+      },
+    ],
+    structuredContent: { orders: orders.items, count: orders.length },
+    _meta: { source: "order-service", version: "2.0" },
+  });
+
+  return response;
+}
+```
+
+:::note
+
+**`isError` is not overridable.** It follows the HTTP status of the response
+your handler returns, so upstream failures cannot be masked. If the downstream
+route returns a non-2xx status, the tool result carries `isError: true`
+regardless of any override.
+
+:::
+
+:::caution{title="Single-use — consumed once"}
+
+The override is **consumed** when the gateway assembles the tool result. It is
+read and deleted from the context at that point, so calling
+`setRawCallToolResult` twice in the same request replaces the first value before
+the gateway reads it.
+
+:::
+
+#### How context lookup works
+
+`setRawCallToolResult` writes the override to the context that carried the
+matching `tools/call` request. The lookup travels exactly one
+`context.invokeRoute` generation up from the context passed to the constructor.
+
+This means:
+
+- In a typical custom tool handler that calls `context.invokeRoute`, the
+  override is written to the parent context (the one carrying the `tools/call`
+  request), which is correct.
+- If your handler calls `invokeRoute` to a route that **also** calls
+  `invokeRoute`, and you construct `ZuploMcpSdk` in that grandchild invocation,
+  the override is stored on the immediate parent — not the grandparent that
+  carries the tool call. The gateway never reads it. Construct `ZuploMcpSdk` in
+  the handler that is one level below the MCP route.
+
+### `getRawCallToolRequest()`
+
+Retrieves the original MCP `tools/call` request object from the context. Use
+this to access metadata like the `_meta` field from the incoming tool call.
+
+```ts
+getRawCallToolRequest(): CallToolRequest | null
+```
+
+Returns the `CallToolRequest` object, or `null` if no MCP tool call is in flight
+on the current or parent context.
+
+```ts
+import { ZuploContext, ZuploMcpSdk, ZuploRequest } from "@zuplo/runtime";
+
+export default async function (request: ZuploRequest, context: ZuploContext) {
+  const sdk = new ZuploMcpSdk(context);
+  const mcpRequest = sdk.getRawCallToolRequest();
+
+  if (mcpRequest) {
+    const meta = mcpRequest.params._meta;
+    context.log.info(`Incoming _meta: ${JSON.stringify(meta)}`);
+  }
+
+  // ... handle the tool call
+}
+```
+
+Unlike `setRawCallToolResult`, this method can be called any number of times —
+the request object is not consumed.
+
+## Output schema enforcement
+
+When a tool advertises an `outputSchema` (via `includeOutputSchema` on the
+handler or route config), the gateway validates the tool result's
+`structuredContent` against that schema before sending it to the client. A
+result whose `structuredContent` does not conform to the advertised schema fails
+the call with a diagnostic `isError` result instead of a raw protocol error.
+
+This enforcement is skipped on the error path (`isError: true`), matching the
+MCP SDK's own behavior.
+
+### `includeOutputSchema` implies `includeStructuredContent`
+
+Advertising an `outputSchema` while returning no `structuredContent` makes the
+advertised schema inaccurate — spec-compliant clients reject the call. When
+`includeOutputSchema` resolves to `true`, the gateway automatically forces
+`includeStructuredContent` to `true` as well, and logs a warning naming the
+route where the override kicked in.
+
+You can set both explicitly to avoid the warning:
+
+```json
+{
+  "x-zuplo-route": {
+    "handler": {
+      "export": "mcpServerHandler",
+      "module": "$import(@zuplo/runtime)",
+      "options": {
+        "includeOutputSchema": true,
+        "includeStructuredContent": true
+      }
+    }
+  }
+}
+```
+
+## Type reference
+
+### `ZuploMcpToolResultOverride`
+
+```ts
+interface ZuploMcpToolResultOverride {
+  content?: CallToolResult["content"];
+  structuredContent?: Record<string, unknown>;
+  _meta?: Record<string, unknown>;
+}
+```
+
+The subset of a `tools/call` result that a module author may override via
+`setRawCallToolResult`. Every field is independently optional.
+
+## See also
+
+- [MCP Server custom tools](../mcp-server/custom-tools.mdx) — how to build
+  custom MCP tool handlers with TypeScript
+- [MCP Server handler](../handlers/mcp-server.mdx) — handler configuration
+  reference including `includeOutputSchema` and `includeStructuredContent`
+- [MCP Gateway introduction](../mcp-gateway/introduction.mdx) — overview of the
+  MCP Gateway product
+- [MCP specification](https://modelcontextprotocol.io/specification/) — the
+  canonical protocol reference

package/docs/self-hosted/overview.md

@@ -72,6 +72,8 @@ solutions architect walks through each item during onboarding.
 
 ### Kubernetes Cluster
 
+- A cluster dedicated to Zuplo. If you want to run Zuplo in a multi-tenant
+  cluster, consult your Zuplo point of contact first.
 - A conformant Kubernetes cluster — managed offerings such as EKS, AKS, and GKE,
   or your own distribution.
 - Support for Services of type `LoadBalancer` to expose the ingress.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zuplo",
-  "version": "7.4.4",
+  "version": "7.4.6",
   "type": "module",
   "description": "The programmable API Gateway",
   "author": "Zuplo, Inc.",
@@ -19,9 +19,9 @@
     "zuplo": "zuplo.js"
   },
   "dependencies": {
-    "@zuplo/cli": "7.4.4",
-    "@zuplo/core": "7.4.4",
-    "@zuplo/runtime": "7.4.4",
-    "@zuplo/test": "7.4.4"
+    "@zuplo/cli": "7.4.6",
+    "@zuplo/core": "7.4.6",
+    "@zuplo/runtime": "7.4.6",
+    "@zuplo/test": "7.4.6"
   }
 }