@orq-ai/node 4.0.0-rc.51 → 4.0.0-rc.53

package/src/models/operations/listagenttasks.ts

@@ -9,10 +9,44 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+export type ListAgentTasksRequest = {
+  /**
+   * The unique key of the agent
+   */
+  agentKey: string;
+  /**
+   * A limit on the number of objects to be returned. Limit can range between 1 and 50, and the default is 10
+   */
+  limit?: number | undefined;
+  /**
+   * A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 20 objects, ending with `01JJ1HDHN79XAS7A01WB3HYSDB`, your subsequent call can include `after=01JJ1HDHN79XAS7A01WB3HYSDB` in order to fetch the next page of the list.
+   */
+  startingAfter?: string | undefined;
+  /**
+   * A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 20 objects, starting with `01JJ1HDHN79XAS7A01WB3HYSDB`, your subsequent call can include `before=01JJ1HDHN79XAS7A01WB3HYSDB` in order to fetch the previous page of the list.
+   */
+  endingBefore?: string | undefined;
+  /**
+   * Comma-separated list of task statuses to filter by. Available values: submitted, working, input-required, auth-required, completed, failed, canceled, rejected
+   */
+  status?: string | undefined;
+};
+
+/**
+ * A2A entity type
+ */
+export const ListAgentTasksKind = {
+  Task: "task",
+} as const;
+/**
+ * A2A entity type
+ */
+export type ListAgentTasksKind = ClosedEnum<typeof ListAgentTasksKind>;
+
 /**
- * Comma-separated list of task statuses to filter by. Available values: inactive, approval_required, in_progress, errored
+ * Current state of the agent task execution. Values: submitted (queued), working (executing), input-required (awaiting user input), completed (finished successfully), failed (error occurred). Note: auth-required, canceled, and rejected statuses are defined for A2A protocol compatibility but are not currently supported in task execution.
  */
