@meetkai/mka1 0.55.25 → 0.55.27

package/src/models/components/classifierguardrail.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -18,6 +19,26 @@ import {
   GuardrailInputSource$inboundSchema,
   GuardrailInputSource$outboundSchema,
 } from "./guardrailinputsource.js";
+import {
+  OutputWindow,
+  OutputWindow$inboundSchema,
+  OutputWindow$Outbound,
+  OutputWindow$outboundSchema,
+} from "./outputwindow.js";
+
+/**
+ * When this rule checks model output: final (default) checks the finished text once, after it has streamed; streaming holds streamed text in a window and releases only text this rule has cleared
+ */
+export const ClassifierGuardrailOutputTiming = {
+  Final: "final",
+  Streaming: "streaming",
+} as const;
+/**
+ * When this rule checks model output: final (default) checks the finished text once, after it has streamed; streaming holds streamed text in a window and releases only text this rule has cleared
+ */
+export type ClassifierGuardrailOutputTiming = ClosedEnum<
+  typeof ClassifierGuardrailOutputTiming
+>;
 
 export type ClassifierGuardrail = {
   mode: "classifier";
@@ -29,6 +50,14 @@ export type ClassifierGuardrail = {
    * Also apply this guardrail to model output, not just the request
    */
   checkOutput?: boolean | undefined;
+  /**
+   * When this rule checks model output: final (default) checks the finished text once, after it has streamed; streaming holds streamed text in a window and releases only text this rule has cleared
+   */
+  outputTiming?: ClassifierGuardrailOutputTiming | undefined;
+  /**
+   * When a streaming output check runs: whichever of max_chars and max_ms fills first
+   */
+  outputWindow?: OutputWindow | undefined;
   /**
    * Request sources this guardrail checks before they reach the model. Omit to use the mode's default: every source for classifier; every source except system for ban_words, since instructions often name the terms they forbid; only what the user sends for prompt_injection and leakage, whose keyword patterns match ordinary instructions, replies and documents. An empty list checks no input, so the rule only checks output when check_output is set. Rules saved before this field existed were set to user messages only.
    */
@@ -36,6 +65,15 @@ export type ClassifierGuardrail = {
   config: ClassifierConfig;
 };
 
+/** @internal */
+export const ClassifierGuardrailOutputTiming$inboundSchema: z.ZodNativeEnum<
+  typeof ClassifierGuardrailOutputTiming
+> = z.nativeEnum(ClassifierGuardrailOutputTiming);
+/** @internal */
+export const ClassifierGuardrailOutputTiming$outboundSchema: z.ZodNativeEnum<
+  typeof ClassifierGuardrailOutputTiming
+> = ClassifierGuardrailOutputTiming$inboundSchema;
+
 /** @internal */
 export const ClassifierGuardrail$inboundSchema: z.ZodType<
   ClassifierGuardrail,
@@ -45,11 +83,15 @@ export const ClassifierGuardrail$inboundSchema: z.ZodType<
   mode: z.literal("classifier"),
   enabled: z.boolean().default(true),
   check_output: z.boolean().optional(),
+  output_timing: ClassifierGuardrailOutputTiming$inboundSchema.optional(),
+  output_window: OutputWindow$inboundSchema.optional(),
   input_sources: z.array(GuardrailInputSource$inboundSchema).optional(),
   config: ClassifierConfig$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "check_output": "checkOutput",
+    "output_timing": "outputTiming",
+    "output_window": "outputWindow",
     "input_sources": "inputSources",
   });
 });
@@ -58,6 +100,8 @@ export type ClassifierGuardrail$Outbound = {
   mode: "classifier";
   enabled: boolean;
   check_output?: boolean | undefined;
+  output_timing?: string | undefined;
+  output_window?: OutputWindow$Outbound | undefined;
   input_sources?: Array<string> | undefined;
   config: ClassifierConfig$Outbound;
 };
@@ -71,11 +115,15 @@ export const ClassifierGuardrail$outboundSchema: z.ZodType<
   mode: z.literal("classifier"),
   enabled: z.boolean().default(true),
   checkOutput: z.boolean().optional(),
+  outputTiming: ClassifierGuardrailOutputTiming$outboundSchema.optional(),
+  outputWindow: OutputWindow$outboundSchema.optional(),
   inputSources: z.array(GuardrailInputSource$outboundSchema).optional(),
   config: ClassifierConfig$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
     checkOutput: "check_output",
+    outputTiming: "output_timing",
+    outputWindow: "output_window",
     inputSources: "input_sources",
   });
 });

