@zuplo/cli 7.3.2 → 7.4.1

package/node_modules/@zuplo/runtime/out/types/index.d.ts

@@ -345,8 +345,9 @@ export declare interface AIGatewayConfigurationLoaderV2InboundPolicyOptions {
  * identifiers, API keys and other credentials) using the in-gateway DLP
  * engine, and applies per-rule actions: mask, block, or log. Detection runs
  * entirely inside the gateway; nothing is sent to a third-party scanning
- * service. Streaming responses are scanned as they stream, chunk by chunk
- * with a sliding boundary window, rather than being buffered to the end.
+ * service. Streaming responses are scanned as they stream by default (chunk
+ * by chunk with a sliding boundary window); `streaming.mode: "buffer"`
+ * instead collects the whole response and scans it once as one document.
  *
  * Options are validated at request time and invalid options fail closed with
  * a ConfigurationError. Content that cannot be inspected is denied by
@@ -367,13 +368,13 @@ export declare function AIGatewayDlpInboundPolicy(
 ): Promise<ZuploRequest | Response>;
 
 /**
- * The options for the Data Loss Prevention (DLP) policy. Scans the content of AI requests and responses — system prompts, messages, and tool-call arguments — for sensitive data such as credit cards, national identifiers, and API keys, applying a per-rule action (mask, block, or log). Detection runs entirely inside the gateway and streaming responses are scanned as they stream.
+ * The options for the Data Loss Prevention (DLP) policy. Scans the content of AI requests and responses — system prompts, messages, and tool-call arguments — for sensitive data such as credit cards, national identifiers, and API keys, applying a per-rule action (mask, block, or log). Detection runs entirely inside the gateway; streaming responses are scanned as they stream (or collected and scanned whole with `streaming.mode: "buffer"`).
  * @public
  */
 export declare interface AIGatewayDlpInboundPolicyOptions {
   rules: DlpRules;
   /**
-   * Your own detection rules alongside the built-ins: the same rule object plus a `name`, a regex `pattern`, and optional `context` words.
+   * Your own detectors: a `name`, a regex `pattern`, and optional `context` words. A detector does nothing by itself — activate it by name inside `rules.inbound` or `rules.outbound`, exactly like a built-in type, with its own action, detection level, and mask per direction.
    */
   customRules?: DlpCustomRule[];
   /**
@@ -4861,7 +4862,7 @@ declare interface DlpCustomPattern_2 {
 
 declare interface DlpCustomRule {
   /**
-   * Identifier reported in findings and block details for this rule.
+   * The detector's name — the key you use to activate it inside `rules.inbound` or `rules.outbound`, exactly like a built-in type id. Must be distinct and must not reuse a built-in type id or group selector.
    */
   name: string;
   /**
@@ -4869,68 +4870,16 @@ declare interface DlpCustomRule {
    */
   pattern: string;
   /**
-   * Context words for this rule. With `detection: "corroborated"` the rule only fires when one of these words appears near the match.
+   * Context words for this detector. An activation with `detection: "corroborated"` then only fires when one of these words appears near the match.
    */
   context?: string[];
-  /**
-   * What happens when this rule matches, in BOTH directions. `mask` replaces the matched text with a placeholder and the conversation continues; `block` rejects the request or terminates the response with an error naming only the rule's name (never the values); `log` records a finding and lets the traffic pass unchanged; `off` disables the rule. A rule states either `action` or the directional pair (`inboundAction`/`outboundAction`), never both.
-   */
-  action?: "mask" | "block" | "log" | "off";
-  /**
-   * What happens when this rule matches in what callers send the model. Use with `outboundAction` to give the rule different behavior per direction. Omitting it (or `off`) leaves the inbound direction unscanned for this rule. Cannot be combined with `action`.
-   */
-  inboundAction?: "mask" | "block" | "log" | "off";
-  /**
-   * What happens when this rule matches in what the model sends back. Omitting it (or `off`) leaves the outbound direction unscanned for this rule. Cannot be combined with `action`.
-   */
-  outboundAction?: "mask" | "block" | "log" | "off";
-  /**
-   * How much evidence a match needs before this rule acts. `corroborated` additionally requires one of the type's context words near the match (types that define no context words behave as `standard`); `standard` uses the catalog as tuned — distinctive shapes act on their own while ambiguous shapes need nearby context; `aggressive` counts every pattern match and is false-positive-prone — pair it with the `log` action for audits. Overrides the policy-level `detection` for this rule.
-   */
-  detection?: "corroborated" | "standard" | "aggressive";
-  /**
-   * Replacement text for this rule's masked matches. The `{type}` token inserts the detected type id in UPPER_SNAKE form, so the default turns a matched email into `[CONTACT_EMAIL]` — typed placeholders keep masked conversations legible to the model. Set a literal like `[REDACTED]` to hide the type.
-   */
-  mask?: string;
-  partialMask?: DlpPartialMask;
-}
-
-declare interface DlpPartialMask {
-  /**
-   * Keep the last N characters of the matched value unmasked and replace the rest with `*`, preserving length (for example `**** **** **** 4242`). Values no longer than N characters are fully masked.
-   */
-  keepLast: number;
-}
-
-declare interface DlpRule {
-  /**
-   * What happens when this type is found, in BOTH directions. `mask` replaces the matched text with a placeholder and the conversation continues; `block` rejects the request or terminates the response with an error naming only the detected types (never the values); `log` records a finding and lets the traffic pass unchanged — use it to trial a rule before enforcing it; `off` excludes this type from a group enabled by a broader key. A rule states either `action` or the directional pair (`inboundAction`/`outboundAction`), never both.
-   */
-  action?: "mask" | "block" | "log" | "off";
-  /**
-   * What happens when this type is found in what callers send the model (system prompt, message text, and tool-call arguments). Use with `outboundAction` to give one type different behavior per direction — for example mask PII on the way in and block it on the way out. Omitting it (or `off`) leaves the inbound direction unscanned for this type. Cannot be combined with `action`.
-   */
-  inboundAction?: "mask" | "block" | "log" | "off";
-  /**
-   * What happens when this type is found in what the model sends back (buffered responses whole, streaming responses as they stream). Omitting it (or `off`) leaves the outbound direction unscanned for this type. Cannot be combined with `action`.
-   */
-  outboundAction?: "mask" | "block" | "log" | "off";
-  /**
-   * How much evidence a match needs before this rule acts. `corroborated` additionally requires one of the type's context words near the match (types that define no context words behave as `standard`); `standard` uses the catalog as tuned — distinctive shapes act on their own while ambiguous shapes need nearby context; `aggressive` counts every pattern match and is false-positive-prone — pair it with the `log` action for audits. Overrides the policy-level `detection` for this rule.
-   */
-  detection?: "corroborated" | "standard" | "aggressive";
-  /**
-   * Replacement text for this rule's masked matches. The `{type}` token inserts the detected type id in UPPER_SNAKE form, so the default turns a matched email into `[CONTACT_EMAIL]` — typed placeholders keep masked conversations legible to the model. Set a literal like `[REDACTED]` to hide the type.
-   */
-  mask?: string;
-  partialMask?: DlpPartialMask;
 }
 
 /**
- * What to find and what to do about it. Each key is a built-in data type id (like `id-us-ssn`) or a group selector (like `pii` or `secret`, plus any dash-aligned id prefix such as `secret-aws`); each value is a rule object stating either one `action` for both directions or a directional pair (`inboundAction`/`outboundAction`) — for example mask PII inbound and block it outbound. Types you do not mention are not scanned. The most specific key wins — an exact id beats a prefix beats a group — and the winning entry decides everything for its type. When one stretch of text matches multiple rules, the severest action wins (block > mask > log). At least one rule must scan something.
+ * What to find in this direction and what to do about it. Each key is a built-in data type id (like `id-us-ssn`), a group selector (like `pii` or `secret`, plus any dash-aligned id prefix such as `secret-aws`), or one of your custom detectors by name; each value is a rule object whose required `action` says what happens on a match. Types you do not mention are not scanned in this direction. The most specific key wins — an exact id beats a prefix beats a group — and the winning entry decides everything for its type in this direction. When one stretch of text matches multiple rules, the severest action wins (block > mask > log).
  * @public
  */