-export const Status = {
+export const ListAgentTasksTaskState = {
   Submitted: "submitted",
   Working: "working",
   InputRequired: "input-required",
@@ -23,42 +57,216 @@ export const Status = {
   Rejected: "rejected",
 } as const;
 /**
- * Comma-separated list of task statuses to filter by. Available values: inactive, approval_required, in_progress, errored
+ * Current state of the agent task execution. Values: submitted (queued), working (executing), input-required (awaiting user input), completed (finished successfully), failed (error occurred). Note: auth-required, canceled, and rejected statuses are defined for A2A protocol compatibility but are not currently supported in task execution.
+ */
+export type ListAgentTasksTaskState = ClosedEnum<
+  typeof ListAgentTasksTaskState
+>;
+
+export const ListAgentTasksAgentsResponseKind = {
+  Message: "message",
+} as const;
+export type ListAgentTasksAgentsResponseKind = ClosedEnum<
+  typeof ListAgentTasksAgentsResponseKind
+>;
+
+/**
+ * Role of the message sender in the A2A protocol. Values: user (end user), agent (AI agent), tool (tool execution result), system (system instructions/prompts).
+ */
+export const ListAgentTasksAgentsExtendedMessageRole = {
+  User: "user",
+  Agent: "agent",
+  Tool: "tool",
+  System: "system",
+} as const;
+/**
+ * Role of the message sender in the A2A protocol. Values: user (end user), agent (AI agent), tool (tool execution result), system (system instructions/prompts).
  */
-export type Status = ClosedEnum<typeof Status>;
+export type ListAgentTasksAgentsExtendedMessageRole = ClosedEnum<
+  typeof ListAgentTasksAgentsExtendedMessageRole
+>;
 
-export type ListAgentTasksRequest = {
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage5Kind =
+  {
+    ToolResult: "tool_result",
+  } as const;
+export type ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage5Kind =
+  ClosedEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage5Kind
+  >;
+
+/**
+ * The result of a tool execution. Contains the tool call ID for correlation and the result data from the tool invocation.
+ */
+export type ListAgentTasksPartsAgentsToolResultPart = {
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage5Kind;
+  toolCallId: string;
+  result?: any | undefined;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessageKind =
+  {
+    ToolCall: "tool_call",
+  } as const;
+export type ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessageKind =
+  ClosedEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessageKind
+  >;
+
+/**
+ * A tool invocation request from an agent. Contains the tool name, unique call ID, and arguments for the tool execution.
+ */
+export type ListAgentTasksPartsToolCallPart = {
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessageKind;
+  toolName: string;
+  toolCallId: string;
+  arguments: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusKind =
+  {
+    File: "file",
+  } as const;
+export type ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusKind =
+  ClosedEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusKind
+  >;
+
+/**
+ * File in URI format. Check in the model's documentation for the supported mime types for the URI format
+ */
+export type ListAgentTasksFileAgentsResponseFileInURIFormat = {
   /**
-   * The unique key of the agent
+   * URL for the File content
    */
-  agentKey: string;
+  uri: string;
   /**
-   * A limit on the number of objects to be returned. Limit can range between 1 and 50, and the default is 10
+   * Optional mimeType for the file
    */
-  limit?: number | undefined;
+  mimeType?: string | undefined;
   /**
-   * A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 20 objects, ending with `01JJ1HDHN79XAS7A01WB3HYSDB`, your subsequent call can include `after=01JJ1HDHN79XAS7A01WB3HYSDB` in order to fetch the next page of the list.
+   * Optional name for the file
    */
-  startingAfter?: string | undefined;
+  name?: string | undefined;
+};
+
+/**
+ * Binary in base64 format. Check in the model's documentation for the supported mime types for the binary format.
+ */
+export type ListAgentTasksFileAgentsResponseBinaryFormat = {
   /**
-   * A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 20 objects, starting with `01JJ1HDHN79XAS7A01WB3HYSDB`, your subsequent call can include `before=01JJ1HDHN79XAS7A01WB3HYSDB` in order to fetch the previous page of the list.
+   * base64 encoded content of the file
    */
-  endingBefore?: string | undefined;
+  bytes: string;
   /**
-   * Comma-separated list of task statuses to filter by. Available values: inactive, approval_required, in_progress, errored
+   * Optional mimeType for the file
+   */
+  mimeType?: string | undefined;
+  /**
+   * Optional name for the file
    */
-  status?: Status | undefined;
+  name?: string | undefined;
 };
 
-export const ListAgentTasksKind = {
-  Task: "task",
-} as const;
-export type ListAgentTasksKind = ClosedEnum<typeof ListAgentTasksKind>;
+export type ListAgentTasksPartsAgentsResponseFile =
+  | ListAgentTasksFileAgentsResponseBinaryFormat
+  | ListAgentTasksFileAgentsResponseFileInURIFormat;
 
-export type ListAgentTasksStatus = {
-  state: string;
+/**
+ * A file content part that can contain either base64-encoded bytes or a URI reference. Used for images, documents, and other binary content in agent communications.
+ */
+export type ListAgentTasksPartsAgentsResponseFilePart = {
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusKind;
+  file:
+    | ListAgentTasksFileAgentsResponseBinaryFormat
+    | ListAgentTasksFileAgentsResponseFileInURIFormat;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage2Kind =
+  {
+    Data: "data",
+  } as const;
+export type ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage2Kind =
+  ClosedEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage2Kind
+  >;
+
+/**
+ * A structured data part containing JSON-serializable key-value pairs. Used for passing structured information between agents and tools.
+ */
+export type ListAgentTasksPartsAgentsResponseDataPart = {
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage2Kind;
+  data: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage1Kind =
+  {
+    Text: "text",
+  } as const;
+export type ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage1Kind =
+  ClosedEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage1Kind
+  >;
+
+/**
+ * A text content part containing plain text or markdown. Used for agent messages, user input, and text-based responses.
+ */
+export type ListAgentTasksPartsAgentsResponseTextPart = {
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage1Kind;
+  text: string;
+};
+
+export type ListAgentTasksAgentsResponseParts =
+  | ListAgentTasksPartsToolCallPart
+  | ListAgentTasksPartsAgentsResponseTextPart
+  | ListAgentTasksPartsAgentsResponseDataPart
+  | ListAgentTasksPartsAgentsResponseFilePart
+  | ListAgentTasksPartsAgentsToolResultPart;
+
+/**
+ * Optional A2A message providing additional context about the current status
+ */
+export type ListAgentTasksTaskStatusMessage = {
+  kind: ListAgentTasksAgentsResponseKind;
+  messageId: string;
+  /**
+   * Role of the message sender in the A2A protocol. Values: user (end user), agent (AI agent), tool (tool execution result), system (system instructions/prompts).
+   */
+  role: ListAgentTasksAgentsExtendedMessageRole;
+  parts: Array<
+    | ListAgentTasksPartsToolCallPart
+    | ListAgentTasksPartsAgentsResponseTextPart
+    | ListAgentTasksPartsAgentsResponseDataPart
+    | ListAgentTasksPartsAgentsResponseFilePart
+    | ListAgentTasksPartsAgentsToolResultPart
+  >;
+};
+
+/**
+ * Current task execution status
+ */
+export type ListAgentTasksTaskStatus = {
+  /**
+   * Current state of the agent task execution. Values: submitted (queued), working (executing), input-required (awaiting user input), completed (finished successfully), failed (error occurred). Note: auth-required, canceled, and rejected statuses are defined for A2A protocol compatibility but are not currently supported in task execution.
+   */
+  state: ListAgentTasksTaskState;
+  /**
+   * ISO 8601 timestamp of when the status was updated
+   */
   timestamp?: string | undefined;
-  message?: any | undefined;
+  /**
+   * Optional A2A message providing additional context about the current status
+   */
+  message?: ListAgentTasksTaskStatusMessage | undefined;
 };
 
 export const ListAgentTasksAgentsKind = {
@@ -69,18 +277,20 @@ export type ListAgentTasksAgentsKind = ClosedEnum<
 >;
 
 /**
- * Extended A2A message role
+ * Role of the message sender in the A2A protocol. Values: user (end user), agent (AI agent), tool (tool execution result), system (system instructions/prompts).
  */
-export const ListAgentTasksRole = {
+export const ListAgentTasksExtendedMessageRole = {
   User: "user",
   Agent: "agent",
   Tool: "tool",
   System: "system",
 } as const;
 /**
- * Extended A2A message role
+ * Role of the message sender in the A2A protocol. Values: user (end user), agent (AI agent), tool (tool execution result), system (system instructions/prompts).
  */
-export type ListAgentTasksRole = ClosedEnum<typeof ListAgentTasksRole>;
+export type ListAgentTasksExtendedMessageRole = ClosedEnum<
+  typeof ListAgentTasksExtendedMessageRole
+>;
 
 export const ListAgentTasksPartsAgentsResponse200ApplicationJSONKind = {
   ToolResult: "tool_result",
@@ -88,7 +298,10 @@ export const ListAgentTasksPartsAgentsResponse200ApplicationJSONKind = {
 export type ListAgentTasksPartsAgentsResponse200ApplicationJSONKind =
   ClosedEnum<typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONKind>;
 
-export type ListAgentTasksParts5 = {
+/**
+ * The result of a tool execution. Contains the tool call ID for correlation and the result data from the tool invocation.
+ */
+export type ListAgentTasksPartsToolResultPart = {
   kind: ListAgentTasksPartsAgentsResponse200ApplicationJSONKind;
   toolCallId: string;
   result?: any | undefined;
@@ -102,7 +315,10 @@ export type ListAgentTasksPartsAgentsResponse200Kind = ClosedEnum<
   typeof ListAgentTasksPartsAgentsResponse200Kind
 >;
 
-export type ListAgentTasksParts4 = {
+/**
+ * A tool invocation request from an agent. Contains the tool name, unique call ID, and arguments for the tool execution.
+ */
+export type PartsToolCallPart = {
   kind: ListAgentTasksPartsAgentsResponse200Kind;
   toolName: string;
   toolCallId: string;
@@ -157,7 +373,10 @@ export type ListAgentTasksPartsFile =
   | ListAgentTasksFileBinaryFormat
   | ListAgentTasksFileFileInURIFormat;
 
-export type ListAgentTasksParts3 = {
+/**
+ * A file content part that can contain either base64-encoded bytes or a URI reference. Used for images, documents, and other binary content in agent communications.
+ */
+export type ListAgentTasksPartsFilePart = {
   kind: ListAgentTasksPartsAgentsResponseKind;
   file: ListAgentTasksFileBinaryFormat | ListAgentTasksFileFileInURIFormat;
   metadata?: { [k: string]: any } | undefined;
@@ -170,7 +389,10 @@ export type ListAgentTasksPartsAgentsKind = ClosedEnum<
   typeof ListAgentTasksPartsAgentsKind
 >;
 
-export type ListAgentTasksParts2 = {
+/**
+ * A structured data part containing JSON-serializable key-value pairs. Used for passing structured information between agents and tools.
+ */
+export type ListAgentTasksPartsAgentsDataPart = {
   kind: ListAgentTasksPartsAgentsKind;
   data: { [k: string]: any };
   metadata?: { [k: string]: any } | undefined;
@@ -183,116 +405,280 @@ export type ListAgentTasksPartsKind = ClosedEnum<
   typeof ListAgentTasksPartsKind
 >;
 
-export type ListAgentTasksParts1 = {
+/**
+ * A text content part containing plain text or markdown. Used for agent messages, user input, and text-based responses.
+ */
+export type ListAgentTasksPartsTextPart = {
   kind: ListAgentTasksPartsKind;
   text: string;
 };
 
 export type ListAgentTasksParts =
-  | ListAgentTasksParts4
-  | ListAgentTasksParts1
-  | ListAgentTasksParts2
-  | ListAgentTasksParts3
-  | ListAgentTasksParts5;
+  | PartsToolCallPart
+  | ListAgentTasksPartsTextPart
+  | ListAgentTasksPartsAgentsDataPart
+  | ListAgentTasksPartsFilePart
+  | ListAgentTasksPartsToolResultPart;
 
-export type ListAgentTasksHistory = {
+/**
+ * Extended Agent-to-Agent protocol message with support for tool calls and tool results. Extends the base A2A message format with Orquesta-specific features.
+ */
+export type ListAgentTasksExtendedA2AMessage = {
   kind: ListAgentTasksAgentsKind;
+  /**
+   * Unique identifier for the message
+   */
   messageId: string;
   /**
-   * Extended A2A message role
+   * Role of the message sender in the A2A protocol. Values: user (end user), agent (AI agent), tool (tool execution result), system (system instructions/prompts).
+   */
+  role: ListAgentTasksExtendedMessageRole;
+  /**
+   * Array of message parts (text, file, tool_call, tool_result)
    */
-  role: ListAgentTasksRole;
   parts: Array<
-    | ListAgentTasksParts4
-    | ListAgentTasksParts1
-    | ListAgentTasksParts2
-    | ListAgentTasksParts3
-    | ListAgentTasksParts5
+    | PartsToolCallPart
+    | ListAgentTasksPartsTextPart
+    | ListAgentTasksPartsAgentsDataPart
+    | ListAgentTasksPartsFilePart
+    | ListAgentTasksPartsToolResultPart
   >;
+  /**
+   * Associated task ID if applicable
+   */
   taskId?: string | undefined;
+  /**
+   * Correlation ID for execution tracking
+   */
   contextId?: string | undefined;
+  /**
+   * Additional message metadata
+   */
   metadata?: { [k: string]: any } | undefined;
 };
 
-export const ListAgentTasksAgentsResponseKind = {
-  Artifact: "artifact",
-} as const;
-export type ListAgentTasksAgentsResponseKind = ClosedEnum<
-  typeof ListAgentTasksAgentsResponseKind
->;
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksArtifactsKind =
+  {
+    Data: "data",
+  } as const;
+export type ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksArtifactsKind =
+  ClosedEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksArtifactsKind
+  >;
 
-export type ListAgentTasksArtifacts = {
-  kind: ListAgentTasksAgentsResponseKind;
-  artifactId: string;
-  name: string;
-  type: string;
-  url?: string | undefined;
-  data?: any | undefined;
+/**
+ * A structured data part containing JSON-serializable key-value pairs. Used for passing structured information between agents and tools.
+ */
+export type ListAgentTasksPartsDataPart = {
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksArtifactsKind;
+  data: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
 };
 
-export type Tasks = {
-  id: string;
-  contextId: string;
-  kind: ListAgentTasksKind;
-  status: ListAgentTasksStatus;
-  history: Array<ListAgentTasksHistory>;
-  artifacts?: Array<ListAgentTasksArtifacts> | undefined;
-  metadata?: { [k: string]: any } | undefined;
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksKind =
+  {
+    File: "file",
+  } as const;
+export type ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksKind =
+  ClosedEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksKind
+  >;
+
+/**
+ * File in URI format. Check in the model's documentation for the supported mime types for the URI format
+ */
+export type ListAgentTasksFileAgentsFileInURIFormat = {
+  /**
+   * URL for the File content
+   */
+  uri: string;
+  /**
+   * Optional mimeType for the file
+   */
+  mimeType?: string | undefined;
+  /**
+   * Optional name for the file
+   */
+  name?: string | undefined;
 };
 
 /**
- * Agent tasks retrieved
+ * Binary in base64 format. Check in the model's documentation for the supported mime types for the binary format.
  */
-export type ListAgentTasksResponseBody = {
-  tasks: Array<Tasks>;
-  overallTotal: number;
+export type ListAgentTasksFileAgentsBinaryFormat = {
+  /**
+   * base64 encoded content of the file
+   */
+  bytes: string;
+  /**
+   * Optional mimeType for the file
+   */
+  mimeType?: string | undefined;
+  /**
+   * Optional name for the file
+   */
+  name?: string | undefined;
 };
 
-/** @internal */
-export const Status$inboundSchema: z.ZodNativeEnum<typeof Status> = z
-  .nativeEnum(Status);
-/** @internal */
-export const Status$outboundSchema: z.ZodNativeEnum<typeof Status> =
-  Status$inboundSchema;
+export type ListAgentTasksPartsAgentsFile =
+  | ListAgentTasksFileAgentsBinaryFormat
+  | ListAgentTasksFileAgentsFileInURIFormat;
 
-/** @internal */
-export const ListAgentTasksRequest$inboundSchema: z.ZodType<
-  ListAgentTasksRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  agent_key: z.string(),
-  limit: z.number().default(10),
-  starting_after: z.string().optional(),
-  ending_before: z.string().optional(),
-  status: Status$inboundSchema.optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "agent_key": "agentKey",
-    "starting_after": "startingAfter",
-    "ending_before": "endingBefore",
-  });
-});
-/** @internal */
-export type ListAgentTasksRequest$Outbound = {
-  agent_key: string;
-  limit: number;
-  starting_after?: string | undefined;
-  ending_before?: string | undefined;
-  status?: string | undefined;
+/**
+ * A file content part that can contain either base64-encoded bytes or a URI reference. Used for images, documents, and other binary content in agent communications.
+ */
+export type ListAgentTasksPartsAgentsFilePart = {
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksKind;
+  file:
+    | ListAgentTasksFileAgentsBinaryFormat
+    | ListAgentTasksFileAgentsFileInURIFormat;
+  metadata?: { [k: string]: any } | undefined;
 };
 
-/** @internal */
-export const ListAgentTasksRequest$outboundSchema: z.ZodType<
-  ListAgentTasksRequest$Outbound,
-  z.ZodTypeDef,
-  ListAgentTasksRequest
-> = z.object({
-  agentKey: z.string(),
-  limit: z.number().default(10),
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyKind =
+  {
+    Text: "text",
+  } as const;
+export type ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyKind =
+  ClosedEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyKind
+  >;
+
+/**
+ * A text content part containing plain text or markdown. Used for agent messages, user input, and text-based responses.
+ */
+export type ListAgentTasksPartsAgentsTextPart = {
+  kind: ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyKind;
+  text: string;
+};
+
+export type ListAgentTasksAgentsParts =
+  | ListAgentTasksPartsAgentsTextPart
+  | ListAgentTasksPartsAgentsFilePart
+  | ListAgentTasksPartsDataPart;
+
+/**
+ * A file or data artifact produced by the agent during task execution. Follows the A2A SDK Artifact structure with required name field.
+ */
+export type ListAgentTasksTaskArtifact = {
+  /**
+   * Unique identifier for the artifact (ULID format)
+   */
+  artifactId: string;
+  /**
+   * Required name for the artifact (e.g., filename or descriptive title)
+   */
+  name: string;
+  /**
+   * Optional human-readable description of the artifact
+   */
+  description?: string | undefined;
+  /**
+   * Array of artifact content parts (text, file, or data). Does not include tool_call or tool_result parts.
+   */
+  parts: Array<
+    | ListAgentTasksPartsAgentsTextPart
+    | ListAgentTasksPartsAgentsFilePart
+    | ListAgentTasksPartsDataPart
+  >;
+  /**
+   * File extensions associated with this artifact (e.g., [".pdf"])
+   */
+  extensions?: Array<string> | undefined;
+  /**
+   * Additional artifact metadata as key-value pairs
+   */
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/**
+ * Agent task execution response format with full conversation history and artifacts. Used for API responses when retrieving task details.
+ */
+export type ExtendedTaskResponse = {
+  /**
+   * Unique task execution identifier
+   */
+  id: string;
+  /**
+   * Correlation ID for tracking
+   */
+  contextId: string;
+  /**
+   * A2A entity type
+   */
+  kind: ListAgentTasksKind;
+  /**
+   * Current task execution status
+   */
+  status: ListAgentTasksTaskStatus;
+  /**
+   * Conversation history with all messages exchanged
+   */
+  history: Array<ListAgentTasksExtendedA2AMessage>;
+  /**
+   * Optional files or data produced during execution
+   */
+  artifacts?: Array<ListAgentTasksTaskArtifact> | undefined;
+  /**
+   * Additional task metadata
+   */
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/**
+ * Response format for listing all tasks associated with an agent. Includes paginated task array and total count.
+ */
+export type ListAgentTasksAgentTasksListResponse = {
+  /**
+   * Array of agent tasks with full execution details
+   */
+  tasks: Array<ExtendedTaskResponse>;
+  /**
+   * Total count of tasks for this agent (across all pages, unfiltered)
+   */
+  overallTotal: number;
+};
+
+/** @internal */
+export const ListAgentTasksRequest$inboundSchema: z.ZodType<
+  ListAgentTasksRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  agent_key: z.string(),
+  limit: z.number().default(10),
+  starting_after: z.string().optional(),
+  ending_before: z.string().optional(),
+  status: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "agent_key": "agentKey",
+    "starting_after": "startingAfter",
+    "ending_before": "endingBefore",
+  });
+});
+/** @internal */
+export type ListAgentTasksRequest$Outbound = {
+  agent_key: string;
+  limit: number;
+  starting_after?: string | undefined;
+  ending_before?: string | undefined;
+  status?: string | undefined;
+};
+
+/** @internal */
+export const ListAgentTasksRequest$outboundSchema: z.ZodType<
+  ListAgentTasksRequest$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksRequest
+> = z.object({
+  agentKey: z.string(),
+  limit: z.number().default(10),
   startingAfter: z.string().optional(),
   endingBefore: z.string().optional(),
-  status: Status$outboundSchema.optional(),
+  status: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     agentKey: "agent_key",
@@ -328,218 +714,1416 @@ export const ListAgentTasksKind$outboundSchema: z.ZodNativeEnum<
 > = ListAgentTasksKind$inboundSchema;
 
 /** @internal */
-export const ListAgentTasksStatus$inboundSchema: z.ZodType<
-  ListAgentTasksStatus,
+export const ListAgentTasksTaskState$inboundSchema: z.ZodNativeEnum<
+  typeof ListAgentTasksTaskState
+> = z.nativeEnum(ListAgentTasksTaskState);
+/** @internal */
+export const ListAgentTasksTaskState$outboundSchema: z.ZodNativeEnum<
+  typeof ListAgentTasksTaskState
+> = ListAgentTasksTaskState$inboundSchema;
+
+/** @internal */
+export const ListAgentTasksAgentsResponseKind$inboundSchema: z.ZodNativeEnum<
+  typeof ListAgentTasksAgentsResponseKind
+> = z.nativeEnum(ListAgentTasksAgentsResponseKind);
+/** @internal */
+export const ListAgentTasksAgentsResponseKind$outboundSchema: z.ZodNativeEnum<
+  typeof ListAgentTasksAgentsResponseKind
+> = ListAgentTasksAgentsResponseKind$inboundSchema;
+
+/** @internal */
+export const ListAgentTasksAgentsExtendedMessageRole$inboundSchema:
+  z.ZodNativeEnum<typeof ListAgentTasksAgentsExtendedMessageRole> = z
+    .nativeEnum(ListAgentTasksAgentsExtendedMessageRole);
+/** @internal */
+export const ListAgentTasksAgentsExtendedMessageRole$outboundSchema:
+  z.ZodNativeEnum<typeof ListAgentTasksAgentsExtendedMessageRole> =
+    ListAgentTasksAgentsExtendedMessageRole$inboundSchema;
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage5Kind$inboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage5Kind
+  > = z.nativeEnum(
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage5Kind,
+  );
+/** @internal */
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage5Kind$outboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage5Kind
+  > =
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage5Kind$inboundSchema;
+
+/** @internal */
+export const ListAgentTasksPartsAgentsToolResultPart$inboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsToolResultPart,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  state: z.string(),
-  timestamp: z.string().optional(),
-  message: z.any().optional(),
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage5Kind$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 ListAgentTasksStatus$Outbound = {
-  state: string;
-  timestamp?: string | undefined;
-  message?: any | undefined;
+export type ListAgentTasksPartsAgentsToolResultPart$Outbound = {
+  kind: string;
+  tool_call_id: string;
+  result?: any | undefined;
+  metadata?: { [k: string]: any } | undefined;
 };
 
 /** @internal */
-export const ListAgentTasksStatus$outboundSchema: z.ZodType<
-  ListAgentTasksStatus$Outbound,
+export const ListAgentTasksPartsAgentsToolResultPart$outboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsToolResultPart$Outbound,
   z.ZodTypeDef,
-  ListAgentTasksStatus
+  ListAgentTasksPartsAgentsToolResultPart
 > = z.object({
-  state: z.string(),
-  timestamp: z.string().optional(),
-  message: z.any().optional(),
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage5Kind$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 listAgentTasksStatusToJSON(
-  listAgentTasksStatus: ListAgentTasksStatus,
+export function listAgentTasksPartsAgentsToolResultPartToJSON(
+  listAgentTasksPartsAgentsToolResultPart:
+    ListAgentTasksPartsAgentsToolResultPart,
 ): string {
   return JSON.stringify(
-    ListAgentTasksStatus$outboundSchema.parse(listAgentTasksStatus),
+    ListAgentTasksPartsAgentsToolResultPart$outboundSchema.parse(
+      listAgentTasksPartsAgentsToolResultPart,
+    ),
   );
 }
-export function listAgentTasksStatusFromJSON(
+export function listAgentTasksPartsAgentsToolResultPartFromJSON(
   jsonString: string,
-): SafeParseResult<ListAgentTasksStatus, SDKValidationError> {
+): SafeParseResult<
+  ListAgentTasksPartsAgentsToolResultPart,
+  SDKValidationError
+> {
   return safeParse(
     jsonString,
-    (x) => ListAgentTasksStatus$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentTasksStatus' from JSON`,
+    (x) =>
+      ListAgentTasksPartsAgentsToolResultPart$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ListAgentTasksPartsAgentsToolResultPart' from JSON`,
   );
 }
 
 /** @internal */
-export const ListAgentTasksAgentsKind$inboundSchema: z.ZodNativeEnum<
-  typeof ListAgentTasksAgentsKind
-> = z.nativeEnum(ListAgentTasksAgentsKind);
-/** @internal */
-export const ListAgentTasksAgentsKind$outboundSchema: z.ZodNativeEnum<
-  typeof ListAgentTasksAgentsKind
-> = ListAgentTasksAgentsKind$inboundSchema;
-
-/** @internal */
-export const ListAgentTasksRole$inboundSchema: z.ZodNativeEnum<
-  typeof ListAgentTasksRole
-> = z.nativeEnum(ListAgentTasksRole);
-/** @internal */
-export const ListAgentTasksRole$outboundSchema: z.ZodNativeEnum<
-  typeof ListAgentTasksRole
-> = ListAgentTasksRole$inboundSchema;
-
-/** @internal */
-export const ListAgentTasksPartsAgentsResponse200ApplicationJSONKind$inboundSchema:
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessageKind$inboundSchema:
   z.ZodNativeEnum<
-    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONKind
-  > = z.nativeEnum(ListAgentTasksPartsAgentsResponse200ApplicationJSONKind);
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessageKind
+  > = z.nativeEnum(
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessageKind,
+  );
 /** @internal */
-export const ListAgentTasksPartsAgentsResponse200ApplicationJSONKind$outboundSchema:
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessageKind$outboundSchema:
   z.ZodNativeEnum<
-    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONKind
-  > = ListAgentTasksPartsAgentsResponse200ApplicationJSONKind$inboundSchema;
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessageKind
+  > =
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessageKind$inboundSchema;
 
 /** @internal */
-export const ListAgentTasksParts5$inboundSchema: z.ZodType<
-  ListAgentTasksParts5,
+export const ListAgentTasksPartsToolCallPart$inboundSchema: z.ZodType<
+  ListAgentTasksPartsToolCallPart,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  kind: ListAgentTasksPartsAgentsResponse200ApplicationJSONKind$inboundSchema,
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessageKind$inboundSchema,
+  tool_name: z.string(),
   tool_call_id: z.string(),
-  result: z.any().optional(),
+  arguments: z.record(z.any()),
   metadata: z.record(z.any()).optional(),
 }).transform((v) => {
   return remap$(v, {
+    "tool_name": "toolName",
     "tool_call_id": "toolCallId",
   });
 });
 /** @internal */
-export type ListAgentTasksParts5$Outbound = {
+export type ListAgentTasksPartsToolCallPart$Outbound = {
+  kind: string;
+  tool_name: string;
+  tool_call_id: string;
+  arguments: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ListAgentTasksPartsToolCallPart$outboundSchema: z.ZodType<
+  ListAgentTasksPartsToolCallPart$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksPartsToolCallPart
+> = z.object({
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessageKind$outboundSchema,
+  toolName: z.string(),
+  toolCallId: z.string(),
+  arguments: z.record(z.any()),
+  metadata: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    toolName: "tool_name",
+    toolCallId: "tool_call_id",
+  });
+});
+
+export function listAgentTasksPartsToolCallPartToJSON(
+  listAgentTasksPartsToolCallPart: ListAgentTasksPartsToolCallPart,
+): string {
+  return JSON.stringify(
+    ListAgentTasksPartsToolCallPart$outboundSchema.parse(
+      listAgentTasksPartsToolCallPart,
+    ),
+  );
+}
+export function listAgentTasksPartsToolCallPartFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentTasksPartsToolCallPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentTasksPartsToolCallPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksPartsToolCallPart' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusKind$inboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusKind
+  > = z.nativeEnum(
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusKind,
+  );
+/** @internal */
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusKind$outboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusKind
+  > =
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusKind$inboundSchema;
+
+/** @internal */
+export const ListAgentTasksFileAgentsResponseFileInURIFormat$inboundSchema:
+  z.ZodType<
+    ListAgentTasksFileAgentsResponseFileInURIFormat,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    uri: z.string(),
+    mimeType: z.string().optional(),
+    name: z.string().optional(),
+  });
+/** @internal */
+export type ListAgentTasksFileAgentsResponseFileInURIFormat$Outbound = {
+  uri: string;
+  mimeType?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const ListAgentTasksFileAgentsResponseFileInURIFormat$outboundSchema:
+  z.ZodType<
+    ListAgentTasksFileAgentsResponseFileInURIFormat$Outbound,
+    z.ZodTypeDef,
+    ListAgentTasksFileAgentsResponseFileInURIFormat
+  > = z.object({
+    uri: z.string(),
+    mimeType: z.string().optional(),
+    name: z.string().optional(),
+  });
+
+export function listAgentTasksFileAgentsResponseFileInURIFormatToJSON(
+  listAgentTasksFileAgentsResponseFileInURIFormat:
+    ListAgentTasksFileAgentsResponseFileInURIFormat,
+): string {
+  return JSON.stringify(
+    ListAgentTasksFileAgentsResponseFileInURIFormat$outboundSchema.parse(
+      listAgentTasksFileAgentsResponseFileInURIFormat,
+    ),
+  );
+}
+export function listAgentTasksFileAgentsResponseFileInURIFormatFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ListAgentTasksFileAgentsResponseFileInURIFormat,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListAgentTasksFileAgentsResponseFileInURIFormat$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ListAgentTasksFileAgentsResponseFileInURIFormat' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksFileAgentsResponseBinaryFormat$inboundSchema:
+  z.ZodType<
+    ListAgentTasksFileAgentsResponseBinaryFormat,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    bytes: z.string(),
+    mimeType: z.string().optional(),
+    name: z.string().optional(),
+  });
+/** @internal */
+export type ListAgentTasksFileAgentsResponseBinaryFormat$Outbound = {
+  bytes: string;
+  mimeType?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const ListAgentTasksFileAgentsResponseBinaryFormat$outboundSchema:
+  z.ZodType<
+    ListAgentTasksFileAgentsResponseBinaryFormat$Outbound,
+    z.ZodTypeDef,
+    ListAgentTasksFileAgentsResponseBinaryFormat
+  > = z.object({
+    bytes: z.string(),
+    mimeType: z.string().optional(),
+    name: z.string().optional(),
+  });
+
+export function listAgentTasksFileAgentsResponseBinaryFormatToJSON(
+  listAgentTasksFileAgentsResponseBinaryFormat:
+    ListAgentTasksFileAgentsResponseBinaryFormat,
+): string {
+  return JSON.stringify(
+    ListAgentTasksFileAgentsResponseBinaryFormat$outboundSchema.parse(
+      listAgentTasksFileAgentsResponseBinaryFormat,
+    ),
+  );
+}
+export function listAgentTasksFileAgentsResponseBinaryFormatFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ListAgentTasksFileAgentsResponseBinaryFormat,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListAgentTasksFileAgentsResponseBinaryFormat$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ListAgentTasksFileAgentsResponseBinaryFormat' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponseFile$inboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsResponseFile,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => ListAgentTasksFileAgentsResponseBinaryFormat$inboundSchema),
+  z.lazy(() => ListAgentTasksFileAgentsResponseFileInURIFormat$inboundSchema),
+]);
+/** @internal */
+export type ListAgentTasksPartsAgentsResponseFile$Outbound =
+  | ListAgentTasksFileAgentsResponseBinaryFormat$Outbound
+  | ListAgentTasksFileAgentsResponseFileInURIFormat$Outbound;
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponseFile$outboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsResponseFile$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksPartsAgentsResponseFile
+> = z.union([
+  z.lazy(() => ListAgentTasksFileAgentsResponseBinaryFormat$outboundSchema),
+  z.lazy(() => ListAgentTasksFileAgentsResponseFileInURIFormat$outboundSchema),
+]);
+
+export function listAgentTasksPartsAgentsResponseFileToJSON(
+  listAgentTasksPartsAgentsResponseFile: ListAgentTasksPartsAgentsResponseFile,
+): string {
+  return JSON.stringify(
+    ListAgentTasksPartsAgentsResponseFile$outboundSchema.parse(
+      listAgentTasksPartsAgentsResponseFile,
+    ),
+  );
+}
+export function listAgentTasksPartsAgentsResponseFileFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentTasksPartsAgentsResponseFile, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListAgentTasksPartsAgentsResponseFile$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksPartsAgentsResponseFile' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponseFilePart$inboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsResponseFilePart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusKind$inboundSchema,
+  file: z.union([
+    z.lazy(() => ListAgentTasksFileAgentsResponseBinaryFormat$inboundSchema),
+    z.lazy(() => ListAgentTasksFileAgentsResponseFileInURIFormat$inboundSchema),
+  ]),
+  metadata: z.record(z.any()).optional(),
+});
+/** @internal */
+export type ListAgentTasksPartsAgentsResponseFilePart$Outbound = {
+  kind: string;
+  file:
+    | ListAgentTasksFileAgentsResponseBinaryFormat$Outbound
+    | ListAgentTasksFileAgentsResponseFileInURIFormat$Outbound;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponseFilePart$outboundSchema:
+  z.ZodType<
+    ListAgentTasksPartsAgentsResponseFilePart$Outbound,
+    z.ZodTypeDef,
+    ListAgentTasksPartsAgentsResponseFilePart
+  > = z.object({
+    kind:
+      ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusKind$outboundSchema,
+    file: z.union([
+      z.lazy(() => ListAgentTasksFileAgentsResponseBinaryFormat$outboundSchema),
+      z.lazy(() =>
+        ListAgentTasksFileAgentsResponseFileInURIFormat$outboundSchema
+      ),
+    ]),
+    metadata: z.record(z.any()).optional(),
+  });
+
+export function listAgentTasksPartsAgentsResponseFilePartToJSON(
+  listAgentTasksPartsAgentsResponseFilePart:
+    ListAgentTasksPartsAgentsResponseFilePart,
+): string {
+  return JSON.stringify(
+    ListAgentTasksPartsAgentsResponseFilePart$outboundSchema.parse(
+      listAgentTasksPartsAgentsResponseFilePart,
+    ),
+  );
+}
+export function listAgentTasksPartsAgentsResponseFilePartFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ListAgentTasksPartsAgentsResponseFilePart,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListAgentTasksPartsAgentsResponseFilePart$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ListAgentTasksPartsAgentsResponseFilePart' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage2Kind$inboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage2Kind
+  > = z.nativeEnum(
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage2Kind,
+  );
+/** @internal */
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage2Kind$outboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage2Kind
+  > =
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage2Kind$inboundSchema;
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponseDataPart$inboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsResponseDataPart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage2Kind$inboundSchema,
+  data: z.record(z.any()),
+  metadata: z.record(z.any()).optional(),
+});
+/** @internal */
+export type ListAgentTasksPartsAgentsResponseDataPart$Outbound = {
+  kind: string;
+  data: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponseDataPart$outboundSchema:
+  z.ZodType<
+    ListAgentTasksPartsAgentsResponseDataPart$Outbound,
+    z.ZodTypeDef,
+    ListAgentTasksPartsAgentsResponseDataPart
+  > = z.object({
+    kind:
+      ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage2Kind$outboundSchema,
+    data: z.record(z.any()),
+    metadata: z.record(z.any()).optional(),
+  });
+
+export function listAgentTasksPartsAgentsResponseDataPartToJSON(
+  listAgentTasksPartsAgentsResponseDataPart:
+    ListAgentTasksPartsAgentsResponseDataPart,
+): string {
+  return JSON.stringify(
+    ListAgentTasksPartsAgentsResponseDataPart$outboundSchema.parse(
+      listAgentTasksPartsAgentsResponseDataPart,
+    ),
+  );
+}
+export function listAgentTasksPartsAgentsResponseDataPartFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ListAgentTasksPartsAgentsResponseDataPart,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListAgentTasksPartsAgentsResponseDataPart$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ListAgentTasksPartsAgentsResponseDataPart' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage1Kind$inboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage1Kind
+  > = z.nativeEnum(
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage1Kind,
+  );
+/** @internal */
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage1Kind$outboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage1Kind
+  > =
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage1Kind$inboundSchema;
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponseTextPart$inboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsResponseTextPart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage1Kind$inboundSchema,
+  text: z.string(),
+});
+/** @internal */
+export type ListAgentTasksPartsAgentsResponseTextPart$Outbound = {
+  kind: string;
+  text: string;
+};
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponseTextPart$outboundSchema:
+  z.ZodType<
+    ListAgentTasksPartsAgentsResponseTextPart$Outbound,
+    z.ZodTypeDef,
+    ListAgentTasksPartsAgentsResponseTextPart
+  > = z.object({
+    kind:
+      ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksStatusMessage1Kind$outboundSchema,
+    text: z.string(),
+  });
+
+export function listAgentTasksPartsAgentsResponseTextPartToJSON(
+  listAgentTasksPartsAgentsResponseTextPart:
+    ListAgentTasksPartsAgentsResponseTextPart,
+): string {
+  return JSON.stringify(
+    ListAgentTasksPartsAgentsResponseTextPart$outboundSchema.parse(
+      listAgentTasksPartsAgentsResponseTextPart,
+    ),
+  );
+}
+export function listAgentTasksPartsAgentsResponseTextPartFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ListAgentTasksPartsAgentsResponseTextPart,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListAgentTasksPartsAgentsResponseTextPart$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ListAgentTasksPartsAgentsResponseTextPart' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksAgentsResponseParts$inboundSchema: z.ZodType<
+  ListAgentTasksAgentsResponseParts,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => ListAgentTasksPartsToolCallPart$inboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsResponseTextPart$inboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsResponseDataPart$inboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsResponseFilePart$inboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsToolResultPart$inboundSchema),
+]);
+/** @internal */
+export type ListAgentTasksAgentsResponseParts$Outbound =
+  | ListAgentTasksPartsToolCallPart$Outbound
+  | ListAgentTasksPartsAgentsResponseTextPart$Outbound
+  | ListAgentTasksPartsAgentsResponseDataPart$Outbound
+  | ListAgentTasksPartsAgentsResponseFilePart$Outbound
+  | ListAgentTasksPartsAgentsToolResultPart$Outbound;
+
+/** @internal */
+export const ListAgentTasksAgentsResponseParts$outboundSchema: z.ZodType<
+  ListAgentTasksAgentsResponseParts$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksAgentsResponseParts
+> = z.union([
+  z.lazy(() => ListAgentTasksPartsToolCallPart$outboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsResponseTextPart$outboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsResponseDataPart$outboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsResponseFilePart$outboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsToolResultPart$outboundSchema),
+]);
+
+export function listAgentTasksAgentsResponsePartsToJSON(
+  listAgentTasksAgentsResponseParts: ListAgentTasksAgentsResponseParts,
+): string {
+  return JSON.stringify(
+    ListAgentTasksAgentsResponseParts$outboundSchema.parse(
+      listAgentTasksAgentsResponseParts,
+    ),
+  );
+}
+export function listAgentTasksAgentsResponsePartsFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentTasksAgentsResponseParts, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentTasksAgentsResponseParts$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksAgentsResponseParts' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksTaskStatusMessage$inboundSchema: z.ZodType<
+  ListAgentTasksTaskStatusMessage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: ListAgentTasksAgentsResponseKind$inboundSchema,
+  messageId: z.string(),
+  role: ListAgentTasksAgentsExtendedMessageRole$inboundSchema,
+  parts: z.array(
+    z.union([
+      z.lazy(() => ListAgentTasksPartsToolCallPart$inboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsResponseTextPart$inboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsResponseDataPart$inboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsResponseFilePart$inboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsToolResultPart$inboundSchema),
+    ]),
+  ),
+});
+/** @internal */
+export type ListAgentTasksTaskStatusMessage$Outbound = {
+  kind: string;
+  messageId: string;
+  role: string;
+  parts: Array<
+    | ListAgentTasksPartsToolCallPart$Outbound
+    | ListAgentTasksPartsAgentsResponseTextPart$Outbound
+    | ListAgentTasksPartsAgentsResponseDataPart$Outbound
+    | ListAgentTasksPartsAgentsResponseFilePart$Outbound
+    | ListAgentTasksPartsAgentsToolResultPart$Outbound
+  >;
+};
+
+/** @internal */
+export const ListAgentTasksTaskStatusMessage$outboundSchema: z.ZodType<
+  ListAgentTasksTaskStatusMessage$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksTaskStatusMessage
+> = z.object({
+  kind: ListAgentTasksAgentsResponseKind$outboundSchema,
+  messageId: z.string(),
+  role: ListAgentTasksAgentsExtendedMessageRole$outboundSchema,
+  parts: z.array(
+    z.union([
+      z.lazy(() => ListAgentTasksPartsToolCallPart$outboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsResponseTextPart$outboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsResponseDataPart$outboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsResponseFilePart$outboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsToolResultPart$outboundSchema),
+    ]),
+  ),
+});
+
+export function listAgentTasksTaskStatusMessageToJSON(
+  listAgentTasksTaskStatusMessage: ListAgentTasksTaskStatusMessage,
+): string {
+  return JSON.stringify(
+    ListAgentTasksTaskStatusMessage$outboundSchema.parse(
+      listAgentTasksTaskStatusMessage,
+    ),
+  );
+}
+export function listAgentTasksTaskStatusMessageFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentTasksTaskStatusMessage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentTasksTaskStatusMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksTaskStatusMessage' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksTaskStatus$inboundSchema: z.ZodType<
+  ListAgentTasksTaskStatus,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  state: ListAgentTasksTaskState$inboundSchema,
+  timestamp: z.string().optional(),
+  message: z.lazy(() => ListAgentTasksTaskStatusMessage$inboundSchema)
+    .optional(),
+});
+/** @internal */
+export type ListAgentTasksTaskStatus$Outbound = {
+  state: string;
+  timestamp?: string | undefined;
+  message?: ListAgentTasksTaskStatusMessage$Outbound | undefined;
+};
+
+/** @internal */
+export const ListAgentTasksTaskStatus$outboundSchema: z.ZodType<
+  ListAgentTasksTaskStatus$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksTaskStatus
+> = z.object({
+  state: ListAgentTasksTaskState$outboundSchema,
+  timestamp: z.string().optional(),
+  message: z.lazy(() => ListAgentTasksTaskStatusMessage$outboundSchema)
+    .optional(),
+});
+
+export function listAgentTasksTaskStatusToJSON(
+  listAgentTasksTaskStatus: ListAgentTasksTaskStatus,
+): string {
+  return JSON.stringify(
+    ListAgentTasksTaskStatus$outboundSchema.parse(listAgentTasksTaskStatus),
+  );
+}
+export function listAgentTasksTaskStatusFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentTasksTaskStatus, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentTasksTaskStatus$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksTaskStatus' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksAgentsKind$inboundSchema: z.ZodNativeEnum<
+  typeof ListAgentTasksAgentsKind
+> = z.nativeEnum(ListAgentTasksAgentsKind);
+/** @internal */
+export const ListAgentTasksAgentsKind$outboundSchema: z.ZodNativeEnum<
+  typeof ListAgentTasksAgentsKind
+> = ListAgentTasksAgentsKind$inboundSchema;
+
+/** @internal */
+export const ListAgentTasksExtendedMessageRole$inboundSchema: z.ZodNativeEnum<
+  typeof ListAgentTasksExtendedMessageRole
+> = z.nativeEnum(ListAgentTasksExtendedMessageRole);
+/** @internal */
+export const ListAgentTasksExtendedMessageRole$outboundSchema: z.ZodNativeEnum<
+  typeof ListAgentTasksExtendedMessageRole
+> = ListAgentTasksExtendedMessageRole$inboundSchema;
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONKind$inboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONKind
+  > = z.nativeEnum(ListAgentTasksPartsAgentsResponse200ApplicationJSONKind);
+/** @internal */
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONKind$outboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONKind
+  > = ListAgentTasksPartsAgentsResponse200ApplicationJSONKind$inboundSchema;
+
+/** @internal */
+export const ListAgentTasksPartsToolResultPart$inboundSchema: z.ZodType<
+  ListAgentTasksPartsToolResultPart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: ListAgentTasksPartsAgentsResponse200ApplicationJSONKind$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 ListAgentTasksPartsToolResultPart$Outbound = {
+  kind: string;
+  tool_call_id: string;
+  result?: any | undefined;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ListAgentTasksPartsToolResultPart$outboundSchema: z.ZodType<
+  ListAgentTasksPartsToolResultPart$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksPartsToolResultPart
+> = z.object({
+  kind: ListAgentTasksPartsAgentsResponse200ApplicationJSONKind$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 listAgentTasksPartsToolResultPartToJSON(
+  listAgentTasksPartsToolResultPart: ListAgentTasksPartsToolResultPart,
+): string {
+  return JSON.stringify(
+    ListAgentTasksPartsToolResultPart$outboundSchema.parse(
+      listAgentTasksPartsToolResultPart,
+    ),
+  );
+}
+export function listAgentTasksPartsToolResultPartFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentTasksPartsToolResultPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentTasksPartsToolResultPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksPartsToolResultPart' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponse200Kind$inboundSchema:
+  z.ZodNativeEnum<typeof ListAgentTasksPartsAgentsResponse200Kind> = z
+    .nativeEnum(ListAgentTasksPartsAgentsResponse200Kind);
+/** @internal */
+export const ListAgentTasksPartsAgentsResponse200Kind$outboundSchema:
+  z.ZodNativeEnum<typeof ListAgentTasksPartsAgentsResponse200Kind> =
+    ListAgentTasksPartsAgentsResponse200Kind$inboundSchema;
+
+/** @internal */
+export const PartsToolCallPart$inboundSchema: z.ZodType<
+  PartsToolCallPart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: ListAgentTasksPartsAgentsResponse200Kind$inboundSchema,
+  tool_name: z.string(),
+  tool_call_id: z.string(),
+  arguments: z.record(z.any()),
+  metadata: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_name": "toolName",
+    "tool_call_id": "toolCallId",
+  });
+});
+/** @internal */
+export type PartsToolCallPart$Outbound = {
+  kind: string;
+  tool_name: string;
+  tool_call_id: string;
+  arguments: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const PartsToolCallPart$outboundSchema: z.ZodType<
+  PartsToolCallPart$Outbound,
+  z.ZodTypeDef,
+  PartsToolCallPart
+> = z.object({
+  kind: ListAgentTasksPartsAgentsResponse200Kind$outboundSchema,
+  toolName: z.string(),
+  toolCallId: z.string(),
+  arguments: z.record(z.any()),
+  metadata: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    toolName: "tool_name",
+    toolCallId: "tool_call_id",
+  });
+});
+
+export function partsToolCallPartToJSON(
+  partsToolCallPart: PartsToolCallPart,
+): string {
+  return JSON.stringify(
+    PartsToolCallPart$outboundSchema.parse(partsToolCallPart),
+  );
+}
+export function partsToolCallPartFromJSON(
+  jsonString: string,
+): SafeParseResult<PartsToolCallPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PartsToolCallPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PartsToolCallPart' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksPartsAgentsResponseKind$inboundSchema:
+  z.ZodNativeEnum<typeof ListAgentTasksPartsAgentsResponseKind> = z.nativeEnum(
+    ListAgentTasksPartsAgentsResponseKind,
+  );
+/** @internal */
+export const ListAgentTasksPartsAgentsResponseKind$outboundSchema:
+  z.ZodNativeEnum<typeof ListAgentTasksPartsAgentsResponseKind> =
+    ListAgentTasksPartsAgentsResponseKind$inboundSchema;
+
+/** @internal */
+export const ListAgentTasksFileFileInURIFormat$inboundSchema: z.ZodType<
+  ListAgentTasksFileFileInURIFormat,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  uri: z.string(),
+  mimeType: z.string().optional(),
+  name: z.string().optional(),
+});
+/** @internal */
+export type ListAgentTasksFileFileInURIFormat$Outbound = {
+  uri: string;
+  mimeType?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const ListAgentTasksFileFileInURIFormat$outboundSchema: z.ZodType<
+  ListAgentTasksFileFileInURIFormat$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksFileFileInURIFormat
+> = z.object({
+  uri: z.string(),
+  mimeType: z.string().optional(),
+  name: z.string().optional(),
+});
+
+export function listAgentTasksFileFileInURIFormatToJSON(
+  listAgentTasksFileFileInURIFormat: ListAgentTasksFileFileInURIFormat,
+): string {
+  return JSON.stringify(
+    ListAgentTasksFileFileInURIFormat$outboundSchema.parse(
+      listAgentTasksFileFileInURIFormat,
+    ),
+  );
+}
+export function listAgentTasksFileFileInURIFormatFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentTasksFileFileInURIFormat, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentTasksFileFileInURIFormat$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksFileFileInURIFormat' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksFileBinaryFormat$inboundSchema: z.ZodType<
+  ListAgentTasksFileBinaryFormat,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  bytes: z.string(),
+  mimeType: z.string().optional(),
+  name: z.string().optional(),
+});
+/** @internal */
+export type ListAgentTasksFileBinaryFormat$Outbound = {
+  bytes: string;
+  mimeType?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const ListAgentTasksFileBinaryFormat$outboundSchema: z.ZodType<
+  ListAgentTasksFileBinaryFormat$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksFileBinaryFormat
+> = z.object({
+  bytes: z.string(),
+  mimeType: z.string().optional(),
+  name: z.string().optional(),
+});
+
+export function listAgentTasksFileBinaryFormatToJSON(
+  listAgentTasksFileBinaryFormat: ListAgentTasksFileBinaryFormat,
+): string {
+  return JSON.stringify(
+    ListAgentTasksFileBinaryFormat$outboundSchema.parse(
+      listAgentTasksFileBinaryFormat,
+    ),
+  );
+}
+export function listAgentTasksFileBinaryFormatFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentTasksFileBinaryFormat, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentTasksFileBinaryFormat$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksFileBinaryFormat' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksPartsFile$inboundSchema: z.ZodType<
+  ListAgentTasksPartsFile,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => ListAgentTasksFileBinaryFormat$inboundSchema),
+  z.lazy(() => ListAgentTasksFileFileInURIFormat$inboundSchema),
+]);
+/** @internal */
+export type ListAgentTasksPartsFile$Outbound =
+  | ListAgentTasksFileBinaryFormat$Outbound
+  | ListAgentTasksFileFileInURIFormat$Outbound;
+
+/** @internal */
+export const ListAgentTasksPartsFile$outboundSchema: z.ZodType<
+  ListAgentTasksPartsFile$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksPartsFile
+> = z.union([
+  z.lazy(() => ListAgentTasksFileBinaryFormat$outboundSchema),
+  z.lazy(() => ListAgentTasksFileFileInURIFormat$outboundSchema),
+]);
+
+export function listAgentTasksPartsFileToJSON(
+  listAgentTasksPartsFile: ListAgentTasksPartsFile,
+): string {
+  return JSON.stringify(
+    ListAgentTasksPartsFile$outboundSchema.parse(listAgentTasksPartsFile),
+  );
+}
+export function listAgentTasksPartsFileFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentTasksPartsFile, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentTasksPartsFile$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksPartsFile' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksPartsFilePart$inboundSchema: z.ZodType<
+  ListAgentTasksPartsFilePart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: ListAgentTasksPartsAgentsResponseKind$inboundSchema,
+  file: z.union([
+    z.lazy(() => ListAgentTasksFileBinaryFormat$inboundSchema),
+    z.lazy(() => ListAgentTasksFileFileInURIFormat$inboundSchema),
+  ]),
+  metadata: z.record(z.any()).optional(),
+});
+/** @internal */
+export type ListAgentTasksPartsFilePart$Outbound = {
+  kind: string;
+  file:
+    | ListAgentTasksFileBinaryFormat$Outbound
+    | ListAgentTasksFileFileInURIFormat$Outbound;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ListAgentTasksPartsFilePart$outboundSchema: z.ZodType<
+  ListAgentTasksPartsFilePart$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksPartsFilePart
+> = z.object({
+  kind: ListAgentTasksPartsAgentsResponseKind$outboundSchema,
+  file: z.union([
+    z.lazy(() => ListAgentTasksFileBinaryFormat$outboundSchema),
+    z.lazy(() => ListAgentTasksFileFileInURIFormat$outboundSchema),
+  ]),
+  metadata: z.record(z.any()).optional(),
+});
+
+export function listAgentTasksPartsFilePartToJSON(
+  listAgentTasksPartsFilePart: ListAgentTasksPartsFilePart,
+): string {
+  return JSON.stringify(
+    ListAgentTasksPartsFilePart$outboundSchema.parse(
+      listAgentTasksPartsFilePart,
+    ),
+  );
+}
+export function listAgentTasksPartsFilePartFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentTasksPartsFilePart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentTasksPartsFilePart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksPartsFilePart' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksPartsAgentsKind$inboundSchema: z.ZodNativeEnum<
+  typeof ListAgentTasksPartsAgentsKind
+> = z.nativeEnum(ListAgentTasksPartsAgentsKind);
+/** @internal */
+export const ListAgentTasksPartsAgentsKind$outboundSchema: z.ZodNativeEnum<
+  typeof ListAgentTasksPartsAgentsKind
+> = ListAgentTasksPartsAgentsKind$inboundSchema;
+
+/** @internal */
+export const ListAgentTasksPartsAgentsDataPart$inboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsDataPart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: ListAgentTasksPartsAgentsKind$inboundSchema,
+  data: z.record(z.any()),
+  metadata: z.record(z.any()).optional(),
+});
+/** @internal */
+export type ListAgentTasksPartsAgentsDataPart$Outbound = {
+  kind: string;
+  data: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ListAgentTasksPartsAgentsDataPart$outboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsDataPart$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksPartsAgentsDataPart
+> = z.object({
+  kind: ListAgentTasksPartsAgentsKind$outboundSchema,
+  data: z.record(z.any()),
+  metadata: z.record(z.any()).optional(),
+});
+
+export function listAgentTasksPartsAgentsDataPartToJSON(
+  listAgentTasksPartsAgentsDataPart: ListAgentTasksPartsAgentsDataPart,
+): string {
+  return JSON.stringify(
+    ListAgentTasksPartsAgentsDataPart$outboundSchema.parse(
+      listAgentTasksPartsAgentsDataPart,
+    ),
+  );
+}
+export function listAgentTasksPartsAgentsDataPartFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentTasksPartsAgentsDataPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentTasksPartsAgentsDataPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksPartsAgentsDataPart' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksPartsKind$inboundSchema: z.ZodNativeEnum<
+  typeof ListAgentTasksPartsKind
+> = z.nativeEnum(ListAgentTasksPartsKind);
+/** @internal */
+export const ListAgentTasksPartsKind$outboundSchema: z.ZodNativeEnum<
+  typeof ListAgentTasksPartsKind
+> = ListAgentTasksPartsKind$inboundSchema;
+
+/** @internal */
+export const ListAgentTasksPartsTextPart$inboundSchema: z.ZodType<
+  ListAgentTasksPartsTextPart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: ListAgentTasksPartsKind$inboundSchema,
+  text: z.string(),
+});
+/** @internal */
+export type ListAgentTasksPartsTextPart$Outbound = {
+  kind: string;
+  text: string;
+};
+
+/** @internal */
+export const ListAgentTasksPartsTextPart$outboundSchema: z.ZodType<
+  ListAgentTasksPartsTextPart$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksPartsTextPart
+> = z.object({
+  kind: ListAgentTasksPartsKind$outboundSchema,
+  text: z.string(),
+});
+
+export function listAgentTasksPartsTextPartToJSON(
+  listAgentTasksPartsTextPart: ListAgentTasksPartsTextPart,
+): string {
+  return JSON.stringify(
+    ListAgentTasksPartsTextPart$outboundSchema.parse(
+      listAgentTasksPartsTextPart,
+    ),
+  );
+}
+export function listAgentTasksPartsTextPartFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentTasksPartsTextPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentTasksPartsTextPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksPartsTextPart' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksParts$inboundSchema: z.ZodType<
+  ListAgentTasksParts,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => PartsToolCallPart$inboundSchema),
+  z.lazy(() => ListAgentTasksPartsTextPart$inboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsDataPart$inboundSchema),
+  z.lazy(() => ListAgentTasksPartsFilePart$inboundSchema),
+  z.lazy(() => ListAgentTasksPartsToolResultPart$inboundSchema),
+]);
+/** @internal */
+export type ListAgentTasksParts$Outbound =
+  | PartsToolCallPart$Outbound
+  | ListAgentTasksPartsTextPart$Outbound
+  | ListAgentTasksPartsAgentsDataPart$Outbound
+  | ListAgentTasksPartsFilePart$Outbound
+  | ListAgentTasksPartsToolResultPart$Outbound;
+
+/** @internal */
+export const ListAgentTasksParts$outboundSchema: z.ZodType<
+  ListAgentTasksParts$Outbound,
+  z.ZodTypeDef,
+  ListAgentTasksParts
+> = z.union([
+  z.lazy(() => PartsToolCallPart$outboundSchema),
+  z.lazy(() => ListAgentTasksPartsTextPart$outboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsDataPart$outboundSchema),
+  z.lazy(() => ListAgentTasksPartsFilePart$outboundSchema),
+  z.lazy(() => ListAgentTasksPartsToolResultPart$outboundSchema),
+]);
+
+export function listAgentTasksPartsToJSON(
+  listAgentTasksParts: ListAgentTasksParts,
+): string {
+  return JSON.stringify(
+    ListAgentTasksParts$outboundSchema.parse(listAgentTasksParts),
+  );
+}
+export function listAgentTasksPartsFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentTasksParts, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentTasksParts$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksParts' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentTasksExtendedA2AMessage$inboundSchema: z.ZodType<
+  ListAgentTasksExtendedA2AMessage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: ListAgentTasksAgentsKind$inboundSchema,
+  messageId: z.string(),
+  role: ListAgentTasksExtendedMessageRole$inboundSchema,
+  parts: z.array(
+    z.union([
+      z.lazy(() => PartsToolCallPart$inboundSchema),
+      z.lazy(() => ListAgentTasksPartsTextPart$inboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsDataPart$inboundSchema),
+      z.lazy(() => ListAgentTasksPartsFilePart$inboundSchema),
+      z.lazy(() => ListAgentTasksPartsToolResultPart$inboundSchema),
+    ]),
+  ),
+  taskId: z.string().optional(),
+  contextId: z.string().optional(),
+  metadata: z.record(z.any()).optional(),
+});
+/** @internal */
+export type ListAgentTasksExtendedA2AMessage$Outbound = {
   kind: string;
-  tool_call_id: string;
-  result?: any | undefined;
+  messageId: string;
+  role: string;
+  parts: Array<
+    | PartsToolCallPart$Outbound
+    | ListAgentTasksPartsTextPart$Outbound
+    | ListAgentTasksPartsAgentsDataPart$Outbound
+    | ListAgentTasksPartsFilePart$Outbound
+    | ListAgentTasksPartsToolResultPart$Outbound
+  >;
+  taskId?: string | undefined;
+  contextId?: string | undefined;
   metadata?: { [k: string]: any } | undefined;
 };
 
 /** @internal */