package/src/models/components/clusterdefaultrulesummary.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -18,6 +19,20 @@ import {
   GuardrailMode$outboundSchema,
 } from "./guardrailmode.js";
 
+/**
+ * When this guardrail checks model output: once on the finished text (final, the default) or while it streams
+ */
+export const ClusterDefaultRuleSummaryOutputTiming = {
+  Final: "final",
+  Streaming: "streaming",
+} as const;
+/**
+ * When this guardrail checks model output: once on the finished text (final, the default) or while it streams
+ */
+export type ClusterDefaultRuleSummaryOutputTiming = ClosedEnum<
+  typeof ClusterDefaultRuleSummaryOutputTiming
+>;
+
 /**
  * A cluster default guardrail, without the operator's configuration
  */
@@ -28,6 +43,10 @@ export type ClusterDefaultRuleSummary = {
    * Whether this guardrail also checks model output
    */
   checkOutput?: boolean | undefined;
+  /**
+   * When this guardrail checks model output: once on the finished text (final, the default) or while it streams
+   */
+  outputTiming?: ClusterDefaultRuleSummaryOutputTiming | undefined;
   /**
    * Request sources this guardrail checks
    */
@@ -38,6 +57,16 @@ export type ClusterDefaultRuleSummary = {
   rejectionMessage?: string | undefined;
 };
 
+/** @internal */
+export const ClusterDefaultRuleSummaryOutputTiming$inboundSchema:
+  z.ZodNativeEnum<typeof ClusterDefaultRuleSummaryOutputTiming> = z.nativeEnum(
+    ClusterDefaultRuleSummaryOutputTiming,
+  );
+/** @internal */
+export const ClusterDefaultRuleSummaryOutputTiming$outboundSchema:
+  z.ZodNativeEnum<typeof ClusterDefaultRuleSummaryOutputTiming> =
+    ClusterDefaultRuleSummaryOutputTiming$inboundSchema;
+
 /** @internal */
 export const ClusterDefaultRuleSummary$inboundSchema: z.ZodType<
   ClusterDefaultRuleSummary,
@@ -47,11 +76,13 @@ export const ClusterDefaultRuleSummary$inboundSchema: z.ZodType<
   mode: GuardrailMode$inboundSchema,
   enabled: z.boolean(),
   check_output: z.boolean().optional(),
+  output_timing: ClusterDefaultRuleSummaryOutputTiming$inboundSchema.optional(),
   input_sources: z.array(GuardrailInputSource$inboundSchema),
   rejection_message: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     "check_output": "checkOutput",
+    "output_timing": "outputTiming",
     "input_sources": "inputSources",
     "rejection_message": "rejectionMessage",
   });
@@ -61,6 +92,7 @@ export type ClusterDefaultRuleSummary$Outbound = {
   mode: string;
   enabled: boolean;
   check_output?: boolean | undefined;
+  output_timing?: string | undefined;
   input_sources: Array<string>;
   rejection_message?: string | undefined;
 };
@@ -74,11 +106,13 @@ export const ClusterDefaultRuleSummary$outboundSchema: z.ZodType<
   mode: GuardrailMode$outboundSchema,
   enabled: z.boolean(),
   checkOutput: z.boolean().optional(),
+  outputTiming: ClusterDefaultRuleSummaryOutputTiming$outboundSchema.optional(),
   inputSources: z.array(GuardrailInputSource$outboundSchema),
   rejectionMessage: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     checkOutput: "check_output",
+    outputTiming: "output_timing",
     inputSources: "input_sources",
     rejectionMessage: "rejection_message",
   });

package/src/models/components/createvectorstorerequest.ts

