@orq-ai/node 4.0.0-rc.20 → 4.0.0-rc.21

package/src/models/operations/getagenttask.ts

@@ -25,6 +25,159 @@ export type GetAgentTaskStatus = {
   message?: any | undefined;
 };
 
+export const GetAgentTaskAgentsResponseKind = {
+  Message: "message",
+} as const;
+export type GetAgentTaskAgentsResponseKind = ClosedEnum<
+  typeof GetAgentTaskAgentsResponseKind
+>;
+
+/**
+ * Extended A2A message role
+ */
+export const GetAgentTaskRole = {
+  User: "user",
+  Agent: "agent",
+  Tool: "tool",
+  System: "system",
+} as const;
+/**
+ * Extended A2A message role
+ */
+export type GetAgentTaskRole = ClosedEnum<typeof GetAgentTaskRole>;
+
+export const GetAgentTaskPartsAgentsResponse200Kind = {
+  ToolResult: "tool_result",
+} as const;
+export type GetAgentTaskPartsAgentsResponse200Kind = ClosedEnum<
+  typeof GetAgentTaskPartsAgentsResponse200Kind
+>;
+
+export type Parts5 = {
+  kind: GetAgentTaskPartsAgentsResponse200Kind;
+  toolCallId: string;
+  result?: any | undefined;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+export const GetAgentTaskPartsAgentsResponseKind = {
+  ToolCall: "tool_call",
+} as const;
+export type GetAgentTaskPartsAgentsResponseKind = ClosedEnum<
+  typeof GetAgentTaskPartsAgentsResponseKind
+>;
+
+export type Parts4 = {
+  kind: GetAgentTaskPartsAgentsResponseKind;
+  toolName: string;
+  toolCallId: string;
+  arguments: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+export const GetAgentTaskPartsAgentsKind = {
+  File: "file",
+} as const;
+export type GetAgentTaskPartsAgentsKind = ClosedEnum<
+  typeof GetAgentTaskPartsAgentsKind
+>;
+
+/**
+ * File in URI format. Check in the model's documentation for the supported mime types for the URI format
+ */
+export type GetAgentTaskFileFileInURIFormat = {
+  /**
+   * URL for the File content
+   */
+  uri: string;
+  /**
+   * Optional mimeType for the file
+   */
+  mimeType?: string | undefined;
+  /**
+   * Optional name for the file
+   */
+  name?: string | undefined;
+};
+
+/**
+ * Binary in base64 format. Check in the model's documentation for the supported mime types for the binary format.
+ */
+export type GetAgentTaskFileBinaryFormat = {
+  /**
+   * base64 encoded content of the file
+   */
+  bytes: string;
+  /**
+   * Optional mimeType for the file
+   */
+  mimeType?: string | undefined;
+  /**
+   * Optional name for the file
+   */
+  name?: string | undefined;
+};
+
+export type PartsFile =
+  | GetAgentTaskFileBinaryFormat
+  | GetAgentTaskFileFileInURIFormat;
+
+export type Parts3 = {
+  kind: GetAgentTaskPartsAgentsKind;
+  file: GetAgentTaskFileBinaryFormat | GetAgentTaskFileFileInURIFormat;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+export const GetAgentTaskPartsKind = {
+  Data: "data",
+} as const;
+export type GetAgentTaskPartsKind = ClosedEnum<typeof GetAgentTaskPartsKind>;
+
+export type Parts2 = {
+  kind: GetAgentTaskPartsKind;
+  data: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+export const PartsKind = {
+  Text: "text",
+} as const;
+export type PartsKind = ClosedEnum<typeof PartsKind>;
+
+export type Parts1 = {
+  kind: PartsKind;
+  text: string;
+};
+
+export type Parts = Parts4 | Parts1 | Parts2 | Parts3 | Parts5;
+
+export type History = {
+  kind: GetAgentTaskAgentsResponseKind;
+  messageId: string;
+  /**
+   * Extended A2A message role
+   */
+  role: GetAgentTaskRole;
+  parts: Array<Parts4 | Parts1 | Parts2 | Parts3 | Parts5>;
+  taskId?: string | undefined;
+  contextId?: string | undefined;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+export const GetAgentTaskAgentsKind = {
+  Artifact: "artifact",
+} as const;
+export type GetAgentTaskAgentsKind = ClosedEnum<typeof GetAgentTaskAgentsKind>;
+
+export type Artifacts = {
+  kind: GetAgentTaskAgentsKind;
+  artifactId: string;
+  name: string;
+  type: string;
+  url?: string | undefined;
+  data?: any | undefined;
+};
+
 /**
  * Agent task retrieved
  */
@@ -33,8 +186,8 @@ export type GetAgentTaskResponseBody = {
   contextId: string;
   kind: GetAgentTaskKind;
   status: GetAgentTaskStatus;
-  history: Array<any>;
-  artifacts?: Array<any> | undefined;
+  history: Array<History>;
+  artifacts?: Array<Artifacts> | undefined;
   metadata?: { [k: string]: any } | undefined;
 };
 
@@ -144,6 +297,595 @@ export function getAgentTaskStatusFromJSON(
   );
 }
 
+/** @internal */
+export const GetAgentTaskAgentsResponseKind$inboundSchema: z.ZodNativeEnum<
+  typeof GetAgentTaskAgentsResponseKind
+> = z.nativeEnum(GetAgentTaskAgentsResponseKind);
+/** @internal */
+export const GetAgentTaskAgentsResponseKind$outboundSchema: z.ZodNativeEnum<
+  typeof GetAgentTaskAgentsResponseKind
+> = GetAgentTaskAgentsResponseKind$inboundSchema;
+
+/** @internal */
+export const GetAgentTaskRole$inboundSchema: z.ZodNativeEnum<
+  typeof GetAgentTaskRole
+> = z.nativeEnum(GetAgentTaskRole);
+/** @internal */
+export const GetAgentTaskRole$outboundSchema: z.ZodNativeEnum<
+  typeof GetAgentTaskRole
+> = GetAgentTaskRole$inboundSchema;
+
+/** @internal */
+export const GetAgentTaskPartsAgentsResponse200Kind$inboundSchema:
+  z.ZodNativeEnum<typeof GetAgentTaskPartsAgentsResponse200Kind> = z.nativeEnum(
+    GetAgentTaskPartsAgentsResponse200Kind,
+  );
+/** @internal */
+export const GetAgentTaskPartsAgentsResponse200Kind$outboundSchema:
+  z.ZodNativeEnum<typeof GetAgentTaskPartsAgentsResponse200Kind> =
+    GetAgentTaskPartsAgentsResponse200Kind$inboundSchema;
+
+/** @internal */
+export const Parts5$inboundSchema: z.ZodType<Parts5, z.ZodTypeDef, unknown> = z
+  .object({
+    kind: GetAgentTaskPartsAgentsResponse200Kind$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 Parts5$Outbound = {
+  kind: string;
+  tool_call_id: string;
+  result?: any | undefined;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const Parts5$outboundSchema: z.ZodType<
+  Parts5$Outbound,
+  z.ZodTypeDef,
+  Parts5
+> = z.object({
+  kind: GetAgentTaskPartsAgentsResponse200Kind$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 parts5ToJSON(parts5: Parts5): string {
+  return JSON.stringify(Parts5$outboundSchema.parse(parts5));
+}
+export function parts5FromJSON(
+  jsonString: string,
+): SafeParseResult<Parts5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Parts5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Parts5' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetAgentTaskPartsAgentsResponseKind$inboundSchema: z.ZodNativeEnum<
+  typeof GetAgentTaskPartsAgentsResponseKind
+> = z.nativeEnum(GetAgentTaskPartsAgentsResponseKind);
+/** @internal */
+export const GetAgentTaskPartsAgentsResponseKind$outboundSchema:
+  z.ZodNativeEnum<typeof GetAgentTaskPartsAgentsResponseKind> =
+    GetAgentTaskPartsAgentsResponseKind$inboundSchema;
+
+/** @internal */
+export const Parts4$inboundSchema: z.ZodType<Parts4, z.ZodTypeDef, unknown> = z
+  .object({
+    kind: GetAgentTaskPartsAgentsResponseKind$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 Parts4$Outbound = {
+  kind: string;
+  tool_name: string;
+  tool_call_id: string;
+  arguments: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const Parts4$outboundSchema: z.ZodType<
+  Parts4$Outbound,
+  z.ZodTypeDef,
+  Parts4
+> = z.object({
+  kind: GetAgentTaskPartsAgentsResponseKind$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 parts4ToJSON(parts4: Parts4): string {
+  return JSON.stringify(Parts4$outboundSchema.parse(parts4));
+}
+export function parts4FromJSON(
+  jsonString: string,
+): SafeParseResult<Parts4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Parts4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Parts4' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetAgentTaskPartsAgentsKind$inboundSchema: z.ZodNativeEnum<
+  typeof GetAgentTaskPartsAgentsKind
+> = z.nativeEnum(GetAgentTaskPartsAgentsKind);
+/** @internal */
+export const GetAgentTaskPartsAgentsKind$outboundSchema: z.ZodNativeEnum<
+  typeof GetAgentTaskPartsAgentsKind
+> = GetAgentTaskPartsAgentsKind$inboundSchema;
+
+/** @internal */
+export const GetAgentTaskFileFileInURIFormat$inboundSchema: z.ZodType<
+  GetAgentTaskFileFileInURIFormat,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  uri: z.string(),
+  mimeType: z.string().optional(),
+  name: z.string().optional(),
+});
+/** @internal */
+export type GetAgentTaskFileFileInURIFormat$Outbound = {
+  uri: string;
+  mimeType?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const GetAgentTaskFileFileInURIFormat$outboundSchema: z.ZodType<
+  GetAgentTaskFileFileInURIFormat$Outbound,
+  z.ZodTypeDef,
+  GetAgentTaskFileFileInURIFormat
+> = z.object({
+  uri: z.string(),
+  mimeType: z.string().optional(),
+  name: z.string().optional(),
+});
+
+export function getAgentTaskFileFileInURIFormatToJSON(
+  getAgentTaskFileFileInURIFormat: GetAgentTaskFileFileInURIFormat,
+): string {
+  return JSON.stringify(
+    GetAgentTaskFileFileInURIFormat$outboundSchema.parse(
+      getAgentTaskFileFileInURIFormat,
+    ),
+  );
+}
+export function getAgentTaskFileFileInURIFormatFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAgentTaskFileFileInURIFormat, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAgentTaskFileFileInURIFormat$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAgentTaskFileFileInURIFormat' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetAgentTaskFileBinaryFormat$inboundSchema: z.ZodType<
+  GetAgentTaskFileBinaryFormat,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  bytes: z.string(),
+  mimeType: z.string().optional(),
+  name: z.string().optional(),
+});
+/** @internal */
+export type GetAgentTaskFileBinaryFormat$Outbound = {
+  bytes: string;
+  mimeType?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const GetAgentTaskFileBinaryFormat$outboundSchema: z.ZodType<
+  GetAgentTaskFileBinaryFormat$Outbound,
+  z.ZodTypeDef,
+  GetAgentTaskFileBinaryFormat
+> = z.object({
+  bytes: z.string(),
+  mimeType: z.string().optional(),
+  name: z.string().optional(),
+});
+
+export function getAgentTaskFileBinaryFormatToJSON(
+  getAgentTaskFileBinaryFormat: GetAgentTaskFileBinaryFormat,
+): string {
+  return JSON.stringify(
+    GetAgentTaskFileBinaryFormat$outboundSchema.parse(
+      getAgentTaskFileBinaryFormat,
+    ),
+  );
+}
+export function getAgentTaskFileBinaryFormatFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAgentTaskFileBinaryFormat, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAgentTaskFileBinaryFormat$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAgentTaskFileBinaryFormat' from JSON`,
+  );
+}
+
+/** @internal */
+export const PartsFile$inboundSchema: z.ZodType<
+  PartsFile,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => GetAgentTaskFileBinaryFormat$inboundSchema),
+  z.lazy(() => GetAgentTaskFileFileInURIFormat$inboundSchema),
+]);
+/** @internal */
+export type PartsFile$Outbound =
+  | GetAgentTaskFileBinaryFormat$Outbound
+  | GetAgentTaskFileFileInURIFormat$Outbound;
+
+/** @internal */
+export const PartsFile$outboundSchema: z.ZodType<
+  PartsFile$Outbound,
+  z.ZodTypeDef,
+  PartsFile
+> = z.union([
+  z.lazy(() => GetAgentTaskFileBinaryFormat$outboundSchema),
+  z.lazy(() => GetAgentTaskFileFileInURIFormat$outboundSchema),
+]);
+
+export function partsFileToJSON(partsFile: PartsFile): string {
+  return JSON.stringify(PartsFile$outboundSchema.parse(partsFile));
+}
+export function partsFileFromJSON(
+  jsonString: string,
+): SafeParseResult<PartsFile, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PartsFile$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PartsFile' from JSON`,
+  );
+}
+
+/** @internal */
+export const Parts3$inboundSchema: z.ZodType<Parts3, z.ZodTypeDef, unknown> = z
+  .object({
+    kind: GetAgentTaskPartsAgentsKind$inboundSchema,
+    file: z.union([
+      z.lazy(() => GetAgentTaskFileBinaryFormat$inboundSchema),
+      z.lazy(() => GetAgentTaskFileFileInURIFormat$inboundSchema),
+    ]),
+    metadata: z.record(z.any()).optional(),
+  });
+/** @internal */
+export type Parts3$Outbound = {
+  kind: string;
+  file:
+    | GetAgentTaskFileBinaryFormat$Outbound
+    | GetAgentTaskFileFileInURIFormat$Outbound;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const Parts3$outboundSchema: z.ZodType<
+  Parts3$Outbound,
+  z.ZodTypeDef,
+  Parts3
+> = z.object({
+  kind: GetAgentTaskPartsAgentsKind$outboundSchema,
+  file: z.union([
+    z.lazy(() => GetAgentTaskFileBinaryFormat$outboundSchema),
+    z.lazy(() => GetAgentTaskFileFileInURIFormat$outboundSchema),
+  ]),
+  metadata: z.record(z.any()).optional(),
+});
+
+export function parts3ToJSON(parts3: Parts3): string {
+  return JSON.stringify(Parts3$outboundSchema.parse(parts3));
+}
+export function parts3FromJSON(
+  jsonString: string,
+): SafeParseResult<Parts3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Parts3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Parts3' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetAgentTaskPartsKind$inboundSchema: z.ZodNativeEnum<
+  typeof GetAgentTaskPartsKind
+> = z.nativeEnum(GetAgentTaskPartsKind);
+/** @internal */
+export const GetAgentTaskPartsKind$outboundSchema: z.ZodNativeEnum<
+  typeof GetAgentTaskPartsKind
+> = GetAgentTaskPartsKind$inboundSchema;
+
+/** @internal */
+export const Parts2$inboundSchema: z.ZodType<Parts2, z.ZodTypeDef, unknown> = z
+  .object({
+    kind: GetAgentTaskPartsKind$inboundSchema,
+    data: z.record(z.any()),
+    metadata: z.record(z.any()).optional(),
+  });
+/** @internal */
+export type Parts2$Outbound = {
+  kind: string;
+  data: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const Parts2$outboundSchema: z.ZodType<
+  Parts2$Outbound,
+  z.ZodTypeDef,
+  Parts2
+> = z.object({
+  kind: GetAgentTaskPartsKind$outboundSchema,
+  data: z.record(z.any()),
+  metadata: z.record(z.any()).optional(),
+});
+
+export function parts2ToJSON(parts2: Parts2): string {
+  return JSON.stringify(Parts2$outboundSchema.parse(parts2));
+}
+export function parts2FromJSON(
+  jsonString: string,
+): SafeParseResult<Parts2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Parts2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Parts2' from JSON`,
+  );
+}
+
+/** @internal */
+export const PartsKind$inboundSchema: z.ZodNativeEnum<typeof PartsKind> = z
+  .nativeEnum(PartsKind);
+/** @internal */
+export const PartsKind$outboundSchema: z.ZodNativeEnum<typeof PartsKind> =
+  PartsKind$inboundSchema;
+
+/** @internal */
+export const Parts1$inboundSchema: z.ZodType<Parts1, z.ZodTypeDef, unknown> = z
+  .object({
+    kind: PartsKind$inboundSchema,
+    text: z.string(),
+  });
+/** @internal */
+export type Parts1$Outbound = {
+  kind: string;
+  text: string;
+};
+
+/** @internal */
+export const Parts1$outboundSchema: z.ZodType<
+  Parts1$Outbound,
+  z.ZodTypeDef,
+  Parts1
+> = z.object({
+  kind: PartsKind$outboundSchema,
+  text: z.string(),
+});
+
+export function parts1ToJSON(parts1: Parts1): string {
+  return JSON.stringify(Parts1$outboundSchema.parse(parts1));
+}
+export function parts1FromJSON(
+  jsonString: string,
+): SafeParseResult<Parts1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Parts1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Parts1' from JSON`,
+  );
+}
+
+/** @internal */
+export const Parts$inboundSchema: z.ZodType<Parts, z.ZodTypeDef, unknown> = z
+  .union([
+    z.lazy(() => Parts4$inboundSchema),
+    z.lazy(() => Parts1$inboundSchema),
+    z.lazy(() => Parts2$inboundSchema),
+    z.lazy(() => Parts3$inboundSchema),
+    z.lazy(() => Parts5$inboundSchema),
+  ]);
+/** @internal */
+export type Parts$Outbound =
+  | Parts4$Outbound
+  | Parts1$Outbound
+  | Parts2$Outbound
+  | Parts3$Outbound
+  | Parts5$Outbound;
+
+/** @internal */
+export const Parts$outboundSchema: z.ZodType<
+  Parts$Outbound,
+  z.ZodTypeDef,
+  Parts
+> = z.union([
+  z.lazy(() => Parts4$outboundSchema),
+  z.lazy(() => Parts1$outboundSchema),
+  z.lazy(() => Parts2$outboundSchema),
+  z.lazy(() => Parts3$outboundSchema),
+  z.lazy(() => Parts5$outboundSchema),
+]);
+
+export function partsToJSON(parts: Parts): string {
+  return JSON.stringify(Parts$outboundSchema.parse(parts));
+}
+export function partsFromJSON(
+  jsonString: string,
+): SafeParseResult<Parts, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Parts$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Parts' from JSON`,
+  );
+}
+
+/** @internal */
+export const History$inboundSchema: z.ZodType<History, z.ZodTypeDef, unknown> =
+  z.object({
+    kind: GetAgentTaskAgentsResponseKind$inboundSchema,
+    messageId: z.string(),
+    role: GetAgentTaskRole$inboundSchema,
+    parts: z.array(
+      z.union([
+        z.lazy(() => Parts4$inboundSchema),
+        z.lazy(() => Parts1$inboundSchema),
+        z.lazy(() => Parts2$inboundSchema),
+        z.lazy(() => Parts3$inboundSchema),
+        z.lazy(() => Parts5$inboundSchema),
+      ]),
+    ),
+    taskId: z.string().optional(),
+    contextId: z.string().optional(),
+    metadata: z.record(z.any()).optional(),
+  });
+/** @internal */
+export type History$Outbound = {
+  kind: string;
+  messageId: string;
+  role: string;
+  parts: Array<
+    | Parts4$Outbound
+    | Parts1$Outbound
+    | Parts2$Outbound
+    | Parts3$Outbound
+    | Parts5$Outbound
+  >;
+  taskId?: string | undefined;
+  contextId?: string | undefined;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const History$outboundSchema: z.ZodType<
+  History$Outbound,
+  z.ZodTypeDef,
+  History
+> = z.object({
+  kind: GetAgentTaskAgentsResponseKind$outboundSchema,
+  messageId: z.string(),
+  role: GetAgentTaskRole$outboundSchema,
+  parts: z.array(
+    z.union([
+      z.lazy(() => Parts4$outboundSchema),
+      z.lazy(() => Parts1$outboundSchema),
+      z.lazy(() => Parts2$outboundSchema),
+      z.lazy(() => Parts3$outboundSchema),
+      z.lazy(() => Parts5$outboundSchema),
+    ]),
+  ),
+  taskId: z.string().optional(),
+  contextId: z.string().optional(),
+  metadata: z.record(z.any()).optional(),
+});
+
+export function historyToJSON(history: History): string {
+  return JSON.stringify(History$outboundSchema.parse(history));
+}
+export function historyFromJSON(
+  jsonString: string,
+): SafeParseResult<History, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => History$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'History' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetAgentTaskAgentsKind$inboundSchema: z.ZodNativeEnum<
+  typeof GetAgentTaskAgentsKind
+> = z.nativeEnum(GetAgentTaskAgentsKind);
+/** @internal */
+export const GetAgentTaskAgentsKind$outboundSchema: z.ZodNativeEnum<
+  typeof GetAgentTaskAgentsKind
+> = GetAgentTaskAgentsKind$inboundSchema;
+
+/** @internal */
+export const Artifacts$inboundSchema: z.ZodType<
+  Artifacts,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: GetAgentTaskAgentsKind$inboundSchema,
+  artifactId: z.string(),
+  name: z.string(),
+  type: z.string(),
+  url: z.string().optional(),
+  data: z.any().optional(),
+});
+/** @internal */
+export type Artifacts$Outbound = {
+  kind: string;
+  artifactId: string;
+  name: string;
+  type: string;
+  url?: string | undefined;
+  data?: any | undefined;
+};
+
+/** @internal */
+export const Artifacts$outboundSchema: z.ZodType<
+  Artifacts$Outbound,
+  z.ZodTypeDef,
+  Artifacts
+> = z.object({
+  kind: GetAgentTaskAgentsKind$outboundSchema,
+  artifactId: z.string(),
+  name: z.string(),
+  type: z.string(),
+  url: z.string().optional(),
+  data: z.any().optional(),
+});
+
+export function artifactsToJSON(artifacts: Artifacts): string {
+  return JSON.stringify(Artifacts$outboundSchema.parse(artifacts));
+}
+export function artifactsFromJSON(
+  jsonString: string,
+): SafeParseResult<Artifacts, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Artifacts$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Artifacts' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetAgentTaskResponseBody$inboundSchema: z.ZodType<
   GetAgentTaskResponseBody,