-export const ListAgentTasksParts5$outboundSchema: z.ZodType<
-  ListAgentTasksParts5$Outbound,
+export const ListAgentTasksExtendedA2AMessage$outboundSchema: z.ZodType<
+  ListAgentTasksExtendedA2AMessage$Outbound,
   z.ZodTypeDef,
-  ListAgentTasksParts5
+  ListAgentTasksExtendedA2AMessage
 > = z.object({
-  kind: ListAgentTasksPartsAgentsResponse200ApplicationJSONKind$outboundSchema,
-  toolCallId: z.string(),
-  result: z.any().optional(),
+  kind: ListAgentTasksAgentsKind$outboundSchema,
+  messageId: z.string(),
+  role: ListAgentTasksExtendedMessageRole$outboundSchema,
+  parts: z.array(
+    z.union([
+      z.lazy(() => PartsToolCallPart$outboundSchema),
+      z.lazy(() => ListAgentTasksPartsTextPart$outboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsDataPart$outboundSchema),
+      z.lazy(() => ListAgentTasksPartsFilePart$outboundSchema),
+      z.lazy(() => ListAgentTasksPartsToolResultPart$outboundSchema),
+    ]),
+  ),
+  taskId: z.string().optional(),
+  contextId: z.string().optional(),
   metadata: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    toolCallId: "tool_call_id",
-  });
 });
 
