@orq-ai/node 4.0.0-rc.67 → 4.0.0-rc.68

package/src/models/operations/createagentresponse.ts

@@ -0,0 +1,1339 @@
+/*
+ * 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 { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Message containing tool execution results
+ */
+export const RoleToolMessage = {
+  Tool: "tool",
+} as const;
+/**
+ * Message containing tool execution results
+ */
+export type RoleToolMessage = ClosedEnum<typeof RoleToolMessage>;
+
+/**
+ * Message from the end user
+ */
+export const RoleUserMessage = {
+  User: "user",
+} as const;
+/**
+ * Message from the end user
+ */
+export type RoleUserMessage = ClosedEnum<typeof RoleUserMessage>;
+
+/**
+ * Message role (user or tool for continuing executions)
+ */
+export type CreateAgentResponseRole = RoleUserMessage | RoleToolMessage;
+
+export const CreateAgentResponsePublicMessagePartKind = {
+  ToolResult: "tool_result",
+} as const;
+export type CreateAgentResponsePublicMessagePartKind = ClosedEnum<
+  typeof CreateAgentResponsePublicMessagePartKind
+>;
+
+/**
+ * Tool execution result part. Use this ONLY when providing results for a pending tool call from the agent. The tool_call_id must match the ID from the agent's tool call request.
+ */
+export type ToolResultPart = {
+  kind: CreateAgentResponsePublicMessagePartKind;
+  toolCallId: string;
+  result?: any | undefined;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+export const PublicMessagePartKind = {
+  File: "file",
+} as const;
+export type PublicMessagePartKind = ClosedEnum<typeof PublicMessagePartKind>;
+
+/**
+ * File in URI format. Check in the model's documentation for the supported mime types for the URI format
+ */
+export type FileInURIFormat = {
+  /**
+   * URL for the File content
+   */
+  uri: string;
+  /**
+   * Optional mimeType for the file
+   */
+  mimeType?: string | undefined;
+  /**
+   * Optional name for the file
+   */
+  name?: string | undefined;
+};
+
+/**
+ * Binary in base64 format. Check in the model's documentation for the supported mime types for the binary format.
+ */
+export type BinaryFormat = {
+  /**
+   * base64 encoded content of the file
+   */
+  bytes: string;
+  /**
+   * Optional mimeType for the file
+   */
+  mimeType?: string | undefined;
+  /**
+   * Optional name for the file
+   */
+  name?: string | undefined;
+};
+
+export type PublicMessagePartFile = BinaryFormat | FileInURIFormat;
+
+/**
+ * File attachment part. Use this to send files (images, documents, etc.) to the agent for processing.
+ */
+export type FilePart = {
+  kind: PublicMessagePartKind;
+  file: BinaryFormat | FileInURIFormat;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+export const Kind = {
+  Text: "text",
+} as const;
+export type Kind = ClosedEnum<typeof Kind>;
+
+/**
+ * Text content part. Use this to send text messages to the agent.
+ */
+export type TextPart = {
+  kind: Kind;
+  text: string;
+};
+
+/**
+ * Message part that can be provided by users. Use "text" for regular messages, "file" for attachments, or "tool_result" when responding to tool call requests.
+ */
+export type PublicMessagePart = TextPart | FilePart | ToolResultPart;
+
+/**
+ * The A2A message to send to the agent (user input or tool results)
+ */
+export type A2AMessage = {
+  /**
+   * Optional A2A message ID in ULID format
+   */
+  messageId?: string | undefined;
+  /**
+   * Message role (user or tool for continuing executions)
+   */
+  role: RoleUserMessage | RoleToolMessage;
+  /**
+   * A2A message parts (text, file, or tool_result only)
+   */
+  parts: Array<TextPart | FilePart | ToolResultPart>;
+};
+
+/**
+ * Information about the contact making the request. If the contact does not exist, it will be created automatically.
+ */
+export type Contact = {
+  /**
+   * Unique identifier for the contact
+   */
+  id: string;
+  /**
+   * Display name of the contact
+   */
+  displayName?: string | undefined;
+  /**
+   * Email address of the contact
+   */
+  email?: string | undefined;
+  /**
+   * A hash of key/value pairs containing any other data about the contact
+   */
+  metadata?: Array<{ [k: string]: any }> | undefined;
+  /**
+   * URL to the contact's avatar or logo
+   */
+  logoUrl?: string | undefined;
+  /**
+   * A list of tags associated with the contact
+   */
+  tags?: Array<string> | undefined;
+};
+
+/**
+ * Thread information to group related requests
+ */
+export type CreateAgentResponseThread = {
+  /**
+   * Unique thread identifier to group related invocations.
+   */
+  id: string;
+  /**
+   * Optional tags to differentiate or categorize threads
+   */
+  tags?: Array<string> | undefined;
+};
+
+/**
+ * Memory configuration for the agent execution. Used to associate memory stores with specific entities like users or sessions.
+ */
+export type Memory = {
+  /**
+   * An entity ID used to link memory stores to a specific user, session, or conversation. This ID is used to isolate and retrieve memories specific to the entity across agent executions.
+   */
+  entityId: string;
+};
+
+export type CreateAgentResponseRequestBody = {
+  /**
+   * Optional task ID to continue an existing agent execution. When provided, the agent will continue the conversation from the existing task state. The task must be in an inactive state to continue.
+   */
+  taskId?: string | undefined;
+  /**
+   * The A2A message to send to the agent (user input or tool results)
+   */
+  message: A2AMessage;
+  /**
+   * Optional variables for template replacement in system prompt, instructions, and messages
+   */
+  variables?: { [k: string]: any } | undefined;
+  /**
+   * Information about the contact making the request. If the contact does not exist, it will be created automatically.
+   */
+  contact?: Contact | undefined;
+  /**
+   * Thread information to group related requests
+   */
+  thread?: CreateAgentResponseThread | undefined;
+  /**
+   * Memory configuration for the agent execution. Used to associate memory stores with specific entities like users or sessions.
+   */
+  memory?: Memory | undefined;
+  /**
+   * Optional metadata for the agent invocation as key-value pairs that will be included in traces
+   */
+  metadata?: { [k: string]: any } | undefined;
+  /**
+   * If true, returns immediately without waiting for completion. If false (default), waits until the agent becomes inactive or errors.
+   */
+  background?: boolean | undefined;
+};
+
+export type CreateAgentResponseRequest = {
+  /**
+   * The key or ID of the agent to invoke
+   */
+  agentKey: string;
+  requestBody?: CreateAgentResponseRequestBody | undefined;
+};
+
+export const CreateAgentResponseAgentsResponsesRole = {
+  User: "user",
+  Agent: "agent",
+  Tool: "tool",
+  System: "system",
+} as const;
+export type CreateAgentResponseAgentsResponsesRole = ClosedEnum<
+  typeof CreateAgentResponseAgentsResponsesRole
+>;
+
+export type Output = {
+  messageId: string;
+  role: CreateAgentResponseAgentsResponsesRole;
+  parts: Array<any>;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+export type PromptTokensDetails = {
+  cachedTokens?: 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 CreateAgentResponseUsage = {
+  /**
+   * 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;
+};
+
+/**
+ * Agent response created successfully
+ */
+export type CreateAgentResponseResponseBody = {
+  /**
+   * The unique response ID
+   */
+  id: string;
+  /**
+   * The agent execution task ID
+   */
+  taskId: string;
+  /**
+   * Array of messages from the agent execution
+   */
+  output: Array<Output>;
+  /**
+   * ISO timestamp of response creation
+   */
+  createdAt: string;
+  /**
+   * Model used in provider/model format
+   */
+  model: string;
+  /**
+   * Token usage from the agent execution
+   */
+  usage?: CreateAgentResponseUsage | null | undefined;
+};
+
+/** @internal */
+export const RoleToolMessage$inboundSchema: z.ZodNativeEnum<
+  typeof RoleToolMessage
+> = z.nativeEnum(RoleToolMessage);
+/** @internal */
+export const RoleToolMessage$outboundSchema: z.ZodNativeEnum<
+  typeof RoleToolMessage
+> = RoleToolMessage$inboundSchema;
+
+/** @internal */
+export const RoleUserMessage$inboundSchema: z.ZodNativeEnum<
+  typeof RoleUserMessage
+> = z.nativeEnum(RoleUserMessage);
+/** @internal */
+export const RoleUserMessage$outboundSchema: z.ZodNativeEnum<
+  typeof RoleUserMessage
+> = RoleUserMessage$inboundSchema;
+
+/** @internal */
+export const CreateAgentResponseRole$inboundSchema: z.ZodType<
+  CreateAgentResponseRole,
+  z.ZodTypeDef,
+  unknown
+> = z.union([RoleUserMessage$inboundSchema, RoleToolMessage$inboundSchema]);
+/** @internal */
+export type CreateAgentResponseRole$Outbound = string | string;
+
+/** @internal */
+export const CreateAgentResponseRole$outboundSchema: z.ZodType<
+  CreateAgentResponseRole$Outbound,
+  z.ZodTypeDef,
+  CreateAgentResponseRole
+> = z.union([RoleUserMessage$outboundSchema, RoleToolMessage$outboundSchema]);
+
+export function createAgentResponseRoleToJSON(
+  createAgentResponseRole: CreateAgentResponseRole,
+): string {
+  return JSON.stringify(
+    CreateAgentResponseRole$outboundSchema.parse(createAgentResponseRole),
+  );
+}
+export function createAgentResponseRoleFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateAgentResponseRole, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateAgentResponseRole$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateAgentResponseRole' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateAgentResponsePublicMessagePartKind$inboundSchema:
+  z.ZodNativeEnum<typeof CreateAgentResponsePublicMessagePartKind> = z
+    .nativeEnum(CreateAgentResponsePublicMessagePartKind);
+/** @internal */
+export const CreateAgentResponsePublicMessagePartKind$outboundSchema:
+  z.ZodNativeEnum<typeof CreateAgentResponsePublicMessagePartKind> =
+    CreateAgentResponsePublicMessagePartKind$inboundSchema;
+
+/** @internal */
+export const ToolResultPart$inboundSchema: z.ZodType<
+  ToolResultPart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: CreateAgentResponsePublicMessagePartKind$inboundSchema,
+  tool_call_id: z.string(),
+  result: z.any().optional(),
+  metadata: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_call_id": "toolCallId",
+  });
+});
+/** @internal */
+export type ToolResultPart$Outbound = {
+  kind: string;
+  tool_call_id: string;
+  result?: any | undefined;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ToolResultPart$outboundSchema: z.ZodType<
+  ToolResultPart$Outbound,
+  z.ZodTypeDef,
+  ToolResultPart
+> = z.object({
+  kind: CreateAgentResponsePublicMessagePartKind$outboundSchema,
+  toolCallId: z.string(),
+  result: z.any().optional(),
+  metadata: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    toolCallId: "tool_call_id",
+  });
+});
+
+export function toolResultPartToJSON(toolResultPart: ToolResultPart): string {
+  return JSON.stringify(ToolResultPart$outboundSchema.parse(toolResultPart));
+}
+export function toolResultPartFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolResultPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolResultPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolResultPart' from JSON`,
+  );
+}
+
+/** @internal */
+export const PublicMessagePartKind$inboundSchema: z.ZodNativeEnum<
+  typeof PublicMessagePartKind
+> = z.nativeEnum(PublicMessagePartKind);
+/** @internal */
+export const PublicMessagePartKind$outboundSchema: z.ZodNativeEnum<
+  typeof PublicMessagePartKind
+> = PublicMessagePartKind$inboundSchema;
+
+/** @internal */
+export const FileInURIFormat$inboundSchema: z.ZodType<
+  FileInURIFormat,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  uri: z.string(),
+  mimeType: z.string().optional(),
+  name: z.string().optional(),
+});
+/** @internal */
+export type FileInURIFormat$Outbound = {
+  uri: string;
+  mimeType?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const FileInURIFormat$outboundSchema: z.ZodType<
+  FileInURIFormat$Outbound,
+  z.ZodTypeDef,
+  FileInURIFormat
+> = z.object({
+  uri: z.string(),
+  mimeType: z.string().optional(),
+  name: z.string().optional(),
+});
+
+export function fileInURIFormatToJSON(
+  fileInURIFormat: FileInURIFormat,
+): string {
+  return JSON.stringify(FileInURIFormat$outboundSchema.parse(fileInURIFormat));
+}
+export function fileInURIFormatFromJSON(
+  jsonString: string,
+): SafeParseResult<FileInURIFormat, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FileInURIFormat$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileInURIFormat' from JSON`,
+  );
+}
+
+/** @internal */
+export const BinaryFormat$inboundSchema: z.ZodType<
+  BinaryFormat,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  bytes: z.string(),
+  mimeType: z.string().optional(),
+  name: z.string().optional(),
+});
+/** @internal */
+export type BinaryFormat$Outbound = {
+  bytes: string;
+  mimeType?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const BinaryFormat$outboundSchema: z.ZodType<
+  BinaryFormat$Outbound,
+  z.ZodTypeDef,
+  BinaryFormat
+> = z.object({
+  bytes: z.string(),
+  mimeType: z.string().optional(),
+  name: z.string().optional(),
+});
+
+export function binaryFormatToJSON(binaryFormat: BinaryFormat): string {
+  return JSON.stringify(BinaryFormat$outboundSchema.parse(binaryFormat));
+}
+export function binaryFormatFromJSON(
+  jsonString: string,
+): SafeParseResult<BinaryFormat, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BinaryFormat$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BinaryFormat' from JSON`,
+  );
+}
+
+/** @internal */
+export const PublicMessagePartFile$inboundSchema: z.ZodType<
+  PublicMessagePartFile,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => BinaryFormat$inboundSchema),
+  z.lazy(() => FileInURIFormat$inboundSchema),
+]);
+/** @internal */
+export type PublicMessagePartFile$Outbound =
+  | BinaryFormat$Outbound
+  | FileInURIFormat$Outbound;
+
+/** @internal */
+export const PublicMessagePartFile$outboundSchema: z.ZodType<
+  PublicMessagePartFile$Outbound,
+  z.ZodTypeDef,
+  PublicMessagePartFile
+> = z.union([
+  z.lazy(() => BinaryFormat$outboundSchema),
+  z.lazy(() => FileInURIFormat$outboundSchema),
+]);
+
+export function publicMessagePartFileToJSON(
+  publicMessagePartFile: PublicMessagePartFile,
+): string {
+  return JSON.stringify(
+    PublicMessagePartFile$outboundSchema.parse(publicMessagePartFile),
+  );
+}
+export function publicMessagePartFileFromJSON(
+  jsonString: string,
+): SafeParseResult<PublicMessagePartFile, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PublicMessagePartFile$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PublicMessagePartFile' from JSON`,
+  );
+}
+
+/** @internal */
+export const FilePart$inboundSchema: z.ZodType<
+  FilePart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: PublicMessagePartKind$inboundSchema,
+  file: z.union([
+    z.lazy(() => BinaryFormat$inboundSchema),
+    z.lazy(() => FileInURIFormat$inboundSchema),
+  ]),
+  metadata: z.record(z.any()).optional(),
+});
+/** @internal */
+export type FilePart$Outbound = {
+  kind: string;
+  file: BinaryFormat$Outbound | FileInURIFormat$Outbound;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const FilePart$outboundSchema: z.ZodType<
+  FilePart$Outbound,
+  z.ZodTypeDef,
+  FilePart
+> = z.object({
+  kind: PublicMessagePartKind$outboundSchema,
+  file: z.union([
+    z.lazy(() => BinaryFormat$outboundSchema),
+    z.lazy(() => FileInURIFormat$outboundSchema),
+  ]),
+  metadata: z.record(z.any()).optional(),
+});
+
+export function filePartToJSON(filePart: FilePart): string {
+  return JSON.stringify(FilePart$outboundSchema.parse(filePart));
+}
+export function filePartFromJSON(
+  jsonString: string,
+): SafeParseResult<FilePart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilePart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilePart' from JSON`,
+  );
+}
+
+/** @internal */
+export const Kind$inboundSchema: z.ZodNativeEnum<typeof Kind> = z.nativeEnum(
+  Kind,
+);
+/** @internal */
+export const Kind$outboundSchema: z.ZodNativeEnum<typeof Kind> =
+  Kind$inboundSchema;
+
+/** @internal */
+export const TextPart$inboundSchema: z.ZodType<
+  TextPart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: Kind$inboundSchema,
+  text: z.string(),
+});
+/** @internal */
+export type TextPart$Outbound = {
+  kind: string;
+  text: string;
+};
+
+/** @internal */
+export const TextPart$outboundSchema: z.ZodType<
+  TextPart$Outbound,
+  z.ZodTypeDef,
+  TextPart
+> = z.object({
+  kind: Kind$outboundSchema,
+  text: z.string(),
+});
+
+export function textPartToJSON(textPart: TextPart): string {
+  return JSON.stringify(TextPart$outboundSchema.parse(textPart));
+}
+export function textPartFromJSON(
+  jsonString: string,
+): SafeParseResult<TextPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TextPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TextPart' from JSON`,
+  );
+}
+
+/** @internal */
+export const PublicMessagePart$inboundSchema: z.ZodType<
+  PublicMessagePart,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => TextPart$inboundSchema),
+  z.lazy(() => FilePart$inboundSchema),
+  z.lazy(() => ToolResultPart$inboundSchema),
+]);
+/** @internal */
+export type PublicMessagePart$Outbound =
+  | TextPart$Outbound
+  | FilePart$Outbound
+  | ToolResultPart$Outbound;
+
+/** @internal */
+export const PublicMessagePart$outboundSchema: z.ZodType<
+  PublicMessagePart$Outbound,
+  z.ZodTypeDef,
+  PublicMessagePart
+> = z.union([
+  z.lazy(() => TextPart$outboundSchema),
+  z.lazy(() => FilePart$outboundSchema),
+  z.lazy(() => ToolResultPart$outboundSchema),
+]);
+
+export function publicMessagePartToJSON(
+  publicMessagePart: PublicMessagePart,
+): string {
+  return JSON.stringify(
+    PublicMessagePart$outboundSchema.parse(publicMessagePart),
+  );
+}
+export function publicMessagePartFromJSON(
+  jsonString: string,
+): SafeParseResult<PublicMessagePart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PublicMessagePart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PublicMessagePart' from JSON`,
+  );
+}
+
+/** @internal */
+export const A2AMessage$inboundSchema: z.ZodType<
+  A2AMessage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  messageId: z.string().optional(),
+  role: z.union([RoleUserMessage$inboundSchema, RoleToolMessage$inboundSchema]),
+  parts: z.array(
+    z.union([
+      z.lazy(() => TextPart$inboundSchema),
+      z.lazy(() => FilePart$inboundSchema),
+      z.lazy(() => ToolResultPart$inboundSchema),
+    ]),
+  ),
+});
+/** @internal */
+export type A2AMessage$Outbound = {
+  messageId?: string | undefined;
+  role: string | string;
+  parts: Array<TextPart$Outbound | FilePart$Outbound | ToolResultPart$Outbound>;
+};
+
+/** @internal */
+export const A2AMessage$outboundSchema: z.ZodType<
+  A2AMessage$Outbound,
+  z.ZodTypeDef,
+  A2AMessage
+> = z.object({
+  messageId: z.string().optional(),
+  role: z.union([
+    RoleUserMessage$outboundSchema,
+    RoleToolMessage$outboundSchema,
+  ]),
+  parts: z.array(
+    z.union([
+      z.lazy(() => TextPart$outboundSchema),
+      z.lazy(() => FilePart$outboundSchema),
+      z.lazy(() => ToolResultPart$outboundSchema),
+    ]),
+  ),
+});
+
+export function a2AMessageToJSON(a2AMessage: A2AMessage): string {
+  return JSON.stringify(A2AMessage$outboundSchema.parse(a2AMessage));
+}
+export function a2AMessageFromJSON(
+  jsonString: string,
+): SafeParseResult<A2AMessage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => A2AMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'A2AMessage' from JSON`,
+  );
+}
+
+/** @internal */
+export const Contact$inboundSchema: z.ZodType<Contact, z.ZodTypeDef, unknown> =
+  z.object({
+    id: z.string(),
+    display_name: z.string().optional(),
+    email: z.string().optional(),
+    metadata: z.array(z.record(z.any())).optional(),
+    logo_url: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "display_name": "displayName",
+      "logo_url": "logoUrl",
+    });
+  });
+/** @internal */
+export type Contact$Outbound = {
+  id: string;
+  display_name?: string | undefined;
+  email?: string | undefined;
+  metadata?: Array<{ [k: string]: any }> | undefined;
+  logo_url?: string | undefined;
+  tags?: Array<string> | undefined;
+};
+
+/** @internal */
+export const Contact$outboundSchema: z.ZodType<
+  Contact$Outbound,
+  z.ZodTypeDef,
+  Contact
+> = z.object({
+  id: z.string(),
+  displayName: z.string().optional(),
+  email: z.string().optional(),
+  metadata: z.array(z.record(z.any())).optional(),
+  logoUrl: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    displayName: "display_name",
+    logoUrl: "logo_url",
+  });
+});
+
+export function contactToJSON(contact: Contact): string {
+  return JSON.stringify(Contact$outboundSchema.parse(contact));
+}
+export function contactFromJSON(
+  jsonString: string,
+): SafeParseResult<Contact, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Contact$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Contact' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateAgentResponseThread$inboundSchema: z.ZodType<
+  CreateAgentResponseThread,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  tags: z.array(z.string()).optional(),
+});
+/** @internal */
+export type CreateAgentResponseThread$Outbound = {
+  id: string;
+  tags?: Array<string> | undefined;
+};
+
+/** @internal */
+export const CreateAgentResponseThread$outboundSchema: z.ZodType<
+  CreateAgentResponseThread$Outbound,
+  z.ZodTypeDef,
+  CreateAgentResponseThread
+> = z.object({
+  id: z.string(),
+  tags: z.array(z.string()).optional(),
+});
+
+export function createAgentResponseThreadToJSON(
+  createAgentResponseThread: CreateAgentResponseThread,
+): string {
+  return JSON.stringify(
+    CreateAgentResponseThread$outboundSchema.parse(createAgentResponseThread),
+  );
+}
+export function createAgentResponseThreadFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateAgentResponseThread, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateAgentResponseThread$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateAgentResponseThread' from JSON`,
+  );
+}
+
+/** @internal */
+export const Memory$inboundSchema: z.ZodType<Memory, z.ZodTypeDef, unknown> = z
+  .object({
+    entity_id: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      "entity_id": "entityId",
+    });
+  });
+/** @internal */
+export type Memory$Outbound = {
+  entity_id: string;
+};
+
+/** @internal */
+export const Memory$outboundSchema: z.ZodType<
+  Memory$Outbound,
+  z.ZodTypeDef,
+  Memory
+> = z.object({
+  entityId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    entityId: "entity_id",
+  });
+});
+
+export function memoryToJSON(memory: Memory): string {
+  return JSON.stringify(Memory$outboundSchema.parse(memory));
+}
+export function memoryFromJSON(
+  jsonString: string,
+): SafeParseResult<Memory, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Memory$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Memory' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateAgentResponseRequestBody$inboundSchema: z.ZodType<
+  CreateAgentResponseRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  task_id: z.string().optional(),
+  message: z.lazy(() => A2AMessage$inboundSchema),
+  variables: z.record(z.any()).optional(),
+  contact: z.lazy(() => Contact$inboundSchema).optional(),
+  thread: z.lazy(() => CreateAgentResponseThread$inboundSchema).optional(),
+  memory: z.lazy(() => Memory$inboundSchema).optional(),
+  metadata: z.record(z.any()).optional(),
+  background: z.boolean().default(false),
+}).transform((v) => {
+  return remap$(v, {
+    "task_id": "taskId",
+  });
+});
+/** @internal */
+export type CreateAgentResponseRequestBody$Outbound = {
+  task_id?: string | undefined;
+  message: A2AMessage$Outbound;
+  variables?: { [k: string]: any } | undefined;
+  contact?: Contact$Outbound | undefined;
+  thread?: CreateAgentResponseThread$Outbound | undefined;
+  memory?: Memory$Outbound | undefined;
+  metadata?: { [k: string]: any } | undefined;
+  background: boolean;
+};
+
+/** @internal */
+export const CreateAgentResponseRequestBody$outboundSchema: z.ZodType<
+  CreateAgentResponseRequestBody$Outbound,
+  z.ZodTypeDef,
+  CreateAgentResponseRequestBody
+> = z.object({
+  taskId: z.string().optional(),
+  message: z.lazy(() => A2AMessage$outboundSchema),
+  variables: z.record(z.any()).optional(),
+  contact: z.lazy(() => Contact$outboundSchema).optional(),
+  thread: z.lazy(() => CreateAgentResponseThread$outboundSchema).optional(),
+  memory: z.lazy(() => Memory$outboundSchema).optional(),
+  metadata: z.record(z.any()).optional(),
+  background: z.boolean().default(false),
+}).transform((v) => {
+  return remap$(v, {
+    taskId: "task_id",
+  });
+});
+
+export function createAgentResponseRequestBodyToJSON(
+  createAgentResponseRequestBody: CreateAgentResponseRequestBody,
+): string {
+  return JSON.stringify(
+    CreateAgentResponseRequestBody$outboundSchema.parse(
+      createAgentResponseRequestBody,
+    ),
+  );
+}
+export function createAgentResponseRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateAgentResponseRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateAgentResponseRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateAgentResponseRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateAgentResponseRequest$inboundSchema: z.ZodType<
+  CreateAgentResponseRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  agent_key: z.string(),
+  RequestBody: z.lazy(() => CreateAgentResponseRequestBody$inboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "agent_key": "agentKey",
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type CreateAgentResponseRequest$Outbound = {
+  agent_key: string;
+  RequestBody?: CreateAgentResponseRequestBody$Outbound | undefined;
+};
+
+/** @internal */
+export const CreateAgentResponseRequest$outboundSchema: z.ZodType<
+  CreateAgentResponseRequest$Outbound,
+  z.ZodTypeDef,
+  CreateAgentResponseRequest
+> = z.object({
+  agentKey: z.string(),
+  requestBody: z.lazy(() => CreateAgentResponseRequestBody$outboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    agentKey: "agent_key",
+    requestBody: "RequestBody",
+  });
+});
+
+export function createAgentResponseRequestToJSON(
+  createAgentResponseRequest: CreateAgentResponseRequest,
+): string {
+  return JSON.stringify(
+    CreateAgentResponseRequest$outboundSchema.parse(createAgentResponseRequest),
+  );
+}
+export function createAgentResponseRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateAgentResponseRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateAgentResponseRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateAgentResponseRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateAgentResponseAgentsResponsesRole$inboundSchema:
+  z.ZodNativeEnum<typeof CreateAgentResponseAgentsResponsesRole> = z.nativeEnum(
+    CreateAgentResponseAgentsResponsesRole,
+  );
+/** @internal */
+export const CreateAgentResponseAgentsResponsesRole$outboundSchema:
+  z.ZodNativeEnum<typeof CreateAgentResponseAgentsResponsesRole> =
+    CreateAgentResponseAgentsResponsesRole$inboundSchema;
+
+/** @internal */
+export const Output$inboundSchema: z.ZodType<Output, z.ZodTypeDef, unknown> = z
+  .object({
+    messageId: z.string(),
+    role: CreateAgentResponseAgentsResponsesRole$inboundSchema,
+    parts: z.array(z.any()),
+    metadata: z.record(z.any()).optional(),
+  });
+/** @internal */
+export type Output$Outbound = {
+  messageId: string;
+  role: string;
+  parts: Array<any>;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const Output$outboundSchema: z.ZodType<
+  Output$Outbound,
+  z.ZodTypeDef,
+  Output
+> = z.object({
+  messageId: z.string(),
+  role: CreateAgentResponseAgentsResponsesRole$outboundSchema,
+  parts: z.array(z.any()),
+  metadata: z.record(z.any()).optional(),
+});
+
+export function outputToJSON(output: Output): string {
+  return JSON.stringify(Output$outboundSchema.parse(output));
+}
+export function outputFromJSON(
+  jsonString: string,
+): SafeParseResult<Output, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Output$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Output' from JSON`,
+  );
+}
+
+/** @internal */
+export const PromptTokensDetails$inboundSchema: z.ZodType<
+  PromptTokensDetails,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  cached_tokens: z.nullable(z.number().int()).optional(),
+  audio_tokens: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "cached_tokens": "cachedTokens",
+    "audio_tokens": "audioTokens",
+  });
+});
+/** @internal */
+export type PromptTokensDetails$Outbound = {
+  cached_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(),
+  audioTokens: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    cachedTokens: "cached_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 CreateAgentResponseUsage$inboundSchema: z.ZodType<
+  CreateAgentResponseUsage,
+  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 CreateAgentResponseUsage$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 CreateAgentResponseUsage$outboundSchema: z.ZodType<
+  CreateAgentResponseUsage$Outbound,
+  z.ZodTypeDef,
+  CreateAgentResponseUsage
+> = 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 createAgentResponseUsageToJSON(
+  createAgentResponseUsage: CreateAgentResponseUsage,
+): string {
+  return JSON.stringify(
+    CreateAgentResponseUsage$outboundSchema.parse(createAgentResponseUsage),
+  );
+}
+export function createAgentResponseUsageFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateAgentResponseUsage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateAgentResponseUsage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateAgentResponseUsage' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateAgentResponseResponseBody$inboundSchema: z.ZodType<
+  CreateAgentResponseResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  task_id: z.string(),
+  output: z.array(z.lazy(() => Output$inboundSchema)),
+  created_at: z.string(),
+  model: z.string(),
+  usage: z.nullable(z.lazy(() => CreateAgentResponseUsage$inboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "task_id": "taskId",
+    "created_at": "createdAt",
+  });
+});
+/** @internal */
+export type CreateAgentResponseResponseBody$Outbound = {
+  _id: string;
+  task_id: string;
+  output: Array<Output$Outbound>;
+  created_at: string;
+  model: string;
+  usage?: CreateAgentResponseUsage$Outbound | null | undefined;
+};
+
+/** @internal */
+export const CreateAgentResponseResponseBody$outboundSchema: z.ZodType<
+  CreateAgentResponseResponseBody$Outbound,
+  z.ZodTypeDef,
+  CreateAgentResponseResponseBody
+> = z.object({
+  id: z.string(),
+  taskId: z.string(),
+  output: z.array(z.lazy(() => Output$outboundSchema)),
+  createdAt: z.string(),
+  model: z.string(),
+  usage: z.nullable(z.lazy(() => CreateAgentResponseUsage$outboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    id: "_id",
+    taskId: "task_id",
+    createdAt: "created_at",
+  });
+});
+
+export function createAgentResponseResponseBodyToJSON(
+  createAgentResponseResponseBody: CreateAgentResponseResponseBody,
+): string {
+  return JSON.stringify(
+    CreateAgentResponseResponseBody$outboundSchema.parse(
+      createAgentResponseResponseBody,
+    ),
+  );
+}
+export function createAgentResponseResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateAgentResponseResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateAgentResponseResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateAgentResponseResponseBody' from JSON`,
+  );
+}