@orq-ai/node 4.1.0-rc.34 → 4.1.0-rc.35

package/src/models/components/conversationresponse.ts

@@ -22,11 +22,29 @@ export type ConversationResponseKind = ClosedEnum<
   typeof ConversationResponseKind
 >;
 
+/**
+ * Optional metadata associated with the conversation.
+ */
+export type Metadata = {
+  /**
+   * Indicates whether the conversation title is currently being generated by AI.
+   */
+  generatingTitle?: boolean | undefined;
+  /**
+   * Identifier of the parent entity (agent, deployment, etc.) this conversation belongs to. Used for filtering conversations by entity.
+   */
+  entityId?: string | undefined;
+};
+
 export type ConversationResponse = {
   /**
    * Unique ULID (Universally Unique Lexicographically Sortable Identifier) for the conversation, prefixed with "conv_"
    */
   id?: string | undefined;
+  /**
+   * Identifier of the parent entity (agent, deployment, etc.) this conversation belongs to.
+   */
+  entityId: string;
   /**
    * Type discriminator indicating this is a conversation
    */
@@ -51,6 +69,10 @@ export type ConversationResponse = {
    * Optional identifier of the user or agent that last updated the conversation
    */
   updatedById?: string | undefined;
+  /**
+   * Optional metadata associated with the conversation.
+   */
+  metadata?: Metadata | undefined;
 };
 
 /** @internal */
@@ -62,33 +84,91 @@ export const ConversationResponseKind$outboundSchema: z.ZodNativeEnum<
   typeof ConversationResponseKind
 > = ConversationResponseKind$inboundSchema;
 
+/** @internal */
+export const Metadata$inboundSchema: z.ZodType<
+  Metadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  generating_title: z.boolean().optional(),
+  entity_id: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "generating_title": "generatingTitle",
+    "entity_id": "entityId",
+  });
+});
+/** @internal */
+export type Metadata$Outbound = {
+  generating_title?: boolean | undefined;
+  entity_id?: string | undefined;
+};
+
+/** @internal */
+export const Metadata$outboundSchema: z.ZodType<
+  Metadata$Outbound,
+  z.ZodTypeDef,
+  Metadata
+> = z.object({
+  generatingTitle: z.boolean().optional(),
+  entityId: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    generatingTitle: "generating_title",
+    entityId: "entity_id",
+  });
+});
+
+export function metadataToJSON(metadata: Metadata): string {
+  return JSON.stringify(Metadata$outboundSchema.parse(metadata));
+}
+export function metadataFromJSON(
+  jsonString: string,
+): SafeParseResult<Metadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Metadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Metadata' from JSON`,
+  );
+}
+
 /** @internal */
 export const ConversationResponse$inboundSchema: z.ZodType<
   ConversationResponse,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("conv_01kbz0nwqcng7ava0ap1zbtxpc"),
+  _id: z.string().default("conv_01kc3ce289afsc6egz69qexm0b"),
+  entity_id: z.string(),
   kind: ConversationResponseKind$inboundSchema,
-  displayName: z.string(),
-  createdAt: z.number(),
-  updatedAt: z.number(),
-  createdById: z.string().optional(),
-  updatedById: z.string().optional(),
+  display_name: z.string(),
+  created_at: z.number(),
+  updated_at: z.number(),
+  created_by_id: z.string().optional(),
+  updated_by_id: z.string().optional(),
+  metadata: z.lazy(() => Metadata$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "_id": "id",
+    "entity_id": "entityId",
+    "display_name": "displayName",
+    "created_at": "createdAt",
+    "updated_at": "updatedAt",
+    "created_by_id": "createdById",
+    "updated_by_id": "updatedById",
   });
 });
 /** @internal */
 export type ConversationResponse$Outbound = {
   _id: string;
+  entity_id: string;
   kind: string;
-  displayName: string;
-  createdAt: number;
-  updatedAt: number;
-  createdById?: string | undefined;
-  updatedById?: string | undefined;
+  display_name: string;
+  created_at: number;
+  updated_at: number;
+  created_by_id?: string | undefined;
+  updated_by_id?: string | undefined;
+  metadata?: Metadata$Outbound | undefined;
 };
 
 /** @internal */