-export function listAgentTasksParts5ToJSON(
-  listAgentTasksParts5: ListAgentTasksParts5,
+export function listAgentTasksExtendedA2AMessageToJSON(
+  listAgentTasksExtendedA2AMessage: ListAgentTasksExtendedA2AMessage,
 ): string {
   return JSON.stringify(
-    ListAgentTasksParts5$outboundSchema.parse(listAgentTasksParts5),
+    ListAgentTasksExtendedA2AMessage$outboundSchema.parse(
+      listAgentTasksExtendedA2AMessage,
+    ),
   );
 }
-export function listAgentTasksParts5FromJSON(
+export function listAgentTasksExtendedA2AMessageFromJSON(
   jsonString: string,
-): SafeParseResult<ListAgentTasksParts5, SDKValidationError> {
+): SafeParseResult<ListAgentTasksExtendedA2AMessage, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ListAgentTasksParts5$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentTasksParts5' from JSON`,
+    (x) => ListAgentTasksExtendedA2AMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksExtendedA2AMessage' from JSON`,
   );
 }
 
 /** @internal */
-export const ListAgentTasksPartsAgentsResponse200Kind$inboundSchema:
-  z.ZodNativeEnum<typeof ListAgentTasksPartsAgentsResponse200Kind> = z
-    .nativeEnum(ListAgentTasksPartsAgentsResponse200Kind);
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksArtifactsKind$inboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksArtifactsKind
+  > = z.nativeEnum(
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksArtifactsKind,
+  );
 /** @internal */