-declare interface DlpRules {
+declare interface DlpDirectionRules {
   contact?: DlpRule;
   finance?: DlpRule;
   "finance-us"?: DlpRule;
@@ -5014,23 +4963,56 @@ declare interface DlpRules {
   "secret-terraform"?: DlpRule;
   "secret-twilio"?: DlpRule;
   "secret-zuplo"?: DlpRule;
+  [k: string]: unknown;
+}
+
+declare interface DlpPartialMask {
+  /**
+   * Keep the last N characters of the matched value unmasked and replace the rest with `*`, preserving length (for example `**** **** **** 4242`). Values no longer than N characters are fully masked.
+   */
+  keepLast: number;
+}
+
+declare interface DlpRule {
+  /**
+   * What happens when this rule matches in this direction. `mask` replaces the matched text with a placeholder and the conversation continues; `block` rejects the request or terminates the response with an error naming only the detected types (never the values); `log` records a finding and lets the traffic pass unchanged — use it to trial a rule before enforcing it; `off` excludes this type from a group enabled by a broader key in the same section.
+   */
+  action: "mask" | "block" | "log" | "off";
+  /**
+   * How much evidence a match needs before this rule acts. `corroborated` additionally requires one of the type's context words near the match (types that define no context words behave as `standard`); `standard` uses the catalog as tuned — distinctive shapes act on their own while ambiguous shapes need nearby context; `aggressive` counts every pattern match and is false-positive-prone — pair it with the `log` action for audits. Overrides the policy-level `detection` for this rule.
+   */
+  detection?: "corroborated" | "standard" | "aggressive";
+  /**
+   * Replacement text for this rule's masked matches. The `{type}` token inserts the detected type id in UPPER_SNAKE form, so the default turns a matched email into `[CONTACT_EMAIL]` — typed placeholders keep masked conversations legible to the model. Set a literal like `[REDACTED]` to hide the type.
+   */
+  mask?: string;
+  partialMask?: DlpPartialMask;
+}
+
+/**
+ * The scan configuration, split by direction: `inbound` covers what callers send the model (system prompt, message text, and tool-call arguments); `outbound` covers what the model sends back (buffered responses whole, streaming responses as they stream). Each direction you include is scanned; each you omit is left untouched — there is no "both" shorthand and no mirroring, so wanting the same behavior on both sides means stating it in both sections. At least one section must enable at least one rule.
+ * @public
+ */
+declare interface DlpRules {
+  inbound?: DlpDirectionRules;
+  outbound?: DlpDirectionRules;
 }
 
 /**
- * Tuning for streaming (SSE) response scanning. Each chunk is held until the boundary scan that includes its successor passes, then released — so values split across chunks are always fully maskable, at the cost of one chunk of latency.
+ * How streaming (SSE) responses are inspected. `stream` (the default) scans deltas as they flow, holding each chunk until the boundary scan that includes its successor passes — values split across chunks stay maskable at the cost of one chunk of latency. `buffer` collects the entire response and scans it once as one document — exact detection for values of any length, and a blocked response is a clean 400 because nothing has been delivered yet — at the cost of the client waiting for the full generation. `off` passes streaming responses through unscanned.
  * @public
  */
 declare interface DlpStreamingSettings {
   /**
-   * Scan streaming responses. When false, streaming responses pass through unscanned even when rules cover the outbound direction.
+   * `stream` scans deltas in flight with the windowed scanner. `buffer` holds the entire response and scans it once, exactly like a non-streaming response: values of any length are caught (no carry window) and a block is a native 400 error instead of a mid-stream termination, but the client receives nothing until the model finishes. `off` skips scanning of streaming responses entirely, even when rules cover the outbound direction.
    */
-  enabled?: boolean;
+  mode?: "stream" | "buffer" | "off";
   /**
-   * Scan across chunk boundaries using a carried tail of already-scanned text. When false, each chunk is scanned alone and released immediately — lower cost, but values split across two chunks are missed.
+   * Scan across chunk boundaries using a carried tail of already-scanned text. When false, each chunk is scanned alone and released immediately — lower cost, but values split across two chunks are missed. Applies to `stream` mode only.
    */
   boundaryScan?: boolean;
   /**
-   * How many trailing characters are carried from one chunk into the next boundary scan. Bounds memory and re-scan cost; must be larger than the longest value you need to catch.
+   * How many trailing characters are carried from one chunk into the next boundary scan. Bounds memory and re-scan cost; must be larger than the longest value you need to catch. Applies to `stream` mode only — `buffer` mode always scans the complete text.
    */
   maxCarryChars?: number;
 }

package/node_modules/@zuplo/runtime/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zuplo/runtime",
   "type": "module",
-  "version": "7.3.2",
+  "version": "7.4.1",
   "repository": "https://github.com/zuplo/zuplo",
   "author": "Zuplo, Inc.",
   "exports": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zuplo/cli",
-  "version": "7.3.2",
+  "version": "7.4.1",
   "repository": "https://github.com/zuplo/zuplo",
   "author": "Zuplo, Inc.",
   "type": "module",
@@ -28,10 +28,10 @@
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/api-logs": "0.220.0",
     "@swc/core": "1.10.18",
-    "@zuplo/core": "7.3.2",
+    "@zuplo/core": "7.4.1",
     "@zuplo/editor": "1.0.31094607111",
-    "@zuplo/openapi-tools": "7.3.2",
-    "@zuplo/runtime": "7.3.2",
+    "@zuplo/openapi-tools": "7.4.1",
+    "@zuplo/runtime": "7.4.1",
     "chalk": "5.4.1",
     "chokidar": "3.5.3",
     "cookie": "1.0.2",
@@ -62,8 +62,15 @@
     "workerd": "1.20241230.0",
     "yargs": "17.7.2",
     "zod": "4.4.3",
-    "@zuplo/graphql": "7.3.2",
-    "@zuplo/otel": "7.3.2"
+    "@zuplo/graphql": "7.4.1",
+    "@zuplo/otel": "7.4.1"
+  },
+  "optionalDependencies": {
+    "@zuplo/lint-darwin-arm64": "7.4.1",
+    "@zuplo/lint-darwin-x64": "7.4.1",
+    "@zuplo/lint-linux-x64": "7.4.1",
+    "@zuplo/lint-linux-arm64": "7.4.1",
+    "@zuplo/lint-win32-x64": "7.4.1"
   },
   "bundleDependencies": [
     "@inquirer/prompts",