@@ -97,16 +177,24 @@ export const ConversationResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ConversationResponse
 > = z.object({
-  id: z.string().default("conv_01kbz0nwqcng7ava0ap1zbtxpc"),
+  id: z.string().default("conv_01kc3ce289afsc6egz69qexm0b"),
+  entityId: z.string(),
   kind: ConversationResponseKind$outboundSchema,
   displayName: z.string(),
   createdAt: z.number(),
   updatedAt: z.number(),
   createdById: z.string().optional(),
   updatedById: z.string().optional(),
+  metadata: z.lazy(() => Metadata$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     id: "_id",
+    entityId: "entity_id",
+    displayName: "display_name",
+    createdAt: "created_at",
+    updatedAt: "updated_at",
+    createdById: "created_by_id",
+    updatedById: "updated_by_id",
   });
 });
 

package/src/models/components/createagentresponse.ts

@@ -0,0 +1,340 @@
+/*
+ * 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";
+import {
+  AgentResponseMessage,
+  AgentResponseMessage$inboundSchema,
+  AgentResponseMessage$Outbound,
+  AgentResponseMessage$outboundSchema,
+} from "./agentresponsemessage.js";
+
+export type PromptTokensDetails = {
+  cachedTokens?: number | null | undefined;
+  cacheCreationTokens?: number | null | undefined;
+  /**
+   * The number of audio input tokens consumed by the request.
+   */
+  audioTokens?: number | null | undefined;
+};
+
+export type CompletionTokensDetails = {
+  reasoningTokens?: number | null | undefined;
+  acceptedPredictionTokens?: number | null | undefined;
+  rejectedPredictionTokens?: number | null | undefined;
+  /**
+   * The number of audio output tokens produced by the response.
+   */
+  audioTokens?: number | null | undefined;
+};
+
+/**
+ * Token usage from the agent execution
+ */
+export type Usage = {
+  /**
+   * Number of tokens in the generated completion.
+   */
+  completionTokens?: number | undefined;
+  /**
+   * Number of tokens in the prompt.
+   */
+  promptTokens?: number | undefined;
+  /**
+   * Total number of tokens used in the request (prompt + completion).
+   */
+  totalTokens?: number | undefined;
+  promptTokensDetails?: PromptTokensDetails | null | undefined;
+  completionTokensDetails?: CompletionTokensDetails | null | undefined;
+};
+
+/**
+ * Response type from the create-response endpoint.
+ */
+export type CreateAgentResponse = {
+  /**
+   * The unique response ID
+   */
+  id: string;
+  /**
+   * The agent execution task ID
+   */
+  taskId: string;
+  /**
+   * Array of messages from the agent execution
+   */
+  output: Array<AgentResponseMessage>;
+  /**
+   * ISO timestamp of response creation
+   */
+  createdAt: string;
+  /**
+   * Model used in provider/model format
+   */
+  model: string;
+  /**
+   * Token usage from the agent execution
+   */
+  usage?: Usage | null | undefined;
+};
+
+/** @internal */
+export const PromptTokensDetails$inboundSchema: z.ZodType<
+  PromptTokensDetails,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  cached_tokens: z.nullable(z.number().int()).optional(),
+  cache_creation_tokens: z.nullable(z.number().int()).optional(),
+  audio_tokens: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "cached_tokens": "cachedTokens",
+    "cache_creation_tokens": "cacheCreationTokens",
+    "audio_tokens": "audioTokens",
+  });
+});
+/** @internal */
+export type PromptTokensDetails$Outbound = {
+  cached_tokens?: number | null | undefined;
+  cache_creation_tokens?: number | null | undefined;
+  audio_tokens?: number | null | undefined;
+};
+
+/** @internal */
+export const PromptTokensDetails$outboundSchema: z.ZodType<
+  PromptTokensDetails$Outbound,
+  z.ZodTypeDef,
+  PromptTokensDetails
+> = z.object({
+  cachedTokens: z.nullable(z.number().int()).optional(),
+  cacheCreationTokens: z.nullable(z.number().int()).optional(),
+  audioTokens: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    cachedTokens: "cached_tokens",
+    cacheCreationTokens: "cache_creation_tokens",
+    audioTokens: "audio_tokens",
+  });
+});
+
+export function promptTokensDetailsToJSON(
+  promptTokensDetails: PromptTokensDetails,
+): string {
+  return JSON.stringify(
+    PromptTokensDetails$outboundSchema.parse(promptTokensDetails),
+  );
+}
+export function promptTokensDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<PromptTokensDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PromptTokensDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PromptTokensDetails' from JSON`,
+  );
+}
+
+/** @internal */
+export const CompletionTokensDetails$inboundSchema: z.ZodType<
+  CompletionTokensDetails,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  reasoning_tokens: z.nullable(z.number()).optional(),
+  accepted_prediction_tokens: z.nullable(z.number()).optional(),
+  rejected_prediction_tokens: z.nullable(z.number()).optional(),
+  audio_tokens: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "reasoning_tokens": "reasoningTokens",
+    "accepted_prediction_tokens": "acceptedPredictionTokens",
+    "rejected_prediction_tokens": "rejectedPredictionTokens",
+    "audio_tokens": "audioTokens",
+  });
+});
+/** @internal */
+export type CompletionTokensDetails$Outbound = {
+  reasoning_tokens?: number | null | undefined;
+  accepted_prediction_tokens?: number | null | undefined;
+  rejected_prediction_tokens?: number | null | undefined;
+  audio_tokens?: number | null | undefined;
+};
+
+/** @internal */
+export const CompletionTokensDetails$outboundSchema: z.ZodType<
+  CompletionTokensDetails$Outbound,
+  z.ZodTypeDef,
+  CompletionTokensDetails
+> = z.object({
+  reasoningTokens: z.nullable(z.number()).optional(),
+  acceptedPredictionTokens: z.nullable(z.number()).optional(),
+  rejectedPredictionTokens: z.nullable(z.number()).optional(),
+  audioTokens: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    reasoningTokens: "reasoning_tokens",
+    acceptedPredictionTokens: "accepted_prediction_tokens",
+    rejectedPredictionTokens: "rejected_prediction_tokens",
+    audioTokens: "audio_tokens",
+  });
+});
+
+export function completionTokensDetailsToJSON(
+  completionTokensDetails: CompletionTokensDetails,
+): string {
+  return JSON.stringify(
+    CompletionTokensDetails$outboundSchema.parse(completionTokensDetails),
+  );
+}
+export function completionTokensDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<CompletionTokensDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CompletionTokensDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CompletionTokensDetails' from JSON`,
+  );
+}
+
+/** @internal */
+export const Usage$inboundSchema: z.ZodType<Usage, z.ZodTypeDef, unknown> = z
+  .object({
+    completion_tokens: z.number().optional(),
+    prompt_tokens: z.number().optional(),
+    total_tokens: z.number().optional(),
+    prompt_tokens_details: z.nullable(
+      z.lazy(() => PromptTokensDetails$inboundSchema),
+    ).optional(),
+    completion_tokens_details: z.nullable(
+      z.lazy(() => CompletionTokensDetails$inboundSchema),
+    ).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "completion_tokens": "completionTokens",
+      "prompt_tokens": "promptTokens",
+      "total_tokens": "totalTokens",
+      "prompt_tokens_details": "promptTokensDetails",
+      "completion_tokens_details": "completionTokensDetails",
+    });
+  });
+/** @internal */
+export type Usage$Outbound = {
+  completion_tokens?: number | undefined;
+  prompt_tokens?: number | undefined;
+  total_tokens?: number | undefined;
+  prompt_tokens_details?: PromptTokensDetails$Outbound | null | undefined;
+  completion_tokens_details?:
+    | CompletionTokensDetails$Outbound
+    | null
+    | undefined;
+};
+
+/** @internal */
+export const Usage$outboundSchema: z.ZodType<
+  Usage$Outbound,
+  z.ZodTypeDef,
+  Usage
+> = z.object({
+  completionTokens: z.number().optional(),
+  promptTokens: z.number().optional(),
+  totalTokens: z.number().optional(),
+  promptTokensDetails: z.nullable(
+    z.lazy(() => PromptTokensDetails$outboundSchema),
+  ).optional(),
+  completionTokensDetails: z.nullable(
+    z.lazy(() => CompletionTokensDetails$outboundSchema),
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    completionTokens: "completion_tokens",
+    promptTokens: "prompt_tokens",
+    totalTokens: "total_tokens",
+    promptTokensDetails: "prompt_tokens_details",
+    completionTokensDetails: "completion_tokens_details",
+  });
+});
+
+export function usageToJSON(usage: Usage): string {
+  return JSON.stringify(Usage$outboundSchema.parse(usage));
+}
+export function usageFromJSON(
+  jsonString: string,
+): SafeParseResult<Usage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Usage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Usage' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateAgentResponse$inboundSchema: z.ZodType<
+  CreateAgentResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  task_id: z.string(),
+  output: z.array(AgentResponseMessage$inboundSchema),
+  created_at: z.string(),
+  model: z.string(),
+  usage: z.nullable(z.lazy(() => Usage$inboundSchema)).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "task_id": "taskId",
+    "created_at": "createdAt",
+  });
+});
+/** @internal */
+export type CreateAgentResponse$Outbound = {
+  _id: string;
+  task_id: string;
+  output: Array<AgentResponseMessage$Outbound>;
+  created_at: string;
+  model: string;
+  usage?: Usage$Outbound | null | undefined;
+};
+
+/** @internal */
+export const CreateAgentResponse$outboundSchema: z.ZodType<
+  CreateAgentResponse$Outbound,
+  z.ZodTypeDef,
+  CreateAgentResponse
+> = z.object({
+  id: z.string(),
+  taskId: z.string(),
+  output: z.array(AgentResponseMessage$outboundSchema),
+  createdAt: z.string(),
+  model: z.string(),
+  usage: z.nullable(z.lazy(() => Usage$outboundSchema)).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    id: "_id",
+    taskId: "task_id",
+    createdAt: "created_at",
+  });
+});
+
+export function createAgentResponseToJSON(
+  createAgentResponse: CreateAgentResponse,
+): string {
+  return JSON.stringify(
+    CreateAgentResponse$outboundSchema.parse(createAgentResponse),
+  );
+}
+export function createAgentResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateAgentResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateAgentResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateAgentResponse' from JSON`,
+  );
+}