-export const ListAgentTasksPartsAgentsResponse200Kind$outboundSchema:
-  z.ZodNativeEnum<typeof ListAgentTasksPartsAgentsResponse200Kind> =
-    ListAgentTasksPartsAgentsResponse200Kind$inboundSchema;
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksArtifactsKind$outboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksArtifactsKind
+  > =
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksArtifactsKind$inboundSchema;
 
 /** @internal */
-export const ListAgentTasksParts4$inboundSchema: z.ZodType<
-  ListAgentTasksParts4,
+export const ListAgentTasksPartsDataPart$inboundSchema: z.ZodType<
+  ListAgentTasksPartsDataPart,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  kind: ListAgentTasksPartsAgentsResponse200Kind$inboundSchema,
-  tool_name: z.string(),
-  tool_call_id: z.string(),
-  arguments: z.record(z.any()),
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksArtifactsKind$inboundSchema,
+  data: z.record(z.any()),
   metadata: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "tool_name": "toolName",
-    "tool_call_id": "toolCallId",
-  });
 });
 /** @internal */
-export type ListAgentTasksParts4$Outbound = {
+export type ListAgentTasksPartsDataPart$Outbound = {
   kind: string;
-  tool_name: string;
-  tool_call_id: string;
-  arguments: { [k: string]: any };
+  data: { [k: string]: any };
   metadata?: { [k: string]: any } | undefined;
 };
 
 /** @internal */
-export const ListAgentTasksParts4$outboundSchema: z.ZodType<
-  ListAgentTasksParts4$Outbound,
+export const ListAgentTasksPartsDataPart$outboundSchema: z.ZodType<
+  ListAgentTasksPartsDataPart$Outbound,
   z.ZodTypeDef,
-  ListAgentTasksParts4
+  ListAgentTasksPartsDataPart
 > = z.object({
-  kind: ListAgentTasksPartsAgentsResponse200Kind$outboundSchema,
-  toolName: z.string(),
-  toolCallId: z.string(),
-  arguments: z.record(z.any()),
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksArtifactsKind$outboundSchema,
+  data: z.record(z.any()),
   metadata: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    toolName: "tool_name",
-    toolCallId: "tool_call_id",
-  });
 });
 