@@ -87,7 +87,7 @@ export type CreateVectorStoreRequest = {
    */
   embeddingModel?: string | undefined;
   /**
-   * The number of dimensions for the embedding vectors. Only supported for models with flexible dimensions. If not specified, uses the model's default dimensions.
+   * The number of dimensions for the embedding vectors. Must equal the model's size when it is fixed, or lie within its range (`embedding_dimension_range` on `GET /models/{model_id}`). If not specified, uses the model's default dimensions. The store stays searchable only while the model's declared dimensions still include this size and the model returns embeddings of this width.
    */
   embeddingDimensions?: number | undefined;
   /**

package/src/models/components/embeddingmodellimits.ts

@@ -13,15 +13,15 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
  */
 export type EmbeddingModelLimits = {
   /**
-   * Maximum number of inputs allowed in a single batch request
+   * Maximum number of inputs allowed in a single batch request: the model's batch size or the gateway-wide 10,000-input limit, whichever is lower, on `POST /embeddings`. Batch `/v1/embeddings` lines are held only to the model's batch size.
    */
   maxBatchSize: number;
   /**
-   * Maximum tokens per individual input (derived from contextWindow)
+   * Maximum tokens per individual input: the model's context window. Null when the registry records no context window: no token cap applies beyond what `max_input_length` implies. For a window long enough that its estimated character length exceeds the gateway-wide character limit, `max_input_length` binds first. Advisory on `/embeddings`, which accepts only strings and enforces `max_input_length`.
    */
-  maxInputTokens: number;
+  maxInputTokens: number | null;
   /**
-   * Maximum characters per individual input (contextWindow * 2)
+   * Maximum characters per individual input: the cap derived from the model's context window or the gateway-wide 100,000-character limit, whichever is lower, on `POST /embeddings`. Batch `/v1/embeddings` lines are held only to the model's cap.
    */
   maxInputLength: number;
 };
@@ -32,9 +32,9 @@ export const EmbeddingModelLimits$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  max_batch_size: z.number(),
-  max_input_tokens: z.number(),
-  max_input_length: z.number(),
+  max_batch_size: z.number().int(),
+  max_input_tokens: z.nullable(z.number().int()),
+  max_input_length: z.number().int(),
 }).transform((v) => {
   return remap$(v, {
     "max_batch_size": "maxBatchSize",
@@ -45,7 +45,7 @@ export const EmbeddingModelLimits$inboundSchema: z.ZodType<
 /** @internal */
 export type EmbeddingModelLimits$Outbound = {
   max_batch_size: number;
-  max_input_tokens: number;
+  max_input_tokens: number | null;
   max_input_length: number;
 };
 
@@ -55,9 +55,9 @@ export const EmbeddingModelLimits$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   EmbeddingModelLimits
 > = z.object({
-  maxBatchSize: z.number(),
-  maxInputTokens: z.number(),
-  maxInputLength: z.number(),
+  maxBatchSize: z.number().int(),
+  maxInputTokens: z.nullable(z.number().int()),
+  maxInputLength: z.number().int(),
 }).transform((v) => {
   return remap$(v, {
     maxBatchSize: "max_batch_size",

package/src/models/components/embeddingsrequest.ts

@@ -39,7 +39,7 @@ export type EmbeddingsRequest = {
    */
   model: string;
   /**
-   * The number of dimensions the resulting output embeddings should have. Only supported in certain models.
+   * The number of dimensions the resulting output embeddings should have. Ignored for a model with a fixed size, which always returns that size. For a model with a range it must lie within the range (`embedding_dimension_range` on `GET /models/{model_id}`), or the request fails with 400.
    */
   dimensions?: number | undefined;
   /**

package/src/models/components/index.ts

@@ -534,6 +534,7 @@ export * from "./outputref.js";
 export * from "./outputspec.js";
 export * from "./outputtext.js";
 export * from "./outputtokensdetails.js";
+export * from "./outputwindow.js";
 export * from "./pagegeneration.js";
 export * from "./pagelogline.js";
 export * from "./param.js";

package/src/models/components/leakageguardrail.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -18,6 +19,26 @@ import {
   LeakageConfig$Outbound,
   LeakageConfig$outboundSchema,
 } from "./leakageconfig.js";
+import {
+  OutputWindow,
+  OutputWindow$inboundSchema,
+  OutputWindow$Outbound,
+  OutputWindow$outboundSchema,
+} from "./outputwindow.js";
+
+/**
+ * When this rule checks model output: final (default) checks the finished text once, after it has streamed; streaming holds streamed text in a window and releases only text this rule has cleared
+ */
+export const LeakageGuardrailOutputTiming = {
+  Final: "final",
+  Streaming: "streaming",
+} as const;
+/**
+ * When this rule checks model output: final (default) checks the finished text once, after it has streamed; streaming holds streamed text in a window and releases only text this rule has cleared
+ */
+export type LeakageGuardrailOutputTiming = ClosedEnum<
+  typeof LeakageGuardrailOutputTiming
+>;
 
 /**
  * Leakage guardrail
@@ -32,6 +53,14 @@ export type LeakageGuardrail = {
    * Also apply this guardrail to model output, not just the request
    */
   checkOutput?: boolean | undefined;
+  /**
+   * When this rule checks model output: final (default) checks the finished text once, after it has streamed; streaming holds streamed text in a window and releases only text this rule has cleared
+   */
+  outputTiming?: LeakageGuardrailOutputTiming | undefined;
+  /**
+   * When a streaming output check runs: whichever of max_chars and max_ms fills first
+   */
+  outputWindow?: OutputWindow | undefined;
   /**
    * Request sources this guardrail checks before they reach the model. Omit to use the mode's default: every source for classifier; every source except system for ban_words, since instructions often name the terms they forbid; only what the user sends for prompt_injection and leakage, whose keyword patterns match ordinary instructions, replies and documents. An empty list checks no input, so the rule only checks output when check_output is set. Rules saved before this field existed were set to user messages only.
    */
@@ -42,6 +71,15 @@ export type LeakageGuardrail = {
   config?: LeakageConfig | undefined;
 };
 
+/** @internal */
+export const LeakageGuardrailOutputTiming$inboundSchema: z.ZodNativeEnum<
+  typeof LeakageGuardrailOutputTiming
+> = z.nativeEnum(LeakageGuardrailOutputTiming);
+/** @internal */
+export const LeakageGuardrailOutputTiming$outboundSchema: z.ZodNativeEnum<
+  typeof LeakageGuardrailOutputTiming
+> = LeakageGuardrailOutputTiming$inboundSchema;
+
 /** @internal */
 export const LeakageGuardrail$inboundSchema: z.ZodType<
   LeakageGuardrail,
@@ -51,11 +89,15 @@ export const LeakageGuardrail$inboundSchema: z.ZodType<
   mode: z.literal("leakage"),
   enabled: z.boolean().default(true),
   check_output: z.boolean().optional(),
+  output_timing: LeakageGuardrailOutputTiming$inboundSchema.optional(),
+  output_window: OutputWindow$inboundSchema.optional(),
   input_sources: z.array(GuardrailInputSource$inboundSchema).optional(),
   config: LeakageConfig$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "check_output": "checkOutput",
+    "output_timing": "outputTiming",
+    "output_window": "outputWindow",
     "input_sources": "inputSources",
   });
 });
@@ -64,6 +106,8 @@ export type LeakageGuardrail$Outbound = {
   mode: "leakage";
   enabled: boolean;
   check_output?: boolean | undefined;
+  output_timing?: string | undefined;
+  output_window?: OutputWindow$Outbound | undefined;
   input_sources?: Array<string> | undefined;
   config?: LeakageConfig$Outbound | undefined;
 };
@@ -77,11 +121,15 @@ export const LeakageGuardrail$outboundSchema: z.ZodType<
   mode: z.literal("leakage"),
   enabled: z.boolean().default(true),
   checkOutput: z.boolean().optional(),
+  outputTiming: LeakageGuardrailOutputTiming$outboundSchema.optional(),
+  outputWindow: OutputWindow$outboundSchema.optional(),
   inputSources: z.array(GuardrailInputSource$outboundSchema).optional(),
   config: LeakageConfig$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     checkOutput: "check_output",
+    outputTiming: "output_timing",
+    outputWindow: "output_window",
     inputSources: "input_sources",
   });
 });

package/src/models/components/outputwindow.ts

@@ -0,0 +1,71 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * When a streaming output check runs: whichever of max_chars and max_ms fills first
+ */
+export type OutputWindow = {
+  /**
+   * Check once this many characters of unchecked text have accumulated
+   */
+  maxChars?: number | undefined;
+  /**
+   * Check once the oldest unchecked text has been held this many milliseconds
+   */
+  maxMs?: number | undefined;
+};
+
+/** @internal */
+export const OutputWindow$inboundSchema: z.ZodType<
+  OutputWindow,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  max_chars: z.number().int().optional(),
+  max_ms: z.number().int().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "max_chars": "maxChars",
+    "max_ms": "maxMs",
+  });
+});
+/** @internal */
+export type OutputWindow$Outbound = {
+  max_chars?: number | undefined;
+  max_ms?: number | undefined;
+};
+
+/** @internal */
+export const OutputWindow$outboundSchema: z.ZodType<
+  OutputWindow$Outbound,
+  z.ZodTypeDef,
+  OutputWindow
+> = z.object({
+  maxChars: z.number().int().optional(),
+  maxMs: z.number().int().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    maxChars: "max_chars",
+    maxMs: "max_ms",
+  });
+});
+
+export function outputWindowToJSON(outputWindow: OutputWindow): string {
+  return JSON.stringify(OutputWindow$outboundSchema.parse(outputWindow));
+}
+export function outputWindowFromJSON(
+  jsonString: string,
+): SafeParseResult<OutputWindow, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OutputWindow$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OutputWindow' from JSON`,
+  );
+}