package/src/models/components/imagecontentpartschema.ts

@@ -36,14 +36,14 @@ export type ImageUrl = {
 /**
  * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
  */
-export const ImageContentPartSchemaType = {
+export const ImageContentPartSchemaCacheControlType = {
   Ephemeral: "ephemeral",
 } as const;
 /**
  * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
  */
-export type ImageContentPartSchemaType = ClosedEnum<
-  typeof ImageContentPartSchemaType
+export type ImageContentPartSchemaCacheControlType = ClosedEnum<
+  typeof ImageContentPartSchemaCacheControlType
 >;
 
 /**
@@ -56,7 +56,7 @@ export type ImageContentPartSchemaType = ClosedEnum<
  *
  * Defaults to `5m`. Only supported by `Anthropic` Claude models.
  */
-export const Ttl = {
+export const ImageContentPartSchemaTtl = {
   Fivem: "5m",
   Oneh: "1h",
 } as const;
@@ -70,13 +70,15 @@ export const Ttl = {
  *
  * Defaults to `5m`. Only supported by `Anthropic` Claude models.
  */
-export type Ttl = ClosedEnum<typeof Ttl>;
+export type ImageContentPartSchemaTtl = ClosedEnum<
+  typeof ImageContentPartSchemaTtl
+>;
 
-export type CacheControl = {
+export type ImageContentPartSchemaCacheControl = {
   /**
    * Create a cache control breakpoint at this content block. Accepts only the value "ephemeral".
    */
-  type: ImageContentPartSchemaType;
+  type: ImageContentPartSchemaCacheControlType;
   /**
    * The time-to-live for the cache control breakpoint. This may be one of the following values:
    *
@@ -87,7 +89,7 @@ export type CacheControl = {
    *
    * Defaults to `5m`. Only supported by `Anthropic` Claude models.
    */
-  ttl?: Ttl | undefined;
+  ttl?: ImageContentPartSchemaTtl | undefined;
 };
 
 /**
@@ -96,7 +98,7 @@ export type CacheControl = {
 export type ImageContentPartSchema = {
   type: "image_url";
   imageUrl: ImageUrl;
-  cacheControl?: CacheControl | undefined;
+  cacheControl?: ImageContentPartSchemaCacheControl | undefined;
 };
 
 /** @internal */
@@ -145,55 +147,66 @@ export function imageUrlFromJSON(
 }
 
 /** @internal */
-export const ImageContentPartSchemaType$inboundSchema: z.ZodNativeEnum<
-  typeof ImageContentPartSchemaType
-> = z.nativeEnum(ImageContentPartSchemaType);
+export const ImageContentPartSchemaCacheControlType$inboundSchema:
+  z.ZodNativeEnum<typeof ImageContentPartSchemaCacheControlType> = z.nativeEnum(
+    ImageContentPartSchemaCacheControlType,
+  );
 /** @internal */
-export const ImageContentPartSchemaType$outboundSchema: z.ZodNativeEnum<
-  typeof ImageContentPartSchemaType
-> = ImageContentPartSchemaType$inboundSchema;
+export const ImageContentPartSchemaCacheControlType$outboundSchema:
+  z.ZodNativeEnum<typeof ImageContentPartSchemaCacheControlType> =
+    ImageContentPartSchemaCacheControlType$inboundSchema;
 
 /** @internal */
-export const Ttl$inboundSchema: z.ZodNativeEnum<typeof Ttl> = z.nativeEnum(Ttl);
+export const ImageContentPartSchemaTtl$inboundSchema: z.ZodNativeEnum<
+  typeof ImageContentPartSchemaTtl
+> = z.nativeEnum(ImageContentPartSchemaTtl);
 /** @internal */
-export const Ttl$outboundSchema: z.ZodNativeEnum<typeof Ttl> =
-  Ttl$inboundSchema;
+export const ImageContentPartSchemaTtl$outboundSchema: z.ZodNativeEnum<
+  typeof ImageContentPartSchemaTtl
+> = ImageContentPartSchemaTtl$inboundSchema;
 
 /** @internal */
-export const CacheControl$inboundSchema: z.ZodType<
-  CacheControl,
+export const ImageContentPartSchemaCacheControl$inboundSchema: z.ZodType<
+  ImageContentPartSchemaCacheControl,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: ImageContentPartSchemaType$inboundSchema,
-  ttl: Ttl$inboundSchema.default("5m"),
+  type: ImageContentPartSchemaCacheControlType$inboundSchema,
+  ttl: ImageContentPartSchemaTtl$inboundSchema.default("5m"),
 });
 /** @internal */
-export type CacheControl$Outbound = {
+export type ImageContentPartSchemaCacheControl$Outbound = {
   type: string;
   ttl: string;
 };
 
 /** @internal */
-export const CacheControl$outboundSchema: z.ZodType<
-  CacheControl$Outbound,
+export const ImageContentPartSchemaCacheControl$outboundSchema: z.ZodType<
+  ImageContentPartSchemaCacheControl$Outbound,
   z.ZodTypeDef,
-  CacheControl
+  ImageContentPartSchemaCacheControl
 > = z.object({
-  type: ImageContentPartSchemaType$outboundSchema,
-  ttl: Ttl$outboundSchema.default("5m"),
+  type: ImageContentPartSchemaCacheControlType$outboundSchema,
+  ttl: ImageContentPartSchemaTtl$outboundSchema.default("5m"),
 });
 
-export function cacheControlToJSON(cacheControl: CacheControl): string {
-  return JSON.stringify(CacheControl$outboundSchema.parse(cacheControl));
+export function imageContentPartSchemaCacheControlToJSON(
+  imageContentPartSchemaCacheControl: ImageContentPartSchemaCacheControl,
+): string {
+  return JSON.stringify(
+    ImageContentPartSchemaCacheControl$outboundSchema.parse(
+      imageContentPartSchemaCacheControl,
+    ),
+  );
 }
-export function cacheControlFromJSON(
+export function imageContentPartSchemaCacheControlFromJSON(
   jsonString: string,
-): SafeParseResult<CacheControl, SDKValidationError> {
+): SafeParseResult<ImageContentPartSchemaCacheControl, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => CacheControl$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CacheControl' from JSON`,
+    (x) =>
+      ImageContentPartSchemaCacheControl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ImageContentPartSchemaCacheControl' from JSON`,
   );
 }
 
@@ -205,7 +218,8 @@ export const ImageContentPartSchema$inboundSchema: z.ZodType<
 > = z.object({
   type: z.literal("image_url"),
   image_url: z.lazy(() => ImageUrl$inboundSchema),
-  cache_control: z.lazy(() => CacheControl$inboundSchema).optional(),
+  cache_control: z.lazy(() => ImageContentPartSchemaCacheControl$inboundSchema)
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     "image_url": "imageUrl",
@@ -216,7 +230,7 @@ export const ImageContentPartSchema$inboundSchema: z.ZodType<
 export type ImageContentPartSchema$Outbound = {
   type: "image_url";
   image_url: ImageUrl$Outbound;
-  cache_control?: CacheControl$Outbound | undefined;
+  cache_control?: ImageContentPartSchemaCacheControl$Outbound | undefined;
 };
 
 /** @internal */
@@ -227,7 +241,8 @@ export const ImageContentPartSchema$outboundSchema: z.ZodType<
 > = z.object({
   type: z.literal("image_url"),
   imageUrl: z.lazy(() => ImageUrl$outboundSchema),
-  cacheControl: z.lazy(() => CacheControl$outboundSchema).optional(),
+  cacheControl: z.lazy(() => ImageContentPartSchemaCacheControl$outboundSchema)
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     imageUrl: "image_url",