-export function listAgentTasksParts4ToJSON(
-  listAgentTasksParts4: ListAgentTasksParts4,
+export function listAgentTasksPartsDataPartToJSON(
+  listAgentTasksPartsDataPart: ListAgentTasksPartsDataPart,
 ): string {
   return JSON.stringify(
-    ListAgentTasksParts4$outboundSchema.parse(listAgentTasksParts4),
+    ListAgentTasksPartsDataPart$outboundSchema.parse(
+      listAgentTasksPartsDataPart,
+    ),
   );
 }
-export function listAgentTasksParts4FromJSON(
+export function listAgentTasksPartsDataPartFromJSON(
   jsonString: string,
-): SafeParseResult<ListAgentTasksParts4, SDKValidationError> {
+): SafeParseResult<ListAgentTasksPartsDataPart, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ListAgentTasksParts4$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentTasksParts4' from JSON`,
+    (x) => ListAgentTasksPartsDataPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksPartsDataPart' from JSON`,
   );
 }
 
 /** @internal */
-export const ListAgentTasksPartsAgentsResponseKind$inboundSchema:
-  z.ZodNativeEnum<typeof ListAgentTasksPartsAgentsResponseKind> = z.nativeEnum(
-    ListAgentTasksPartsAgentsResponseKind,
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksKind$inboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksKind
+  > = z.nativeEnum(
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksKind,
   );
 /** @internal */
-export const ListAgentTasksPartsAgentsResponseKind$outboundSchema:
-  z.ZodNativeEnum<typeof ListAgentTasksPartsAgentsResponseKind> =
-    ListAgentTasksPartsAgentsResponseKind$inboundSchema;
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksKind$outboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksKind
+  > =
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksKind$inboundSchema;
 
 /** @internal */
-export const ListAgentTasksFileFileInURIFormat$inboundSchema: z.ZodType<
-  ListAgentTasksFileFileInURIFormat,
+export const ListAgentTasksFileAgentsFileInURIFormat$inboundSchema: z.ZodType<
+  ListAgentTasksFileAgentsFileInURIFormat,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -548,45 +2132,52 @@ export const ListAgentTasksFileFileInURIFormat$inboundSchema: z.ZodType<
   name: z.string().optional(),
 });
 /** @internal */
-export type ListAgentTasksFileFileInURIFormat$Outbound = {
+export type ListAgentTasksFileAgentsFileInURIFormat$Outbound = {
   uri: string;
   mimeType?: string | undefined;
   name?: string | undefined;
 };
 
 /** @internal */
-export const ListAgentTasksFileFileInURIFormat$outboundSchema: z.ZodType<
-  ListAgentTasksFileFileInURIFormat$Outbound,
+export const ListAgentTasksFileAgentsFileInURIFormat$outboundSchema: z.ZodType<
+  ListAgentTasksFileAgentsFileInURIFormat$Outbound,
   z.ZodTypeDef,
-  ListAgentTasksFileFileInURIFormat
+  ListAgentTasksFileAgentsFileInURIFormat
 > = z.object({
   uri: z.string(),
   mimeType: z.string().optional(),
   name: z.string().optional(),
 });
 
-export function listAgentTasksFileFileInURIFormatToJSON(
-  listAgentTasksFileFileInURIFormat: ListAgentTasksFileFileInURIFormat,
+export function listAgentTasksFileAgentsFileInURIFormatToJSON(
+  listAgentTasksFileAgentsFileInURIFormat:
+    ListAgentTasksFileAgentsFileInURIFormat,
 ): string {
   return JSON.stringify(
-    ListAgentTasksFileFileInURIFormat$outboundSchema.parse(
-      listAgentTasksFileFileInURIFormat,
+    ListAgentTasksFileAgentsFileInURIFormat$outboundSchema.parse(
+      listAgentTasksFileAgentsFileInURIFormat,
     ),
   );
 }
-export function listAgentTasksFileFileInURIFormatFromJSON(
+export function listAgentTasksFileAgentsFileInURIFormatFromJSON(
   jsonString: string,
-): SafeParseResult<ListAgentTasksFileFileInURIFormat, SDKValidationError> {
+): SafeParseResult<
+  ListAgentTasksFileAgentsFileInURIFormat,
+  SDKValidationError
+> {
   return safeParse(
     jsonString,
-    (x) => ListAgentTasksFileFileInURIFormat$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentTasksFileFileInURIFormat' from JSON`,
+    (x) =>
+      ListAgentTasksFileAgentsFileInURIFormat$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ListAgentTasksFileAgentsFileInURIFormat' from JSON`,
   );
 }
 
 /** @internal */
-export const ListAgentTasksFileBinaryFormat$inboundSchema: z.ZodType<
-  ListAgentTasksFileBinaryFormat,
+export const ListAgentTasksFileAgentsBinaryFormat$inboundSchema: z.ZodType<
+  ListAgentTasksFileAgentsBinaryFormat,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -595,492 +2186,387 @@ export const ListAgentTasksFileBinaryFormat$inboundSchema: z.ZodType<
   name: z.string().optional(),
 });
 /** @internal */
-export type ListAgentTasksFileBinaryFormat$Outbound = {
+export type ListAgentTasksFileAgentsBinaryFormat$Outbound = {
   bytes: string;
   mimeType?: string | undefined;
   name?: string | undefined;
 };
 
 /** @internal */
-export const ListAgentTasksFileBinaryFormat$outboundSchema: z.ZodType<
-  ListAgentTasksFileBinaryFormat$Outbound,
+export const ListAgentTasksFileAgentsBinaryFormat$outboundSchema: z.ZodType<
+  ListAgentTasksFileAgentsBinaryFormat$Outbound,
   z.ZodTypeDef,
-  ListAgentTasksFileBinaryFormat
+  ListAgentTasksFileAgentsBinaryFormat
 > = z.object({
   bytes: z.string(),
   mimeType: z.string().optional(),
   name: z.string().optional(),
 });
 
-export function listAgentTasksFileBinaryFormatToJSON(
-  listAgentTasksFileBinaryFormat: ListAgentTasksFileBinaryFormat,
+export function listAgentTasksFileAgentsBinaryFormatToJSON(
+  listAgentTasksFileAgentsBinaryFormat: ListAgentTasksFileAgentsBinaryFormat,
 ): string {
   return JSON.stringify(
-    ListAgentTasksFileBinaryFormat$outboundSchema.parse(
-      listAgentTasksFileBinaryFormat,
+    ListAgentTasksFileAgentsBinaryFormat$outboundSchema.parse(
+      listAgentTasksFileAgentsBinaryFormat,
     ),
   );
 }
-export function listAgentTasksFileBinaryFormatFromJSON(
+export function listAgentTasksFileAgentsBinaryFormatFromJSON(
   jsonString: string,
-): SafeParseResult<ListAgentTasksFileBinaryFormat, SDKValidationError> {
+): SafeParseResult<ListAgentTasksFileAgentsBinaryFormat, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ListAgentTasksFileBinaryFormat$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentTasksFileBinaryFormat' from JSON`,
+    (x) =>
+      ListAgentTasksFileAgentsBinaryFormat$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksFileAgentsBinaryFormat' from JSON`,
   );
 }
 
 /** @internal */
-export const ListAgentTasksPartsFile$inboundSchema: z.ZodType<
-  ListAgentTasksPartsFile,
+export const ListAgentTasksPartsAgentsFile$inboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsFile,
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => ListAgentTasksFileBinaryFormat$inboundSchema),
-  z.lazy(() => ListAgentTasksFileFileInURIFormat$inboundSchema),
+  z.lazy(() => ListAgentTasksFileAgentsBinaryFormat$inboundSchema),
+  z.lazy(() => ListAgentTasksFileAgentsFileInURIFormat$inboundSchema),
 ]);
 /** @internal */
-export type ListAgentTasksPartsFile$Outbound =
-  | ListAgentTasksFileBinaryFormat$Outbound
-  | ListAgentTasksFileFileInURIFormat$Outbound;
+export type ListAgentTasksPartsAgentsFile$Outbound =
+  | ListAgentTasksFileAgentsBinaryFormat$Outbound
+  | ListAgentTasksFileAgentsFileInURIFormat$Outbound;
 
 /** @internal */
-export const ListAgentTasksPartsFile$outboundSchema: z.ZodType<
-  ListAgentTasksPartsFile$Outbound,
+export const ListAgentTasksPartsAgentsFile$outboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsFile$Outbound,
   z.ZodTypeDef,
-  ListAgentTasksPartsFile
+  ListAgentTasksPartsAgentsFile
 > = z.union([
-  z.lazy(() => ListAgentTasksFileBinaryFormat$outboundSchema),
-  z.lazy(() => ListAgentTasksFileFileInURIFormat$outboundSchema),
+  z.lazy(() => ListAgentTasksFileAgentsBinaryFormat$outboundSchema),
+  z.lazy(() => ListAgentTasksFileAgentsFileInURIFormat$outboundSchema),
 ]);
 
-export function listAgentTasksPartsFileToJSON(
-  listAgentTasksPartsFile: ListAgentTasksPartsFile,
+export function listAgentTasksPartsAgentsFileToJSON(
+  listAgentTasksPartsAgentsFile: ListAgentTasksPartsAgentsFile,
 ): string {
   return JSON.stringify(
-    ListAgentTasksPartsFile$outboundSchema.parse(listAgentTasksPartsFile),
+    ListAgentTasksPartsAgentsFile$outboundSchema.parse(
+      listAgentTasksPartsAgentsFile,
+    ),
   );
 }
-export function listAgentTasksPartsFileFromJSON(
+export function listAgentTasksPartsAgentsFileFromJSON(
   jsonString: string,
-): SafeParseResult<ListAgentTasksPartsFile, SDKValidationError> {
+): SafeParseResult<ListAgentTasksPartsAgentsFile, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ListAgentTasksPartsFile$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentTasksPartsFile' from JSON`,
+    (x) => ListAgentTasksPartsAgentsFile$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksPartsAgentsFile' from JSON`,
   );
 }
 
 /** @internal */
-export const ListAgentTasksParts3$inboundSchema: z.ZodType<
-  ListAgentTasksParts3,
+export const ListAgentTasksPartsAgentsFilePart$inboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsFilePart,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  kind: ListAgentTasksPartsAgentsResponseKind$inboundSchema,
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksKind$inboundSchema,
   file: z.union([
-    z.lazy(() => ListAgentTasksFileBinaryFormat$inboundSchema),
-    z.lazy(() => ListAgentTasksFileFileInURIFormat$inboundSchema),
+    z.lazy(() => ListAgentTasksFileAgentsBinaryFormat$inboundSchema),
+    z.lazy(() => ListAgentTasksFileAgentsFileInURIFormat$inboundSchema),
   ]),
   metadata: z.record(z.any()).optional(),
 });
 /** @internal */