package/src/models/components/promptinjectionguardrail.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -12,6 +13,12 @@ import {
   GuardrailInputSource$inboundSchema,
   GuardrailInputSource$outboundSchema,
 } from "./guardrailinputsource.js";
+import {
+  OutputWindow,
+  OutputWindow$inboundSchema,
+  OutputWindow$Outbound,
+  OutputWindow$outboundSchema,
+} from "./outputwindow.js";
 import {
   PromptInjectionConfig,
   PromptInjectionConfig$inboundSchema,
@@ -19,6 +26,20 @@ import {
   PromptInjectionConfig$outboundSchema,
 } from "./promptinjectionconfig.js";
 
+/**
+ * When this rule checks model output: final (default) checks the finished text once, after it has streamed; streaming holds streamed text in a window and releases only text this rule has cleared
+ */
+export const PromptInjectionGuardrailOutputTiming = {
+  Final: "final",
+  Streaming: "streaming",
+} as const;
+/**
+ * When this rule checks model output: final (default) checks the finished text once, after it has streamed; streaming holds streamed text in a window and releases only text this rule has cleared
+ */
+export type PromptInjectionGuardrailOutputTiming = ClosedEnum<
+  typeof PromptInjectionGuardrailOutputTiming
+>;
+
 /**
  * Prompt injection guardrail
  */
@@ -32,6 +53,14 @@ export type PromptInjectionGuardrail = {
    * Also apply this guardrail to model output, not just the request
    */
   checkOutput?: boolean | undefined;
+  /**
+   * When this rule checks model output: final (default) checks the finished text once, after it has streamed; streaming holds streamed text in a window and releases only text this rule has cleared
+   */
+  outputTiming?: PromptInjectionGuardrailOutputTiming | undefined;
+  /**
+   * When a streaming output check runs: whichever of max_chars and max_ms fills first
+   */
+  outputWindow?: OutputWindow | undefined;
   /**
    * Request sources this guardrail checks before they reach the model. Omit to use the mode's default: every source for classifier; every source except system for ban_words, since instructions often name the terms they forbid; only what the user sends for prompt_injection and leakage, whose keyword patterns match ordinary instructions, replies and documents. An empty list checks no input, so the rule only checks output when check_output is set. Rules saved before this field existed were set to user messages only.
    */
@@ -42,6 +71,16 @@ export type PromptInjectionGuardrail = {
   config?: PromptInjectionConfig | undefined;
 };
 
+/** @internal */
+export const PromptInjectionGuardrailOutputTiming$inboundSchema:
+  z.ZodNativeEnum<typeof PromptInjectionGuardrailOutputTiming> = z.nativeEnum(
+    PromptInjectionGuardrailOutputTiming,
+  );
+/** @internal */
+export const PromptInjectionGuardrailOutputTiming$outboundSchema:
+  z.ZodNativeEnum<typeof PromptInjectionGuardrailOutputTiming> =
+    PromptInjectionGuardrailOutputTiming$inboundSchema;
+
 /** @internal */
 export const PromptInjectionGuardrail$inboundSchema: z.ZodType<
   PromptInjectionGuardrail,
@@ -51,11 +90,15 @@ export const PromptInjectionGuardrail$inboundSchema: z.ZodType<
   mode: z.literal("prompt_injection"),
   enabled: z.boolean().default(true),
   check_output: z.boolean().optional(),
+  output_timing: PromptInjectionGuardrailOutputTiming$inboundSchema.optional(),
+  output_window: OutputWindow$inboundSchema.optional(),
   input_sources: z.array(GuardrailInputSource$inboundSchema).optional(),
   config: PromptInjectionConfig$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "check_output": "checkOutput",
+    "output_timing": "outputTiming",
+    "output_window": "outputWindow",
     "input_sources": "inputSources",
   });
 });