@@ -154,8 +896,8 @@ export const GetAgentTaskResponseBody$inboundSchema: z.ZodType<
   contextId: z.string(),
   kind: GetAgentTaskKind$inboundSchema,
   status: z.lazy(() => GetAgentTaskStatus$inboundSchema),
-  history: z.array(z.any()),
-  artifacts: z.array(z.any()).optional(),
+  history: z.array(z.lazy(() => History$inboundSchema)),
+  artifacts: z.array(z.lazy(() => Artifacts$inboundSchema)).optional(),
   metadata: z.record(z.any()).optional(),
 });
 /** @internal */
@@ -164,8 +906,8 @@ export type GetAgentTaskResponseBody$Outbound = {
   contextId: string;
   kind: string;
   status: GetAgentTaskStatus$Outbound;
-  history: Array<any>;
-  artifacts?: Array<any> | undefined;
+  history: Array<History$Outbound>;
+  artifacts?: Array<Artifacts$Outbound> | undefined;
   metadata?: { [k: string]: any } | undefined;
 };
 
@@ -179,8 +921,8 @@ export const GetAgentTaskResponseBody$outboundSchema: z.ZodType<
   contextId: z.string(),
   kind: GetAgentTaskKind$outboundSchema,
   status: z.lazy(() => GetAgentTaskStatus$outboundSchema),
-  history: z.array(z.any()),
-  artifacts: z.array(z.any()).optional(),
+  history: z.array(z.lazy(() => History$outboundSchema)),
+  artifacts: z.array(z.lazy(() => Artifacts$outboundSchema)).optional(),
   metadata: z.record(z.any()).optional(),
 });