-export type ListAgentTasksParts3$Outbound = {
+export type ListAgentTasksPartsAgentsFilePart$Outbound = {
   kind: string;
   file:
-    | ListAgentTasksFileBinaryFormat$Outbound
-    | ListAgentTasksFileFileInURIFormat$Outbound;
+    | ListAgentTasksFileAgentsBinaryFormat$Outbound
+    | ListAgentTasksFileAgentsFileInURIFormat$Outbound;
   metadata?: { [k: string]: any } | undefined;
 };
 
 /** @internal */
-export const ListAgentTasksParts3$outboundSchema: z.ZodType<
-  ListAgentTasksParts3$Outbound,
+export const ListAgentTasksPartsAgentsFilePart$outboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsFilePart$Outbound,
   z.ZodTypeDef,
-  ListAgentTasksParts3
+  ListAgentTasksPartsAgentsFilePart
 > = z.object({
-  kind: ListAgentTasksPartsAgentsResponseKind$outboundSchema,
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyTasksKind$outboundSchema,
   file: z.union([
-    z.lazy(() => ListAgentTasksFileBinaryFormat$outboundSchema),
-    z.lazy(() => ListAgentTasksFileFileInURIFormat$outboundSchema),
+    z.lazy(() => ListAgentTasksFileAgentsBinaryFormat$outboundSchema),
+    z.lazy(() => ListAgentTasksFileAgentsFileInURIFormat$outboundSchema),
   ]),
   metadata: z.record(z.any()).optional(),
 });
 
-export function listAgentTasksParts3ToJSON(
-  listAgentTasksParts3: ListAgentTasksParts3,
+export function listAgentTasksPartsAgentsFilePartToJSON(
+  listAgentTasksPartsAgentsFilePart: ListAgentTasksPartsAgentsFilePart,
 ): string {
   return JSON.stringify(
-    ListAgentTasksParts3$outboundSchema.parse(listAgentTasksParts3),
+    ListAgentTasksPartsAgentsFilePart$outboundSchema.parse(
+      listAgentTasksPartsAgentsFilePart,
+    ),
   );
 }
-export function listAgentTasksParts3FromJSON(
+export function listAgentTasksPartsAgentsFilePartFromJSON(
   jsonString: string,
-): SafeParseResult<ListAgentTasksParts3, SDKValidationError> {
+): SafeParseResult<ListAgentTasksPartsAgentsFilePart, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ListAgentTasksParts3$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentTasksParts3' from JSON`,
+    (x) => ListAgentTasksPartsAgentsFilePart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksPartsAgentsFilePart' from JSON`,
   );
 }
 
 /** @internal */
-export const ListAgentTasksPartsAgentsKind$inboundSchema: z.ZodNativeEnum<
-  typeof ListAgentTasksPartsAgentsKind
-> = z.nativeEnum(ListAgentTasksPartsAgentsKind);
-/** @internal */
-export const ListAgentTasksPartsAgentsKind$outboundSchema: z.ZodNativeEnum<
-  typeof ListAgentTasksPartsAgentsKind
-> = ListAgentTasksPartsAgentsKind$inboundSchema;
-
-/** @internal */
-export const ListAgentTasksParts2$inboundSchema: z.ZodType<
-  ListAgentTasksParts2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  kind: ListAgentTasksPartsAgentsKind$inboundSchema,
-  data: z.record(z.any()),
-  metadata: z.record(z.any()).optional(),
-});
-/** @internal */
-export type ListAgentTasksParts2$Outbound = {
-  kind: string;
-  data: { [k: string]: any };
-  metadata?: { [k: string]: any } | undefined;
-};
-
-/** @internal */
-export const ListAgentTasksParts2$outboundSchema: z.ZodType<
-  ListAgentTasksParts2$Outbound,
-  z.ZodTypeDef,
-  ListAgentTasksParts2
-> = z.object({
-  kind: ListAgentTasksPartsAgentsKind$outboundSchema,
-  data: z.record(z.any()),
-  metadata: z.record(z.any()).optional(),
-});
-
-export function listAgentTasksParts2ToJSON(
-  listAgentTasksParts2: ListAgentTasksParts2,
-): string {
-  return JSON.stringify(
-    ListAgentTasksParts2$outboundSchema.parse(listAgentTasksParts2),
-  );
-}
-export function listAgentTasksParts2FromJSON(
-  jsonString: string,
-): SafeParseResult<ListAgentTasksParts2, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ListAgentTasksParts2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentTasksParts2' from JSON`,
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyKind$inboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyKind
+  > = z.nativeEnum(
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyKind,
   );
-}
-
-/** @internal */
-export const ListAgentTasksPartsKind$inboundSchema: z.ZodNativeEnum<
-  typeof ListAgentTasksPartsKind
-> = z.nativeEnum(ListAgentTasksPartsKind);
 /** @internal */
-export const ListAgentTasksPartsKind$outboundSchema: z.ZodNativeEnum<
-  typeof ListAgentTasksPartsKind
-> = ListAgentTasksPartsKind$inboundSchema;
+export const ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyKind$outboundSchema:
+  z.ZodNativeEnum<
+    typeof ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyKind
+  > =
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyKind$inboundSchema;
 
 /** @internal */
-export const ListAgentTasksParts1$inboundSchema: z.ZodType<
-  ListAgentTasksParts1,
+export const ListAgentTasksPartsAgentsTextPart$inboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsTextPart,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  kind: ListAgentTasksPartsKind$inboundSchema,
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyKind$inboundSchema,
   text: z.string(),
 });
 /** @internal */
-export type ListAgentTasksParts1$Outbound = {
+export type ListAgentTasksPartsAgentsTextPart$Outbound = {
   kind: string;
   text: string;
 };
 
 /** @internal */
-export const ListAgentTasksParts1$outboundSchema: z.ZodType<
-  ListAgentTasksParts1$Outbound,
+export const ListAgentTasksPartsAgentsTextPart$outboundSchema: z.ZodType<
+  ListAgentTasksPartsAgentsTextPart$Outbound,
   z.ZodTypeDef,
-  ListAgentTasksParts1
+  ListAgentTasksPartsAgentsTextPart
 > = z.object({
-  kind: ListAgentTasksPartsKind$outboundSchema,
+  kind:
+    ListAgentTasksPartsAgentsResponse200ApplicationJSONResponseBodyKind$outboundSchema,
   text: z.string(),
 });
 
-export function listAgentTasksParts1ToJSON(
-  listAgentTasksParts1: ListAgentTasksParts1,
+export function listAgentTasksPartsAgentsTextPartToJSON(
+  listAgentTasksPartsAgentsTextPart: ListAgentTasksPartsAgentsTextPart,
 ): string {
   return JSON.stringify(
-    ListAgentTasksParts1$outboundSchema.parse(listAgentTasksParts1),
+    ListAgentTasksPartsAgentsTextPart$outboundSchema.parse(
+      listAgentTasksPartsAgentsTextPart,
+    ),
   );
 }
-export function listAgentTasksParts1FromJSON(
+export function listAgentTasksPartsAgentsTextPartFromJSON(
   jsonString: string,
-): SafeParseResult<ListAgentTasksParts1, SDKValidationError> {
+): SafeParseResult<ListAgentTasksPartsAgentsTextPart, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ListAgentTasksParts1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentTasksParts1' from JSON`,
+    (x) => ListAgentTasksPartsAgentsTextPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksPartsAgentsTextPart' from JSON`,
   );
 }
 
 /** @internal */
-export const ListAgentTasksParts$inboundSchema: z.ZodType<
-  ListAgentTasksParts,
+export const ListAgentTasksAgentsParts$inboundSchema: z.ZodType<
+  ListAgentTasksAgentsParts,
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => ListAgentTasksParts4$inboundSchema),
-  z.lazy(() => ListAgentTasksParts1$inboundSchema),
-  z.lazy(() => ListAgentTasksParts2$inboundSchema),
-  z.lazy(() => ListAgentTasksParts3$inboundSchema),
-  z.lazy(() => ListAgentTasksParts5$inboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsTextPart$inboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsFilePart$inboundSchema),
+  z.lazy(() => ListAgentTasksPartsDataPart$inboundSchema),
 ]);
 /** @internal */
-export type ListAgentTasksParts$Outbound =
-  | ListAgentTasksParts4$Outbound
-  | ListAgentTasksParts1$Outbound
-  | ListAgentTasksParts2$Outbound
-  | ListAgentTasksParts3$Outbound
-  | ListAgentTasksParts5$Outbound;
+export type ListAgentTasksAgentsParts$Outbound =
+  | ListAgentTasksPartsAgentsTextPart$Outbound
+  | ListAgentTasksPartsAgentsFilePart$Outbound
+  | ListAgentTasksPartsDataPart$Outbound;
 
 /** @internal */
-export const ListAgentTasksParts$outboundSchema: z.ZodType<
-  ListAgentTasksParts$Outbound,
+export const ListAgentTasksAgentsParts$outboundSchema: z.ZodType<
+  ListAgentTasksAgentsParts$Outbound,
   z.ZodTypeDef,
-  ListAgentTasksParts
+  ListAgentTasksAgentsParts
 > = z.union([
-  z.lazy(() => ListAgentTasksParts4$outboundSchema),
-  z.lazy(() => ListAgentTasksParts1$outboundSchema),
-  z.lazy(() => ListAgentTasksParts2$outboundSchema),
-  z.lazy(() => ListAgentTasksParts3$outboundSchema),
-  z.lazy(() => ListAgentTasksParts5$outboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsTextPart$outboundSchema),
+  z.lazy(() => ListAgentTasksPartsAgentsFilePart$outboundSchema),
+  z.lazy(() => ListAgentTasksPartsDataPart$outboundSchema),
 ]);
 
-export function listAgentTasksPartsToJSON(
-  listAgentTasksParts: ListAgentTasksParts,
+export function listAgentTasksAgentsPartsToJSON(
+  listAgentTasksAgentsParts: ListAgentTasksAgentsParts,
 ): string {
   return JSON.stringify(
-    ListAgentTasksParts$outboundSchema.parse(listAgentTasksParts),
+    ListAgentTasksAgentsParts$outboundSchema.parse(listAgentTasksAgentsParts),
   );
 }
-export function listAgentTasksPartsFromJSON(
+export function listAgentTasksAgentsPartsFromJSON(
   jsonString: string,
-): SafeParseResult<ListAgentTasksParts, SDKValidationError> {
+): SafeParseResult<ListAgentTasksAgentsParts, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ListAgentTasksParts$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentTasksParts' from JSON`,
+    (x) => ListAgentTasksAgentsParts$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksAgentsParts' from JSON`,
   );
 }
 
 /** @internal */