@@ -64,6 +107,8 @@ export type PromptInjectionGuardrail$Outbound = {
   mode: "prompt_injection";
   enabled: boolean;
   check_output?: boolean | undefined;
+  output_timing?: string | undefined;
+  output_window?: OutputWindow$Outbound | undefined;
   input_sources?: Array<string> | undefined;
   config?: PromptInjectionConfig$Outbound | undefined;
 };
@@ -77,11 +122,15 @@ export const PromptInjectionGuardrail$outboundSchema: z.ZodType<
   mode: z.literal("prompt_injection"),
   enabled: z.boolean().default(true),
   checkOutput: z.boolean().optional(),
+  outputTiming: PromptInjectionGuardrailOutputTiming$outboundSchema.optional(),
+  outputWindow: OutputWindow$outboundSchema.optional(),
   inputSources: z.array(GuardrailInputSource$outboundSchema).optional(),
   config: PromptInjectionConfig$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     checkOutput: "check_output",
+    outputTiming: "output_timing",
+    outputWindow: "output_window",
     inputSources: "input_sources",
   });
 });

package/src/models/components/tooldefinition.ts

@@ -120,7 +120,7 @@ export const ToolDefinition9Type = {
 export type ToolDefinition9Type = ClosedEnum<typeof ToolDefinition9Type>;
 
 /**
- * Another saved agent of the same team, called as a tool. mkllm-gateway starts a run of that agent and returns its answer.
+ * Another saved agent of the same team, called as a tool. The Responses API starts a run of that agent and returns its answer.
  */
 export type Nine = {
   type: ToolDefinition9Type;

package/src/models/components/vectorstore.ts

@@ -88,7 +88,7 @@ export type VectorStore = {
    */
   embeddingModel: string | null;
   /**
-   * The number of dimensions for the embedding vectors in this vector store. Null for legacy vector stores.
+   * The number of dimensions for the embedding vectors in this vector store. Null for legacy vector stores. If the embedding model's declared dimensions stop including this size, or the model returns embeddings of another width, search fails with 412 and new files fail to ingest.
    */
   embeddingDimensions: number | null;
   /**

package/src/models/operations/getmodel.ts

@@ -160,7 +160,7 @@ export type GetModelResponseBody = {
    */
   outputModalities: Array<string>;
   /**
-   * Context window in tokens, mirroring the registry's `contextWindow`. For an LLM it is the input plus output tokens one request can span: the Responses API trims the oldest conversation items to fit it, reserving nothing for the output, unless the request sets `truncation` to `disabled`, which rejects an oversized request instead; a separate request-size limit in bytes applies the same way. Chat completions forwards requests unchanged. For an embeddings model `/embeddings` derives its per-input character cap from it, which `GET /embeddings/models` reports as `max_input_length`; a gateway-wide per-input ceiling also applies. On other model types the gateway does not read it, so a recorded value is informational only and not enforced. Null when the registry does not record one.
+   * Context window in tokens, mirroring the registry's `contextWindow`. For an LLM it is the input plus output tokens one request can span: the Responses API trims the oldest conversation items to fit it, reserving nothing for the output, unless the request sets `truncation` to `disabled`, which rejects an oversized request instead; a separate request-size limit in bytes applies the same way. Chat completions forwards requests unchanged. For an embeddings model `/embeddings` derives a per-input character cap from it, alongside a gateway-wide per-input ceiling; `GET /embeddings/models` reports whichever binds first as `max_input_length`. On other model types the gateway does not read it, so a recorded value is informational only and not enforced. Null when the registry does not record one.
    */
   contextWindow: number | null;
   /**
@@ -172,7 +172,7 @@ export type GetModelResponseBody = {
    */
   minImageResolution: MinImageResolution | null;
   /**
-   * Output vector sizes declared for this model, mirroring the registry's `embeddingLimits.dimensions`, which is normally recorded only on embeddings models. A model with a single fixed size reports it as `min`, `max` and `default` alike, so when `min` equals `max` the size is fixed and a request should omit `dimensions`. Vector stores reject a size outside the range. `/embeddings` does not check it: it drops a requested `dimensions` for a fixed-size model and otherwise forwards it to the upstream. Null when the registry does not record dimensions; a vector store using such a model must then be created with an explicit size (`embedding_dimensions` on `POST /vector_stores`). Distinct from the vector store's own `embedding_dimensions`, which is a single size.
+   * Output vector sizes declared for this model, mirroring the registry's `embeddingLimits.dimensions`, which is normally recorded only on embeddings models. When `min` equals `max` the size is fixed: `/embeddings` ignores a requested `dimensions` and returns that size, and vector stores accept only that size. Otherwise a requested size must lie within the range: `/embeddings` and vector stores reject one outside it with 400. Null when the registry does not record dimensions; a vector store using such a model must then be created with an explicit size (`embedding_dimensions` on `POST /vector_stores`). Distinct from the vector store's own `embedding_dimensions`, which is a single size.
    */
   embeddingDimensionRange: EmbeddingDimensionRange | null;
   /**