-export const ListAgentTasksHistory$inboundSchema: z.ZodType<
-  ListAgentTasksHistory,
+export const ListAgentTasksTaskArtifact$inboundSchema: z.ZodType<
+  ListAgentTasksTaskArtifact,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  kind: ListAgentTasksAgentsKind$inboundSchema,
-  messageId: z.string(),
-  role: ListAgentTasksRole$inboundSchema,
+  artifactId: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
   parts: z.array(
     z.union([
-      z.lazy(() => ListAgentTasksParts4$inboundSchema),
-      z.lazy(() => ListAgentTasksParts1$inboundSchema),
-      z.lazy(() => ListAgentTasksParts2$inboundSchema),
-      z.lazy(() => ListAgentTasksParts3$inboundSchema),
-      z.lazy(() => ListAgentTasksParts5$inboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsTextPart$inboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsFilePart$inboundSchema),
+      z.lazy(() => ListAgentTasksPartsDataPart$inboundSchema),
     ]),
   ),
-  taskId: z.string().optional(),
-  contextId: z.string().optional(),
+  extensions: z.array(z.string()).optional(),
   metadata: z.record(z.any()).optional(),
 });
 /** @internal */
-export type ListAgentTasksHistory$Outbound = {
-  kind: string;
-  messageId: string;
-  role: string;
+export type ListAgentTasksTaskArtifact$Outbound = {
+  artifactId: string;
+  name: string;
+  description?: string | undefined;
   parts: Array<
-    | ListAgentTasksParts4$Outbound
-    | ListAgentTasksParts1$Outbound
-    | ListAgentTasksParts2$Outbound
-    | ListAgentTasksParts3$Outbound
-    | ListAgentTasksParts5$Outbound
+    | ListAgentTasksPartsAgentsTextPart$Outbound
+    | ListAgentTasksPartsAgentsFilePart$Outbound
+    | ListAgentTasksPartsDataPart$Outbound
   >;
-  taskId?: string | undefined;
-  contextId?: string | undefined;
+  extensions?: Array<string> | undefined;
   metadata?: { [k: string]: any } | undefined;
 };
 
 /** @internal */
-export const ListAgentTasksHistory$outboundSchema: z.ZodType<
-  ListAgentTasksHistory$Outbound,
+export const ListAgentTasksTaskArtifact$outboundSchema: z.ZodType<
+  ListAgentTasksTaskArtifact$Outbound,
   z.ZodTypeDef,
-  ListAgentTasksHistory
+  ListAgentTasksTaskArtifact
 > = z.object({
-  kind: ListAgentTasksAgentsKind$outboundSchema,
-  messageId: z.string(),
-  role: ListAgentTasksRole$outboundSchema,
+  artifactId: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
   parts: z.array(
     z.union([
-      z.lazy(() => ListAgentTasksParts4$outboundSchema),
-      z.lazy(() => ListAgentTasksParts1$outboundSchema),
-      z.lazy(() => ListAgentTasksParts2$outboundSchema),
-      z.lazy(() => ListAgentTasksParts3$outboundSchema),
-      z.lazy(() => ListAgentTasksParts5$outboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsTextPart$outboundSchema),
+      z.lazy(() => ListAgentTasksPartsAgentsFilePart$outboundSchema),
+      z.lazy(() => ListAgentTasksPartsDataPart$outboundSchema),
     ]),
   ),
-  taskId: z.string().optional(),
-  contextId: z.string().optional(),
+  extensions: z.array(z.string()).optional(),
   metadata: z.record(z.any()).optional(),
 });
 
-export function listAgentTasksHistoryToJSON(
-  listAgentTasksHistory: ListAgentTasksHistory,
+export function listAgentTasksTaskArtifactToJSON(
+  listAgentTasksTaskArtifact: ListAgentTasksTaskArtifact,
 ): string {
   return JSON.stringify(
-    ListAgentTasksHistory$outboundSchema.parse(listAgentTasksHistory),
+    ListAgentTasksTaskArtifact$outboundSchema.parse(listAgentTasksTaskArtifact),
   );
 }
-export function listAgentTasksHistoryFromJSON(
+export function listAgentTasksTaskArtifactFromJSON(
   jsonString: string,
-): SafeParseResult<ListAgentTasksHistory, SDKValidationError> {
+): SafeParseResult<ListAgentTasksTaskArtifact, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ListAgentTasksHistory$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentTasksHistory' from JSON`,
+    (x) => ListAgentTasksTaskArtifact$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksTaskArtifact' from JSON`,
   );
 }
 
 /** @internal */
-export const ListAgentTasksAgentsResponseKind$inboundSchema: z.ZodNativeEnum<
-  typeof ListAgentTasksAgentsResponseKind
-> = z.nativeEnum(ListAgentTasksAgentsResponseKind);
-/** @internal */
-export const ListAgentTasksAgentsResponseKind$outboundSchema: z.ZodNativeEnum<
-  typeof ListAgentTasksAgentsResponseKind
-> = ListAgentTasksAgentsResponseKind$inboundSchema;
-
-/** @internal */
-export const ListAgentTasksArtifacts$inboundSchema: z.ZodType<
-  ListAgentTasksArtifacts,
+export const ExtendedTaskResponse$inboundSchema: z.ZodType<
+  ExtendedTaskResponse,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  kind: ListAgentTasksAgentsResponseKind$inboundSchema,
-  artifactId: z.string(),
-  name: z.string(),
-  type: z.string(),
-  url: z.string().optional(),
-  data: z.any().optional(),
-});
-/** @internal */
-export type ListAgentTasksArtifacts$Outbound = {
-  kind: string;
-  artifactId: string;
-  name: string;
-  type: string;
-  url?: string | undefined;
-  data?: any | undefined;
-};
-
-/** @internal */
-export const ListAgentTasksArtifacts$outboundSchema: z.ZodType<
-  ListAgentTasksArtifacts$Outbound,
-  z.ZodTypeDef,
-  ListAgentTasksArtifacts
-> = z.object({
-  kind: ListAgentTasksAgentsResponseKind$outboundSchema,
-  artifactId: z.string(),
-  name: z.string(),
-  type: z.string(),
-  url: z.string().optional(),
-  data: z.any().optional(),
+  id: z.string(),
+  contextId: z.string(),
+  kind: ListAgentTasksKind$inboundSchema,
+  status: z.lazy(() => ListAgentTasksTaskStatus$inboundSchema),
+  history: z.array(
+    z.lazy(() => ListAgentTasksExtendedA2AMessage$inboundSchema),
+  ),
+  artifacts: z.array(z.lazy(() => ListAgentTasksTaskArtifact$inboundSchema))
+    .optional(),
+  metadata: z.record(z.any()).optional(),
 });
-
-export function listAgentTasksArtifactsToJSON(
-  listAgentTasksArtifacts: ListAgentTasksArtifacts,
-): string {
-  return JSON.stringify(
-    ListAgentTasksArtifacts$outboundSchema.parse(listAgentTasksArtifacts),
-  );
-}
-export function listAgentTasksArtifactsFromJSON(
-  jsonString: string,
-): SafeParseResult<ListAgentTasksArtifacts, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ListAgentTasksArtifacts$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentTasksArtifacts' from JSON`,
-  );
-}
-
 /** @internal */
-export const Tasks$inboundSchema: z.ZodType<Tasks, z.ZodTypeDef, unknown> = z
-  .object({
-    id: z.string(),
-    contextId: z.string(),
-    kind: ListAgentTasksKind$inboundSchema,
-    status: z.lazy(() => ListAgentTasksStatus$inboundSchema),
-    history: z.array(z.lazy(() => ListAgentTasksHistory$inboundSchema)),
-    artifacts: z.array(z.lazy(() => ListAgentTasksArtifacts$inboundSchema))
-      .optional(),
-    metadata: z.record(z.any()).optional(),
-  });
-/** @internal */
-export type Tasks$Outbound = {
+export type ExtendedTaskResponse$Outbound = {
   id: string;
   contextId: string;
   kind: string;
-  status: ListAgentTasksStatus$Outbound;
-  history: Array<ListAgentTasksHistory$Outbound>;
-  artifacts?: Array<ListAgentTasksArtifacts$Outbound> | undefined;
+  status: ListAgentTasksTaskStatus$Outbound;
+  history: Array<ListAgentTasksExtendedA2AMessage$Outbound>;
+  artifacts?: Array<ListAgentTasksTaskArtifact$Outbound> | undefined;
   metadata?: { [k: string]: any } | undefined;
 };
 
 /** @internal */
-export const Tasks$outboundSchema: z.ZodType<
-  Tasks$Outbound,
+export const ExtendedTaskResponse$outboundSchema: z.ZodType<
+  ExtendedTaskResponse$Outbound,
   z.ZodTypeDef,
-  Tasks
+  ExtendedTaskResponse
 > = z.object({
   id: z.string(),
   contextId: z.string(),
   kind: ListAgentTasksKind$outboundSchema,
-  status: z.lazy(() => ListAgentTasksStatus$outboundSchema),
-  history: z.array(z.lazy(() => ListAgentTasksHistory$outboundSchema)),
-  artifacts: z.array(z.lazy(() => ListAgentTasksArtifacts$outboundSchema))
+  status: z.lazy(() => ListAgentTasksTaskStatus$outboundSchema),
+  history: z.array(
+    z.lazy(() => ListAgentTasksExtendedA2AMessage$outboundSchema),
+  ),
+  artifacts: z.array(z.lazy(() => ListAgentTasksTaskArtifact$outboundSchema))
     .optional(),
   metadata: z.record(z.any()).optional(),
 });
 
-export function tasksToJSON(tasks: Tasks): string {
-  return JSON.stringify(Tasks$outboundSchema.parse(tasks));
+export function extendedTaskResponseToJSON(
+  extendedTaskResponse: ExtendedTaskResponse,
+): string {
+  return JSON.stringify(
+    ExtendedTaskResponse$outboundSchema.parse(extendedTaskResponse),
+  );
 }
-export function tasksFromJSON(
+export function extendedTaskResponseFromJSON(
   jsonString: string,
-): SafeParseResult<Tasks, SDKValidationError> {
+): SafeParseResult<ExtendedTaskResponse, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Tasks$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Tasks' from JSON`,
+    (x) => ExtendedTaskResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExtendedTaskResponse' from JSON`,
   );
 }
 
 /** @internal */
-export const ListAgentTasksResponseBody$inboundSchema: z.ZodType<
-  ListAgentTasksResponseBody,
+export const ListAgentTasksAgentTasksListResponse$inboundSchema: z.ZodType<
+  ListAgentTasksAgentTasksListResponse,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  tasks: z.array(z.lazy(() => Tasks$inboundSchema)),
+  tasks: z.array(z.lazy(() => ExtendedTaskResponse$inboundSchema)),
   overall_total: z.number(),
 }).transform((v) => {
   return remap$(v, {
@@ -1088,18 +2574,18 @@ export const ListAgentTasksResponseBody$inboundSchema: z.ZodType<
   });
 });
 /** @internal */
-export type ListAgentTasksResponseBody$Outbound = {
-  tasks: Array<Tasks$Outbound>;
+export type ListAgentTasksAgentTasksListResponse$Outbound = {
+  tasks: Array<ExtendedTaskResponse$Outbound>;
   overall_total: number;
 };
 
 /** @internal */
-export const ListAgentTasksResponseBody$outboundSchema: z.ZodType<
-  ListAgentTasksResponseBody$Outbound,
+export const ListAgentTasksAgentTasksListResponse$outboundSchema: z.ZodType<
+  ListAgentTasksAgentTasksListResponse$Outbound,
   z.ZodTypeDef,
-  ListAgentTasksResponseBody
+  ListAgentTasksAgentTasksListResponse
 > = z.object({
-  tasks: z.array(z.lazy(() => Tasks$outboundSchema)),
+  tasks: z.array(z.lazy(() => ExtendedTaskResponse$outboundSchema)),
   overallTotal: z.number(),
 }).transform((v) => {
   return remap$(v, {
@@ -1107,19 +2593,22 @@ export const ListAgentTasksResponseBody$outboundSchema: z.ZodType<
   });
 });
 
-export function listAgentTasksResponseBodyToJSON(
-  listAgentTasksResponseBody: ListAgentTasksResponseBody,
+export function listAgentTasksAgentTasksListResponseToJSON(
+  listAgentTasksAgentTasksListResponse: ListAgentTasksAgentTasksListResponse,
 ): string {
   return JSON.stringify(
-    ListAgentTasksResponseBody$outboundSchema.parse(listAgentTasksResponseBody),
+    ListAgentTasksAgentTasksListResponse$outboundSchema.parse(
+      listAgentTasksAgentTasksListResponse,
+    ),
   );
 }
-export function listAgentTasksResponseBodyFromJSON(
+export function listAgentTasksAgentTasksListResponseFromJSON(
   jsonString: string,
-): SafeParseResult<ListAgentTasksResponseBody, SDKValidationError> {
+): SafeParseResult<ListAgentTasksAgentTasksListResponse, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ListAgentTasksResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAgentTasksResponseBody' from JSON`,
+    (x) =>
+      ListAgentTasksAgentTasksListResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentTasksAgentTasksListResponse' from JSON`,
   );
 }