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

package/models/operations/streamagent.d.ts

@@ -3,23 +3,23 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 /**
- * Tool message
+ * Message containing tool execution results
  */
 export declare const StreamAgentRoleToolMessage: {
     readonly Tool: "tool";
 };
 /**
- * Tool message
+ * Message containing tool execution results
  */
 export type StreamAgentRoleToolMessage = ClosedEnum<typeof StreamAgentRoleToolMessage>;
 /**
- * User message
+ * Message from the end user
  */
 export declare const StreamAgentRoleUserMessage: {
     readonly User: "user";
 };
 /**
- * User message
+ * Message from the end user
  */
 export type StreamAgentRoleUserMessage = ClosedEnum<typeof StreamAgentRoleUserMessage>;
 /**
@@ -105,7 +105,10 @@ export type StreamAgentPublicMessagePartTextPart = {
  * Message part that can be provided by users. Use "text" for regular messages, "file" for attachments, or "tool_result" when responding to tool call requests.
  */
 export type StreamAgentPublicMessagePart = StreamAgentPublicMessagePartTextPart | StreamAgentPublicMessagePartFilePart | StreamAgentPublicMessagePartToolResultPart;
-export type StreamAgentMessage = {
+/**
+ * The A2A message to send to the agent (user input or tool results)
+ */
+export type StreamAgentA2AMessage = {
     /**
      * Optional A2A message ID in ULID format
      */
@@ -177,7 +180,10 @@ export type StreamAgentRequestBody = {
      * Optional task ID to continue an existing agent execution. When provided, the agent will continue the conversation from the existing task state. The task must be in an inactive state to continue.
      */
     taskId?: string | undefined;
-    message: StreamAgentMessage;
+    /**
+     * The A2A message to send to the agent (user input or tool results)
+     */
+    message: StreamAgentA2AMessage;
     /**
      * Optional variables for template replacement in system prompt, instructions, and messages
      */
@@ -214,210 +220,2762 @@ export type StreamAgentRequest = {
     key: string;
     requestBody?: StreamAgentRequestBody | undefined;
 };
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Type: {
+    readonly AgentsError: "agents.error";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Type>;
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Data = {
+    error: string;
+    code: string;
+};
+export type Data17 = {
+    type: StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Type;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Data;
+};
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Type: {
+    readonly AgentsTimeout: "agents.timeout";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Type>;
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Data = {
+    message: string;
+};
+export type Data16 = {
+    type: StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Type;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Data;
+};
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Type: {
+    readonly EventWorkflowEventsToolExecutionFailed: "event.workflow_events.tool_execution_failed";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Type>;
+export type DataError = {
+    message: string;
+    stack?: string | undefined;
+};
 /**
- * SSE stream of agent events
+ * Orquesta product
  */
-export type StreamAgentResponseBody = {
+export declare const StreamAgentDataAgentsResponseProduct: {
+    readonly Remoteconfigs: "remoteconfigs";
+    readonly Deployments: "deployments";
+    readonly Experiments: "experiments";
+    readonly Playgrounds: "playgrounds";
+    readonly Spreadsheets: "spreadsheets";
+    readonly SpreadsheetRun: "spreadsheet_run";
+    readonly LlmEvaluator: "llm_evaluator";
+    readonly Knowledge: "knowledge";
+    readonly Router: "router";
+    readonly Workflows: "workflows";
+    readonly ExternalEvents: "external_events";
+    readonly Agents: "agents";
+    readonly MemoryStores: "memory-stores";
+    readonly Generic: "generic";
+    readonly Evaluators: "evaluators";
+    readonly Otel: "otel";
+};
+/**
+ * Orquesta product
+ */
+export type StreamAgentDataAgentsResponseProduct = ClosedEnum<typeof StreamAgentDataAgentsResponseProduct>;
+export type StreamAgentDataAgentsResponseMemory = {
+    entityId: string;
+};
+export type StreamAgentDataAgentsResponseToolExecutionContext = {
+    actionId: string;
+    agentToolCallId: string;
+    workspaceId: string;
+    agentManifestId: string;
+    agentExecutionId: string;
     /**
-     * JSON-encoded event data
+     * Orquesta product
      */
-    data: string;
+    product: StreamAgentDataAgentsResponseProduct;
+    memory?: StreamAgentDataAgentsResponseMemory | undefined;
+    parentId?: string | undefined;
 };
-/** @internal */
-export declare const StreamAgentRoleToolMessage$inboundSchema: z.ZodNativeEnum<typeof StreamAgentRoleToolMessage>;
-/** @internal */
-export declare const StreamAgentRoleToolMessage$outboundSchema: z.ZodNativeEnum<typeof StreamAgentRoleToolMessage>;
-/** @internal */
-export declare const StreamAgentRoleUserMessage$inboundSchema: z.ZodNativeEnum<typeof StreamAgentRoleUserMessage>;
-/** @internal */
-export declare const StreamAgentRoleUserMessage$outboundSchema: z.ZodNativeEnum<typeof StreamAgentRoleUserMessage>;
-/** @internal */
-export declare const StreamAgentRole$inboundSchema: z.ZodType<StreamAgentRole, z.ZodTypeDef, unknown>;
-/** @internal */
-export type StreamAgentRole$Outbound = string | string;
-/** @internal */
-export declare const StreamAgentRole$outboundSchema: z.ZodType<StreamAgentRole$Outbound, z.ZodTypeDef, StreamAgentRole>;
-export declare function streamAgentRoleToJSON(streamAgentRole: StreamAgentRole): string;
-export declare function streamAgentRoleFromJSON(jsonString: string): SafeParseResult<StreamAgentRole, SDKValidationError>;
-/** @internal */
-export declare const StreamAgentPublicMessagePartAgentsRequestKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPublicMessagePartAgentsRequestKind>;
-/** @internal */
-export declare const StreamAgentPublicMessagePartAgentsRequestKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPublicMessagePartAgentsRequestKind>;
-/** @internal */
-export declare const StreamAgentPublicMessagePartToolResultPart$inboundSchema: z.ZodType<StreamAgentPublicMessagePartToolResultPart, z.ZodTypeDef, unknown>;
-/** @internal */
-export type StreamAgentPublicMessagePartToolResultPart$Outbound = {
-    kind: string;
-    tool_call_id: string;
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Data = {
+    error: DataError;
+    actionType: string;
+    toolExecutionContext: StreamAgentDataAgentsResponseToolExecutionContext;
+};
+export type Data15 = {
+    type: StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Type;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Data;
+};
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Type: {
+    readonly EventWorkflowEventsToolExecutionFinished: "event.workflow_events.tool_execution_finished";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Type>;
+/**
+ * Orquesta product
+ */
+export declare const StreamAgentDataAgentsProduct: {
+    readonly Remoteconfigs: "remoteconfigs";
+    readonly Deployments: "deployments";
+    readonly Experiments: "experiments";
+    readonly Playgrounds: "playgrounds";
+    readonly Spreadsheets: "spreadsheets";
+    readonly SpreadsheetRun: "spreadsheet_run";
+    readonly LlmEvaluator: "llm_evaluator";
+    readonly Knowledge: "knowledge";
+    readonly Router: "router";
+    readonly Workflows: "workflows";
+    readonly ExternalEvents: "external_events";
+    readonly Agents: "agents";
+    readonly MemoryStores: "memory-stores";
+    readonly Generic: "generic";
+    readonly Evaluators: "evaluators";
+    readonly Otel: "otel";
+};
+/**
+ * Orquesta product
+ */
+export type StreamAgentDataAgentsProduct = ClosedEnum<typeof StreamAgentDataAgentsProduct>;
+export type StreamAgentDataAgentsMemory = {
+    entityId: string;
+};
+export type StreamAgentDataAgentsToolExecutionContext = {
+    actionId: string;
+    agentToolCallId: string;
+    workspaceId: string;
+    agentManifestId: string;
+    agentExecutionId: string;
+    /**
+     * Orquesta product
+     */
+    product: StreamAgentDataAgentsProduct;
+    memory?: StreamAgentDataAgentsMemory | undefined;
+    parentId?: string | undefined;
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Data = {
+    result?: any | undefined;
+    actionType: string;
+    toolExecutionContext: StreamAgentDataAgentsToolExecutionContext;
+};
+export type Data14 = {
+    type: StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Type;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Data;
+};
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Type: {
+    readonly EventWorkflowEventsToolExecutionStarted: "event.workflow_events.tool_execution_started";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Type>;
+/**
+ * Orquesta product
+ */
+export declare const StreamAgentDataProduct: {
+    readonly Remoteconfigs: "remoteconfigs";
+    readonly Deployments: "deployments";
+    readonly Experiments: "experiments";
+    readonly Playgrounds: "playgrounds";
+    readonly Spreadsheets: "spreadsheets";
+    readonly SpreadsheetRun: "spreadsheet_run";
+    readonly LlmEvaluator: "llm_evaluator";
+    readonly Knowledge: "knowledge";
+    readonly Router: "router";
+    readonly Workflows: "workflows";
+    readonly ExternalEvents: "external_events";
+    readonly Agents: "agents";
+    readonly MemoryStores: "memory-stores";
+    readonly Generic: "generic";
+    readonly Evaluators: "evaluators";
+    readonly Otel: "otel";
+};
+/**
+ * Orquesta product
+ */
+export type StreamAgentDataProduct = ClosedEnum<typeof StreamAgentDataProduct>;
+export type StreamAgentDataMemory = {
+    entityId: string;
+};
+export type StreamAgentDataToolExecutionContext = {
+    actionId: string;
+    agentToolCallId: string;
+    workspaceId: string;
+    agentManifestId: string;
+    agentExecutionId: string;
+    /**
+     * Orquesta product
+     */
+    product: StreamAgentDataProduct;
+    memory?: StreamAgentDataMemory | undefined;
+    parentId?: string | undefined;
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Data = {
+    toolId: string;
+    toolKey?: string | undefined;
+    toolDisplayName?: string | undefined;
+    actionType: string;
+    toolArguments: {
+        [k: string]: any;
+    };
+    toolExecutionContext: StreamAgentDataToolExecutionContext;
+};
+export type Data13 = {
+    type: StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Type;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Data;
+};
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Type: {
+    readonly EventAgentsMessageCreated: "event.agents.message-created";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Type>;
+export declare const StreamAgentDataAgentsResponseRole: {
+    readonly User: "user";
+    readonly Tool: "tool";
+};
+export type StreamAgentDataAgentsResponseRole = ClosedEnum<typeof StreamAgentDataAgentsResponseRole>;
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage5Kind: {
+    readonly ToolResult: "tool_result";
+};
+export type StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage5Kind = ClosedEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage5Kind>;
+/**
+ * The result of a tool execution. Contains the tool call ID for correlation and the result data from the tool invocation.
+ */
+export type StreamAgentPartsAgentsResponseToolResultPart = {
+    kind: StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage5Kind;
+    toolCallId: string;
     result?: any | undefined;
     metadata?: {
         [k: string]: any;
     } | undefined;
 };
-/** @internal */
-export declare const StreamAgentPublicMessagePartToolResultPart$outboundSchema: z.ZodType<StreamAgentPublicMessagePartToolResultPart$Outbound, z.ZodTypeDef, StreamAgentPublicMessagePartToolResultPart>;
-export declare function streamAgentPublicMessagePartToolResultPartToJSON(streamAgentPublicMessagePartToolResultPart: StreamAgentPublicMessagePartToolResultPart): string;
-export declare function streamAgentPublicMessagePartToolResultPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPublicMessagePartToolResultPart, SDKValidationError>;
-/** @internal */
-export declare const StreamAgentPublicMessagePartAgentsKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPublicMessagePartAgentsKind>;
-/** @internal */
-export declare const StreamAgentPublicMessagePartAgentsKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPublicMessagePartAgentsKind>;
-/** @internal */
-export declare const StreamAgentFileFileInURIFormat$inboundSchema: z.ZodType<StreamAgentFileFileInURIFormat, z.ZodTypeDef, unknown>;
-/** @internal */
-export type StreamAgentFileFileInURIFormat$Outbound = {
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage4Kind: {
+    readonly ToolCall: "tool_call";
+};
+export type StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage4Kind = ClosedEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage4Kind>;
+/**
+ * A tool invocation request from an agent. Contains the tool name, unique call ID, and arguments for the tool execution.
+ */
+export type StreamAgentPartsAgentsResponseToolCallPart = {
+    kind: StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage4Kind;
+    toolName: string;
+    toolCallId: string;
+    arguments: {
+        [k: string]: any;
+    };
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessageKind: {
+    readonly File: "file";
+};
+export type StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessageKind = ClosedEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessageKind>;
+/**
+ * File in URI format. Check in the model's documentation for the supported mime types for the URI format
+ */
+export type StreamAgentFileAgentsResponse200FileInURIFormat = {
+    /**
+     * URL for the File content
+     */
     uri: string;
+    /**
+     * Optional mimeType for the file
+     */
     mimeType?: string | undefined;
+    /**
+     * Optional name for the file
+     */
     name?: string | undefined;
 };
-/** @internal */
-export declare const StreamAgentFileFileInURIFormat$outboundSchema: z.ZodType<StreamAgentFileFileInURIFormat$Outbound, z.ZodTypeDef, StreamAgentFileFileInURIFormat>;
-export declare function streamAgentFileFileInURIFormatToJSON(streamAgentFileFileInURIFormat: StreamAgentFileFileInURIFormat): string;
-export declare function streamAgentFileFileInURIFormatFromJSON(jsonString: string): SafeParseResult<StreamAgentFileFileInURIFormat, SDKValidationError>;
-/** @internal */
-export declare const StreamAgentFileBinaryFormat$inboundSchema: z.ZodType<StreamAgentFileBinaryFormat, z.ZodTypeDef, unknown>;
-/** @internal */
-export type StreamAgentFileBinaryFormat$Outbound = {
+/**
+ * Binary in base64 format. Check in the model's documentation for the supported mime types for the binary format.
+ */
+export type StreamAgentFileAgentsResponse200BinaryFormat = {
+    /**
+     * 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 declare const StreamAgentFileBinaryFormat$outboundSchema: z.ZodType<StreamAgentFileBinaryFormat$Outbound, z.ZodTypeDef, StreamAgentFileBinaryFormat>;
-export declare function streamAgentFileBinaryFormatToJSON(streamAgentFileBinaryFormat: StreamAgentFileBinaryFormat): string;
-export declare function streamAgentFileBinaryFormatFromJSON(jsonString: string): SafeParseResult<StreamAgentFileBinaryFormat, SDKValidationError>;
-/** @internal */
-export declare const StreamAgentPublicMessagePartFile$inboundSchema: z.ZodType<StreamAgentPublicMessagePartFile, z.ZodTypeDef, unknown>;
-/** @internal */
-export type StreamAgentPublicMessagePartFile$Outbound = StreamAgentFileBinaryFormat$Outbound | StreamAgentFileFileInURIFormat$Outbound;
-/** @internal */
-export declare const StreamAgentPublicMessagePartFile$outboundSchema: z.ZodType<StreamAgentPublicMessagePartFile$Outbound, z.ZodTypeDef, StreamAgentPublicMessagePartFile>;
-export declare function streamAgentPublicMessagePartFileToJSON(streamAgentPublicMessagePartFile: StreamAgentPublicMessagePartFile): string;
-export declare function streamAgentPublicMessagePartFileFromJSON(jsonString: string): SafeParseResult<StreamAgentPublicMessagePartFile, SDKValidationError>;
-/** @internal */
-export declare const StreamAgentPublicMessagePartFilePart$inboundSchema: z.ZodType<StreamAgentPublicMessagePartFilePart, z.ZodTypeDef, unknown>;
-/** @internal */
-export type StreamAgentPublicMessagePartFilePart$Outbound = {
-    kind: string;
-    file: StreamAgentFileBinaryFormat$Outbound | StreamAgentFileFileInURIFormat$Outbound;
+export type StreamAgentPartsAgentsResponseFile = StreamAgentFileAgentsResponse200BinaryFormat | StreamAgentFileAgentsResponse200FileInURIFormat;
+/**
+ * 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 StreamAgentPartsAgentsResponseFilePart = {
+    kind: StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessageKind;
+    file: StreamAgentFileAgentsResponse200BinaryFormat | StreamAgentFileAgentsResponse200FileInURIFormat;
     metadata?: {
         [k: string]: any;
     } | undefined;
 };
-/** @internal */
-export declare const StreamAgentPublicMessagePartFilePart$outboundSchema: z.ZodType<StreamAgentPublicMessagePartFilePart$Outbound, z.ZodTypeDef, StreamAgentPublicMessagePartFilePart>;
-export declare function streamAgentPublicMessagePartFilePartToJSON(streamAgentPublicMessagePartFilePart: StreamAgentPublicMessagePartFilePart): string;
-export declare function streamAgentPublicMessagePartFilePartFromJSON(jsonString: string): SafeParseResult<StreamAgentPublicMessagePartFilePart, SDKValidationError>;
-/** @internal */
-export declare const StreamAgentPublicMessagePartKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPublicMessagePartKind>;
-/** @internal */
-export declare const StreamAgentPublicMessagePartKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPublicMessagePartKind>;
-/** @internal */
-export declare const StreamAgentPublicMessagePartTextPart$inboundSchema: z.ZodType<StreamAgentPublicMessagePartTextPart, z.ZodTypeDef, unknown>;
-/** @internal */
-export type StreamAgentPublicMessagePartTextPart$Outbound = {
-    kind: string;
-    text: string;
-};
-/** @internal */
-export declare const StreamAgentPublicMessagePartTextPart$outboundSchema: z.ZodType<StreamAgentPublicMessagePartTextPart$Outbound, z.ZodTypeDef, StreamAgentPublicMessagePartTextPart>;
-export declare function streamAgentPublicMessagePartTextPartToJSON(streamAgentPublicMessagePartTextPart: StreamAgentPublicMessagePartTextPart): string;
-export declare function streamAgentPublicMessagePartTextPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPublicMessagePartTextPart, SDKValidationError>;
-/** @internal */
-export declare const StreamAgentPublicMessagePart$inboundSchema: z.ZodType<StreamAgentPublicMessagePart, z.ZodTypeDef, unknown>;
-/** @internal */
-export type StreamAgentPublicMessagePart$Outbound = StreamAgentPublicMessagePartTextPart$Outbound | StreamAgentPublicMessagePartFilePart$Outbound | StreamAgentPublicMessagePartToolResultPart$Outbound;
-/** @internal */
-export declare const StreamAgentPublicMessagePart$outboundSchema: z.ZodType<StreamAgentPublicMessagePart$Outbound, z.ZodTypeDef, StreamAgentPublicMessagePart>;
-export declare function streamAgentPublicMessagePartToJSON(streamAgentPublicMessagePart: StreamAgentPublicMessagePart): string;
-export declare function streamAgentPublicMessagePartFromJSON(jsonString: string): SafeParseResult<StreamAgentPublicMessagePart, SDKValidationError>;
-/** @internal */
-export declare const StreamAgentMessage$inboundSchema: z.ZodType<StreamAgentMessage, z.ZodTypeDef, unknown>;
-/** @internal */
-export type StreamAgentMessage$Outbound = {
-    messageId?: string | undefined;
-    role: string | string;
-    parts: Array<StreamAgentPublicMessagePartTextPart$Outbound | StreamAgentPublicMessagePartFilePart$Outbound | StreamAgentPublicMessagePartToolResultPart$Outbound>;
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataKind: {
+    readonly Data: "data";
 };
-/** @internal */
-export declare const StreamAgentMessage$outboundSchema: z.ZodType<StreamAgentMessage$Outbound, z.ZodTypeDef, StreamAgentMessage>;
-export declare function streamAgentMessageToJSON(streamAgentMessage: StreamAgentMessage): string;
-export declare function streamAgentMessageFromJSON(jsonString: string): SafeParseResult<StreamAgentMessage, SDKValidationError>;
-/** @internal */
-export declare const StreamAgentContact$inboundSchema: z.ZodType<StreamAgentContact, z.ZodTypeDef, unknown>;
-/** @internal */
-export type StreamAgentContact$Outbound = {
-    id: string;
-    display_name?: string | undefined;
-    email?: string | undefined;
-    metadata?: Array<{
+export type StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataKind = ClosedEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataKind>;
+/**
+ * A structured data part containing JSON-serializable key-value pairs. Used for passing structured information between agents and tools.
+ */
+export type StreamAgentPartsAgentsResponseDataPart = {
+    kind: StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataKind;
+    data: {
         [k: string]: any;
-    }> | undefined;
-    logo_url?: string | undefined;
-    tags?: Array<string> | undefined;
+    };
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
 };
-/** @internal */
-export declare const StreamAgentContact$outboundSchema: z.ZodType<StreamAgentContact$Outbound, z.ZodTypeDef, StreamAgentContact>;
-export declare function streamAgentContactToJSON(streamAgentContact: StreamAgentContact): string;
-export declare function streamAgentContactFromJSON(jsonString: string): SafeParseResult<StreamAgentContact, SDKValidationError>;
-/** @internal */
-export declare const StreamAgentThread$inboundSchema: z.ZodType<StreamAgentThread, z.ZodTypeDef, unknown>;
-/** @internal */
-export type StreamAgentThread$Outbound = {
-    id: string;
-    tags?: Array<string> | undefined;
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12Kind: {
+    readonly Text: "text";
 };
-/** @internal */
-export declare const StreamAgentThread$outboundSchema: z.ZodType<StreamAgentThread$Outbound, z.ZodTypeDef, StreamAgentThread>;
-export declare function streamAgentThreadToJSON(streamAgentThread: StreamAgentThread): string;
-export declare function streamAgentThreadFromJSON(jsonString: string): SafeParseResult<StreamAgentThread, SDKValidationError>;
-/** @internal */
-export declare const StreamAgentMemory$inboundSchema: z.ZodType<StreamAgentMemory, z.ZodTypeDef, unknown>;
-/** @internal */
-export type StreamAgentMemory$Outbound = {
-    entity_id: string;
+export type StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12Kind = ClosedEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12Kind>;
+/**
+ * A text content part containing plain text or markdown. Used for agent messages, user input, and text-based responses.
+ */
+export type StreamAgentPartsAgentsResponseTextPart = {
+    kind: StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12Kind;
+    text: string;
 };
-/** @internal */
-export declare const StreamAgentMemory$outboundSchema: z.ZodType<StreamAgentMemory$Outbound, z.ZodTypeDef, StreamAgentMemory>;
-export declare function streamAgentMemoryToJSON(streamAgentMemory: StreamAgentMemory): string;
-export declare function streamAgentMemoryFromJSON(jsonString: string): SafeParseResult<StreamAgentMemory, SDKValidationError>;
-/** @internal */
-export declare const StreamAgentRequestBody$inboundSchema: z.ZodType<StreamAgentRequestBody, z.ZodTypeDef, unknown>;
-/** @internal */
-export type StreamAgentRequestBody$Outbound = {
-    task_id?: string | undefined;
-    message: StreamAgentMessage$Outbound;
-    variables?: {
+export type StreamAgentDataAgentsResponseParts = StreamAgentPartsAgentsResponseToolCallPart | StreamAgentPartsAgentsResponseTextPart | StreamAgentPartsAgentsResponseDataPart | StreamAgentPartsAgentsResponseFilePart | StreamAgentPartsAgentsResponseToolResultPart;
+export type StreamAgentDataMessage = {
+    messageId?: string | undefined;
+    role: StreamAgentDataAgentsResponseRole;
+    parts: Array<StreamAgentPartsAgentsResponseToolCallPart | StreamAgentPartsAgentsResponseTextPart | StreamAgentPartsAgentsResponseDataPart | StreamAgentPartsAgentsResponseFilePart | StreamAgentPartsAgentsResponseToolResultPart>;
+    metadata?: {
         [k: string]: any;
     } | undefined;
-    contact?: StreamAgentContact$Outbound | undefined;
-    thread?: StreamAgentThread$Outbound | undefined;
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Data = {
+    workflowRunId: string;
+    spanId: string;
+    parentId: string;
+    message: Array<StreamAgentDataMessage>;
+};
+export type Data12 = {
+    type: StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Type;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Data;
+};
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Type: {
+    readonly EventAgentsHandedOff: "event.agents.handed_off";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Type>;
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Data = {
+    agentId: string;
+    input: string;
+};
+export type Data11 = {
+    type: StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Type;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Data;
+};
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Type: {
+    readonly EventAgentsExecutionNamed: "event.agents.execution_named";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Type>;
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Data = {
+    name: string;
+    agentManifestId: string;
+};
+export type Data10 = {
+    type: StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Type;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Data;
+};
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Type: {
+    readonly EventAgentsExecutionReviewed: "event.agents.execution_reviewed";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Type>;
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Data = {};
+export type Data9 = {
+    type: StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Type;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Data;
+};
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Type: {
+    readonly EventAgentsExecutionReviewRequired: "event.agents.execution_review_required";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Type>;
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Data = {};
+export type Data8 = {
+    type: StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Type;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Data;
+};
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Type: {
+    readonly EventAgentsActionReviewed: "event.agents.action_reviewed";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Type>;
+export declare const DataReview: {
+    readonly Approved: "approved";
+    readonly Rejected: "rejected";
+};
+export type DataReview = ClosedEnum<typeof DataReview>;
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Data = {
+    agentId: string;
+    actionId: string;
+    agentToolCallId: string;
+    review: DataReview;
+    mockOutput?: {
+        [k: string]: any;
+    } | undefined;
+    reviewSource?: string | undefined;
+    reviewedById?: string | undefined;
+};
+export type Data7 = {
+    type: StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Type;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Data;
+};
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBodyType: {
+    readonly EventAgentsActionReviewRequested: "event.agents.action_review_requested";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBodyType = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBodyType>;
+export type StreamAgentDataConditions = {
+    /**
+     * The argument of the tool call to evaluate
+     */
+    condition: string;
+    /**
+     * The operator to use
+     */
+    operator: string;
+    /**
+     * The value to compare against
+     */
+    value: string;
+};
+export type DataTool = {
+    /**
+     * The id of the resource
+     */
+    id: string;
+    /**
+     * Optional tool key for custom tools
+     */
+    key?: string | undefined;
+    actionType: string;
+    displayName?: string | undefined;
+    /**
+     * Optional tool description
+     */
+    description?: string | undefined;
+    requiresApproval?: boolean | undefined;
+    /**
+     * Nested tool ID for MCP tools (identifies specific tool within MCP server)
+     */
+    toolId?: string | undefined;
+    conditions?: Array<StreamAgentDataConditions> | undefined;
+    /**
+     * Tool execution timeout in seconds (default: 2 minutes, max: 10 minutes)
+     */
+    timeout?: number | undefined;
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBodyData = {
+    agentId: string;
+    actionId: string;
+    requiresApproval: boolean;
+    tool: DataTool;
+    input: {
+        [k: string]: any;
+    };
+    agentToolCallId: string;
+};
+export type Data6 = {
+    type: StreamAgentDataAgentsResponse200TextEventStreamResponseBodyType;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBodyData;
+};
+export declare const StreamAgentDataAgentsResponse200TextEventStreamType: {
+    readonly EventAgentsErrored: "event.agents.errored";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamType = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamType>;
+export type StreamAgentDataAgentsResponse200TextEventStreamData = {
+    error: string;
+    code: number;
+};
+export type Data5 = {
+    type: StreamAgentDataAgentsResponse200TextEventStreamType;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamData;
+};
+export declare const StreamAgentDataAgentsResponse200Type: {
+    readonly EventAgentsInactive: "event.agents.inactive";
+};
+export type StreamAgentDataAgentsResponse200Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200Type>;
+/**
+ * The reason why the agent execution became inactive
+ */
+export declare const DataFinishReason: {
+    readonly Stop: "stop";
+    readonly Length: "length";
+    readonly ToolCalls: "tool_calls";
+    readonly ContentFilter: "content_filter";
+    readonly FunctionCall: "function_call";
+    readonly MaxIterations: "max_iterations";
+    readonly MaxTime: "max_time";
+};
+/**
+ * The reason why the agent execution became inactive
+ */
+export type DataFinishReason = ClosedEnum<typeof DataFinishReason>;
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody4Type: {
+    readonly Function: "function";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody4Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody4Type>;
+export type StreamAgentDataFunction = {
+    name?: string | undefined;
+    arguments?: string | undefined;
+};
+export type DataPendingToolCalls = {
+    id: string;
+    type: StreamAgentDataAgentsResponse200TextEventStreamResponseBody4Type;
+    function: StreamAgentDataFunction;
+};
+export type StreamAgentDataAgentsResponse200Data = {
+    lastMessage: string;
+    /**
+     * The reason why the agent execution became inactive
+     */
+    finishReason: DataFinishReason;
+    /**
+     * Tool calls that are pending user response (for function_call finish reason)
+     */
+    pendingToolCalls?: Array<DataPendingToolCalls> | undefined;
+};
+export type StreamAgentData4 = {
+    type: StreamAgentDataAgentsResponse200Type;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200Data;
+};
+export declare const StreamAgentDataAgentsResponseType: {
+    readonly EventAgentsThought: "event.agents.thought";
+};
+export type StreamAgentDataAgentsResponseType = ClosedEnum<typeof StreamAgentDataAgentsResponseType>;
+export declare const StreamAgentDataAgentsRole: {
+    readonly User: "user";
+    readonly Agent: "agent";
+    readonly Tool: "tool";
+    readonly System: "system";
+};
+export type StreamAgentDataAgentsRole = ClosedEnum<typeof StreamAgentDataAgentsRole>;
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataMessageDifferenceKind: {
+    readonly ToolResult: "tool_result";
+};
+export type StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataMessageDifferenceKind = ClosedEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataMessageDifferenceKind>;
+/**
+ * The result of a tool execution. Contains the tool call ID for correlation and the result data from the tool invocation.
+ */
+export type StreamAgentPartsAgentsToolResultPart = {
+    kind: StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataMessageDifferenceKind;
+    toolCallId: string;
+    result?: any | undefined;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataKind: {
+    readonly ToolCall: "tool_call";
+};
+export type StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataKind = ClosedEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataKind>;
+/**
+ * A tool invocation request from an agent. Contains the tool name, unique call ID, and arguments for the tool execution.
+ */
+export type StreamAgentPartsAgentsToolCallPart = {
+    kind: StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataKind;
+    toolName: string;
+    toolCallId: string;
+    arguments: {
+        [k: string]: any;
+    };
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3Kind: {
+    readonly File: "file";
+};
+export type StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3Kind = ClosedEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3Kind>;
+/**
+ * File in URI format. Check in the model's documentation for the supported mime types for the URI format
+ */
+export type StreamAgentFileAgentsResponseFileInURIFormat = {
+    /**
+     * 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 StreamAgentFileAgentsResponseBinaryFormat = {
+    /**
+     * 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 StreamAgentPartsAgentsFile = StreamAgentFileAgentsResponseBinaryFormat | StreamAgentFileAgentsResponseFileInURIFormat;
+/**
+ * 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 StreamAgentPartsAgentsFilePart = {
+    kind: StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3Kind;
+    file: StreamAgentFileAgentsResponseBinaryFormat | StreamAgentFileAgentsResponseFileInURIFormat;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyDataKind: {
+    readonly Data: "data";
+};
+export type StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyDataKind = ClosedEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyDataKind>;
+/**
+ * A structured data part containing JSON-serializable key-value pairs. Used for passing structured information between agents and tools.
+ */
+export type StreamAgentPartsAgentsDataPart = {
+    kind: StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyDataKind;
+    data: {
+        [k: string]: any;
+    };
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyKind: {
+    readonly Text: "text";
+};
+export type StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyKind = ClosedEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyKind>;
+/**
+ * A text content part containing plain text or markdown. Used for agent messages, user input, and text-based responses.
+ */
+export type StreamAgentPartsAgentsTextPart = {
+    kind: StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyKind;
+    text: string;
+};
+export type StreamAgentDataAgentsParts = StreamAgentPartsAgentsToolCallPart | StreamAgentPartsAgentsTextPart | StreamAgentPartsAgentsDataPart | StreamAgentPartsAgentsFilePart | StreamAgentPartsAgentsToolResultPart;
+export type DataMessageDifference = {
+    messageId: string;
+    role: StreamAgentDataAgentsRole;
+    parts: Array<StreamAgentPartsAgentsToolCallPart | StreamAgentPartsAgentsTextPart | StreamAgentPartsAgentsDataPart | StreamAgentPartsAgentsFilePart | StreamAgentPartsAgentsToolResultPart>;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+    agentId: string;
+    agentExecutionId: string;
+    workspaceId: string;
+};
+/**
+ * The reason the model stopped generating tokens.
+ */
+export declare const StreamAgentDataFinishReason: {
+    readonly Stop: "stop";
+    readonly Length: "length";
+    readonly ToolCalls: "tool_calls";
+    readonly ContentFilter: "content_filter";
+    readonly FunctionCall: "function_call";
+};
+/**
+ * The reason the model stopped generating tokens.
+ */
+export type StreamAgentDataFinishReason = ClosedEnum<typeof StreamAgentDataFinishReason>;
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody3Type: {
+    readonly Function: "function";
+};
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody3Type = ClosedEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody3Type>;
+export type StreamAgentDataAgentsFunction = {
+    /**
+     * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
+     */
+    name?: string | undefined;
+    /**
+     * The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function.
+     */
+    arguments?: string | undefined;
+};
+export type StreamAgentDataToolCalls = {
+    id?: string | undefined;
+    type?: StreamAgentDataAgentsResponse200TextEventStreamResponseBody3Type | undefined;
+    function?: StreamAgentDataAgentsFunction | undefined;
+};
+export declare const StreamAgentDataAgentsResponse200Role: {
+    readonly Assistant: "assistant";
+};
+export type StreamAgentDataAgentsResponse200Role = ClosedEnum<typeof StreamAgentDataAgentsResponse200Role>;
+/**
+ * If the audio output modality is requested, this object contains data about the audio response from the model.
+ */
+export type StreamAgentDataAudio = {
+    id: string;
+    expiresAt: number;
+    data: string;
+    transcript: string;
+};
+/**
+ * A chat completion message generated by the model.
+ */
+export type StreamAgentDataAgentsMessage = {
+    content?: string | null | undefined;
+    refusal?: string | null | undefined;
+    toolCalls?: Array<StreamAgentDataToolCalls> | undefined;
+    role?: StreamAgentDataAgentsResponse200Role | undefined;
+    /**
+     * Internal thought process of the model
+     */
+    reasoning?: string | null | undefined;
+    /**
+     * The signature holds a cryptographic token which verifies that the thinking block was generated by the model, and is verified when thinking is part of a multiturn conversation. This value should not be modified and should always be sent to the API when the reasoning is redacted. Currently only supported by `Anthropic`.
+     */
+    reasoningSignature?: string | null | undefined;
+    /**
+     * Occasionally the model's internal reasoning will be flagged by the safety systems of the provider. When this occurs, the provider will encrypt the reasoning. These redacted reasoning is decrypted when passed back to the API, allowing the model to continue its response without losing context.
+     */
+    redactedReasoning?: string | undefined;
+    /**
+     * If the audio output modality is requested, this object contains data about the audio response from the model.
+     */
+    audio?: StreamAgentDataAudio | null | undefined;
+};
+export type StreamAgentDataTopLogprobs = {
+    /**
+     * The token.
+     */
+    token: string;
+    /**
+     * The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value -9999.0 is used to signify that the token is very unlikely.
+     */
+    logprob: number;
+    /**
+     * A list of integers representing the UTF-8 bytes representation of the token.
+     */
+    bytes: Array<number> | null;
+};
+export type StreamAgentDataContent = {
+    /**
+     * The token.
+     */
+    token: string;
+    /**
+     * The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value -9999.0 is used to signify that the token is very unlikely.
+     */
+    logprob: number;
+    /**
+     * A list of integers representing the UTF-8 bytes representation of the token.
+     */
+    bytes: Array<number> | null;
+    /**
+     * List of the most likely tokens and their log probability, at this token position.
+     */
+    topLogprobs: Array<StreamAgentDataTopLogprobs>;
+};
+export type StreamAgentDataAgentsTopLogprobs = {
+    /**
+     * The token.
+     */
+    token: string;
+    /**
+     * The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value -9999.0 is used to signify that the token is very unlikely.
+     */
+    logprob: number;
+    /**
+     * A list of integers representing the UTF-8 bytes representation of the token.
+     */
+    bytes: Array<number> | null;
+};
+export type DataRefusal = {
+    /**
+     * The token.
+     */
+    token: string;
+    /**
+     * The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value -9999.0 is used to signify that the token is very unlikely.
+     */
+    logprob: number;
+    /**
+     * A list of integers representing the UTF-8 bytes representation of the token.
+     */
+    bytes: Array<number> | null;
+    /**
+     * List of the most likely tokens and their log probability, at this token position.
+     */
+    topLogprobs: Array<StreamAgentDataAgentsTopLogprobs>;
+};
+/**
+ * Log probability information for the choice.
+ */
+export type DataLogprobs = {
+    /**
+     * A list of message content tokens with log probability information.
+     */
+    content: Array<StreamAgentDataContent> | null;
+    /**
+     * A list of message refusal tokens with log probability information.
+     */
+    refusal: Array<DataRefusal> | null;
+};
+export type DataChoice = {
+    /**
+     * The reason the model stopped generating tokens.
+     */
+    finishReason: StreamAgentDataFinishReason | null;
+    /**
+     * The index of the choice in the list of choices.
+     */
+    index?: number | undefined;
+    /**
+     * A chat completion message generated by the model.
+     */
+    message: StreamAgentDataAgentsMessage;
+    /**
+     * Log probability information for the choice.
+     */
+    logprobs?: DataLogprobs | null | undefined;
+};
+export type StreamAgentDataAgentsResponseData = {
+    agentId: string;
+    messageDifference: {
+        [k: string]: DataMessageDifference;
+    };
+    choice?: DataChoice | undefined;
+    choiceIndex?: number | undefined;
+    iteration: number;
+    accumulatedExecutionTime: number;
+};
+export type StreamAgentData3 = {
+    type: StreamAgentDataAgentsResponseType;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsResponseData;
+};
+export declare const StreamAgentDataAgentsType: {
+    readonly EventAgentsStarted: "event.agents.started";
+};
+export type StreamAgentDataAgentsType = ClosedEnum<typeof StreamAgentDataAgentsType>;
+/**
+ * Extended A2A message role
+ */
+export declare const StreamAgentDataRole: {
+    readonly User: "user";
+    readonly Agent: "agent";
+    readonly Tool: "tool";
+    readonly System: "system";
+};
+/**
+ * Extended A2A message role
+ */
+export type StreamAgentDataRole = ClosedEnum<typeof StreamAgentDataRole>;
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamKind: {
+    readonly ToolResult: "tool_result";
+};
+export type StreamAgentPartsAgentsResponse200TextEventStreamKind = ClosedEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamKind>;
+/**
+ * The result of a tool execution. Contains the tool call ID for correlation and the result data from the tool invocation.
+ */
+export type StreamAgentPartsToolResultPart = {
+    kind: StreamAgentPartsAgentsResponse200TextEventStreamKind;
+    toolCallId: string;
+    result?: any | undefined;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+export declare const StreamAgentPartsAgentsResponse200Kind: {
+    readonly ToolCall: "tool_call";
+};
+export type StreamAgentPartsAgentsResponse200Kind = ClosedEnum<typeof StreamAgentPartsAgentsResponse200Kind>;
+/**
+ * A tool invocation request from an agent. Contains the tool name, unique call ID, and arguments for the tool execution.
+ */
+export type StreamAgentPartsToolCallPart = {
+    kind: StreamAgentPartsAgentsResponse200Kind;
+    toolName: string;
+    toolCallId: string;
+    arguments: {
+        [k: string]: any;
+    };
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+export declare const StreamAgentPartsAgentsResponseKind: {
+    readonly File: "file";
+};
+export type StreamAgentPartsAgentsResponseKind = ClosedEnum<typeof StreamAgentPartsAgentsResponseKind>;
+/**
+ * File in URI format. Check in the model's documentation for the supported mime types for the URI format
+ */
+export type StreamAgentFileAgentsFileInURIFormat = {
+    /**
+     * 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 StreamAgentFileAgentsBinaryFormat = {
+    /**
+     * 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 StreamAgentPartsFile = StreamAgentFileAgentsBinaryFormat | StreamAgentFileAgentsFileInURIFormat;
+/**
+ * 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 StreamAgentPartsFilePart = {
+    kind: StreamAgentPartsAgentsResponseKind;
+    file: StreamAgentFileAgentsBinaryFormat | StreamAgentFileAgentsFileInURIFormat;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+export declare const StreamAgentPartsAgentsKind: {
+    readonly Data: "data";
+};
+export type StreamAgentPartsAgentsKind = ClosedEnum<typeof StreamAgentPartsAgentsKind>;
+/**
+ * A structured data part containing JSON-serializable key-value pairs. Used for passing structured information between agents and tools.
+ */
+export type StreamAgentPartsDataPart = {
+    kind: StreamAgentPartsAgentsKind;
+    data: {
+        [k: string]: any;
+    };
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+export declare const StreamAgentPartsKind: {
+    readonly Text: "text";
+};
+export type StreamAgentPartsKind = ClosedEnum<typeof StreamAgentPartsKind>;
+/**
+ * A text content part containing plain text or markdown. Used for agent messages, user input, and text-based responses.
+ */
+export type StreamAgentPartsTextPart = {
+    kind: StreamAgentPartsKind;
+    text: string;
+};
+export type StreamAgentDataParts = StreamAgentPartsToolCallPart | StreamAgentPartsTextPart | StreamAgentPartsDataPart | StreamAgentPartsFilePart | StreamAgentPartsToolResultPart;
+export type DataInputMessage = {
+    messageId?: string | undefined;
+    /**
+     * Extended A2A message role
+     */
+    role: StreamAgentDataRole;
+    parts: Array<StreamAgentPartsToolCallPart | StreamAgentPartsTextPart | StreamAgentPartsDataPart | StreamAgentPartsFilePart | StreamAgentPartsToolResultPart>;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/**
+ * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
+ */
+export declare const StreamAgentDataToolApprovalRequired: {
+    readonly All: "all";
+    readonly RespectTool: "respect_tool";
+    readonly None: "none";
+};
+/**
+ * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
+ */
+export type StreamAgentDataToolApprovalRequired = ClosedEnum<typeof StreamAgentDataToolApprovalRequired>;
+export type StreamAgentDataAgentsConditions = {
+    /**
+     * The argument of the tool call to evaluate
+     */
+    condition: string;
+    /**
+     * The operator to use
+     */
+    operator: string;
+    /**
+     * The value to compare against
+     */
+    value: string;
+};
+export type StreamAgentDataTools = {
+    /**
+     * The id of the resource
+     */
+    id: string;
+    /**
+     * Optional tool key for custom tools
+     */
+    key?: string | undefined;
+    actionType: string;
+    displayName?: string | undefined;
+    /**
+     * Optional tool description
+     */
+    description?: string | undefined;
+    requiresApproval?: boolean | undefined;
+    /**
+     * Nested tool ID for MCP tools (identifies specific tool within MCP server)
+     */
+    toolId?: string | undefined;
+    conditions?: Array<StreamAgentDataAgentsConditions> | undefined;
+    /**
+     * Tool execution timeout in seconds (default: 2 minutes, max: 10 minutes)
+     */
+    timeout?: number | undefined;
+};
+/**
+ * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
+ */
+export declare const StreamAgentDataExecuteOn: {
+    readonly Input: "input";
+    readonly Output: "output";
+};
+/**
+ * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
+ */
+export type StreamAgentDataExecuteOn = ClosedEnum<typeof StreamAgentDataExecuteOn>;
+export type StreamAgentDataEvaluators = {
+    /**
+     * Unique key or identifier of the evaluator
+     */
+    id: string;
+    /**
+     * The percentage of executions to evaluate with this evaluator (1-100). For example, a value of 50 means the evaluator will run on approximately half of the executions.
+     */
+    sampleRate?: number | undefined;
+    /**
+     * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
+     */
+    executeOn: StreamAgentDataExecuteOn;
+};
+/**
+ * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
+ */
+export declare const StreamAgentDataAgentsExecuteOn: {
+    readonly Input: "input";
+    readonly Output: "output";
+};
+/**
+ * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
+ */
+export type StreamAgentDataAgentsExecuteOn = ClosedEnum<typeof StreamAgentDataAgentsExecuteOn>;
+export type StreamAgentDataGuardrails = {
+    /**
+     * Unique key or identifier of the evaluator
+     */
+    id: string;
+    /**
+     * The percentage of executions to evaluate with this evaluator (1-100). For example, a value of 50 means the evaluator will run on approximately half of the executions.
+     */
+    sampleRate?: number | undefined;
+    /**
+     * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
+     */
+    executeOn: StreamAgentDataAgentsExecuteOn;
+};
+export type StreamAgentDataSettings = {
+    /**
+     * Maximum iterations(llm calls) before the agent will stop executing.
+     */
+    maxIterations?: number | undefined;
+    /**
+     * Maximum time (in seconds) for the agent thinking process. This does not include the time for tool calls and sub agent calls. It will be loosely enforced, the in progress LLM calls will not be terminated and the last assistant message will be returned.
+     */
+    maxExecutionTime?: number | undefined;
+    /**
+     * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
+     */
+    toolApprovalRequired?: StreamAgentDataToolApprovalRequired | undefined;
+    tools?: Array<StreamAgentDataTools> | undefined;
+    /**
+     * Configuration for an evaluator applied to the agent
+     */
+    evaluators?: Array<StreamAgentDataEvaluators> | undefined;
+    /**
+     * Configuration for a guardrail applied to the agent
+     */
+    guardrails?: Array<StreamAgentDataGuardrails> | undefined;
+};
+export type StreamAgentDataAgentsData = {
+    integrationId?: string | undefined;
+    inputMessage: DataInputMessage;
+    modelId: string;
+    instructions: string;
+    systemPrompt: string;
+    settings?: StreamAgentDataSettings | undefined;
+    agentManifestId: string;
+    agentKey: string;
+    variables?: {
+        [k: string]: any;
+    } | undefined;
+    toolExecutionId?: string | undefined;
+    isContinuation?: boolean | undefined;
+    stream?: boolean | undefined;
+};
+export type StreamAgentData2 = {
+    type: StreamAgentDataAgentsType;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataAgentsData;
+};
+export declare const StreamAgentDataType: {
+    readonly AgentsExecutionStarted: "agents.execution_started";
+};
+export type StreamAgentDataType = ClosedEnum<typeof StreamAgentDataType>;
+export type StreamAgentDataData = {
+    /**
+     * Agent execution task ID (ULID)
+     */
+    agentTaskId: string;
+    /**
+     * Workspace ID
+     */
+    workspaceId: string;
+    /**
+     * Trace ID for the workflow run
+     */
+    traceId: string;
+};
+export type StreamAgentData1 = {
+    type: StreamAgentDataType;
+    /**
+     * ISO timestamp of the event
+     */
+    timestamp: string;
+    data: StreamAgentDataData;
+};
+export type StreamAgentData = StreamAgentData1 | StreamAgentData2 | StreamAgentData3 | StreamAgentData4 | Data5 | Data6 | Data7 | Data8 | Data9 | Data10 | Data11 | Data12 | Data13 | Data14 | Data15 | Data16 | Data17;
+/**
+ * SSE stream of agent events
+ */
+export type StreamAgentResponseBody = {
+    data: StreamAgentData1 | StreamAgentData2 | StreamAgentData3 | StreamAgentData4 | Data5 | Data6 | Data7 | Data8 | Data9 | Data10 | Data11 | Data12 | Data13 | Data14 | Data15 | Data16 | Data17;
+};
+/** @internal */
+export declare const StreamAgentRoleToolMessage$inboundSchema: z.ZodNativeEnum<typeof StreamAgentRoleToolMessage>;
+/** @internal */
+export declare const StreamAgentRoleToolMessage$outboundSchema: z.ZodNativeEnum<typeof StreamAgentRoleToolMessage>;
+/** @internal */
+export declare const StreamAgentRoleUserMessage$inboundSchema: z.ZodNativeEnum<typeof StreamAgentRoleUserMessage>;
+/** @internal */
+export declare const StreamAgentRoleUserMessage$outboundSchema: z.ZodNativeEnum<typeof StreamAgentRoleUserMessage>;
+/** @internal */
+export declare const StreamAgentRole$inboundSchema: z.ZodType<StreamAgentRole, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentRole$Outbound = string | string;
+/** @internal */
+export declare const StreamAgentRole$outboundSchema: z.ZodType<StreamAgentRole$Outbound, z.ZodTypeDef, StreamAgentRole>;
+export declare function streamAgentRoleToJSON(streamAgentRole: StreamAgentRole): string;
+export declare function streamAgentRoleFromJSON(jsonString: string): SafeParseResult<StreamAgentRole, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPublicMessagePartAgentsRequestKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPublicMessagePartAgentsRequestKind>;
+/** @internal */
+export declare const StreamAgentPublicMessagePartAgentsRequestKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPublicMessagePartAgentsRequestKind>;
+/** @internal */
+export declare const StreamAgentPublicMessagePartToolResultPart$inboundSchema: z.ZodType<StreamAgentPublicMessagePartToolResultPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPublicMessagePartToolResultPart$Outbound = {
+    kind: string;
+    tool_call_id: string;
+    result?: any | undefined;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const StreamAgentPublicMessagePartToolResultPart$outboundSchema: z.ZodType<StreamAgentPublicMessagePartToolResultPart$Outbound, z.ZodTypeDef, StreamAgentPublicMessagePartToolResultPart>;
+export declare function streamAgentPublicMessagePartToolResultPartToJSON(streamAgentPublicMessagePartToolResultPart: StreamAgentPublicMessagePartToolResultPart): string;
+export declare function streamAgentPublicMessagePartToolResultPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPublicMessagePartToolResultPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPublicMessagePartAgentsKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPublicMessagePartAgentsKind>;
+/** @internal */
+export declare const StreamAgentPublicMessagePartAgentsKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPublicMessagePartAgentsKind>;
+/** @internal */
+export declare const StreamAgentFileFileInURIFormat$inboundSchema: z.ZodType<StreamAgentFileFileInURIFormat, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentFileFileInURIFormat$Outbound = {
+    uri: string;
+    mimeType?: string | undefined;
+    name?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentFileFileInURIFormat$outboundSchema: z.ZodType<StreamAgentFileFileInURIFormat$Outbound, z.ZodTypeDef, StreamAgentFileFileInURIFormat>;
+export declare function streamAgentFileFileInURIFormatToJSON(streamAgentFileFileInURIFormat: StreamAgentFileFileInURIFormat): string;
+export declare function streamAgentFileFileInURIFormatFromJSON(jsonString: string): SafeParseResult<StreamAgentFileFileInURIFormat, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentFileBinaryFormat$inboundSchema: z.ZodType<StreamAgentFileBinaryFormat, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentFileBinaryFormat$Outbound = {
+    bytes: string;
+    mimeType?: string | undefined;
+    name?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentFileBinaryFormat$outboundSchema: z.ZodType<StreamAgentFileBinaryFormat$Outbound, z.ZodTypeDef, StreamAgentFileBinaryFormat>;
+export declare function streamAgentFileBinaryFormatToJSON(streamAgentFileBinaryFormat: StreamAgentFileBinaryFormat): string;
+export declare function streamAgentFileBinaryFormatFromJSON(jsonString: string): SafeParseResult<StreamAgentFileBinaryFormat, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPublicMessagePartFile$inboundSchema: z.ZodType<StreamAgentPublicMessagePartFile, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPublicMessagePartFile$Outbound = StreamAgentFileBinaryFormat$Outbound | StreamAgentFileFileInURIFormat$Outbound;
+/** @internal */
+export declare const StreamAgentPublicMessagePartFile$outboundSchema: z.ZodType<StreamAgentPublicMessagePartFile$Outbound, z.ZodTypeDef, StreamAgentPublicMessagePartFile>;
+export declare function streamAgentPublicMessagePartFileToJSON(streamAgentPublicMessagePartFile: StreamAgentPublicMessagePartFile): string;
+export declare function streamAgentPublicMessagePartFileFromJSON(jsonString: string): SafeParseResult<StreamAgentPublicMessagePartFile, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPublicMessagePartFilePart$inboundSchema: z.ZodType<StreamAgentPublicMessagePartFilePart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPublicMessagePartFilePart$Outbound = {
+    kind: string;
+    file: StreamAgentFileBinaryFormat$Outbound | StreamAgentFileFileInURIFormat$Outbound;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const StreamAgentPublicMessagePartFilePart$outboundSchema: z.ZodType<StreamAgentPublicMessagePartFilePart$Outbound, z.ZodTypeDef, StreamAgentPublicMessagePartFilePart>;
+export declare function streamAgentPublicMessagePartFilePartToJSON(streamAgentPublicMessagePartFilePart: StreamAgentPublicMessagePartFilePart): string;
+export declare function streamAgentPublicMessagePartFilePartFromJSON(jsonString: string): SafeParseResult<StreamAgentPublicMessagePartFilePart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPublicMessagePartKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPublicMessagePartKind>;
+/** @internal */
+export declare const StreamAgentPublicMessagePartKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPublicMessagePartKind>;
+/** @internal */
+export declare const StreamAgentPublicMessagePartTextPart$inboundSchema: z.ZodType<StreamAgentPublicMessagePartTextPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPublicMessagePartTextPart$Outbound = {
+    kind: string;
+    text: string;
+};
+/** @internal */
+export declare const StreamAgentPublicMessagePartTextPart$outboundSchema: z.ZodType<StreamAgentPublicMessagePartTextPart$Outbound, z.ZodTypeDef, StreamAgentPublicMessagePartTextPart>;
+export declare function streamAgentPublicMessagePartTextPartToJSON(streamAgentPublicMessagePartTextPart: StreamAgentPublicMessagePartTextPart): string;
+export declare function streamAgentPublicMessagePartTextPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPublicMessagePartTextPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPublicMessagePart$inboundSchema: z.ZodType<StreamAgentPublicMessagePart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPublicMessagePart$Outbound = StreamAgentPublicMessagePartTextPart$Outbound | StreamAgentPublicMessagePartFilePart$Outbound | StreamAgentPublicMessagePartToolResultPart$Outbound;
+/** @internal */
+export declare const StreamAgentPublicMessagePart$outboundSchema: z.ZodType<StreamAgentPublicMessagePart$Outbound, z.ZodTypeDef, StreamAgentPublicMessagePart>;
+export declare function streamAgentPublicMessagePartToJSON(streamAgentPublicMessagePart: StreamAgentPublicMessagePart): string;
+export declare function streamAgentPublicMessagePartFromJSON(jsonString: string): SafeParseResult<StreamAgentPublicMessagePart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentA2AMessage$inboundSchema: z.ZodType<StreamAgentA2AMessage, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentA2AMessage$Outbound = {
+    messageId?: string | undefined;
+    role: string | string;
+    parts: Array<StreamAgentPublicMessagePartTextPart$Outbound | StreamAgentPublicMessagePartFilePart$Outbound | StreamAgentPublicMessagePartToolResultPart$Outbound>;
+};
+/** @internal */
+export declare const StreamAgentA2AMessage$outboundSchema: z.ZodType<StreamAgentA2AMessage$Outbound, z.ZodTypeDef, StreamAgentA2AMessage>;
+export declare function streamAgentA2AMessageToJSON(streamAgentA2AMessage: StreamAgentA2AMessage): string;
+export declare function streamAgentA2AMessageFromJSON(jsonString: string): SafeParseResult<StreamAgentA2AMessage, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentContact$inboundSchema: z.ZodType<StreamAgentContact, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentContact$Outbound = {
+    id: string;
+    display_name?: string | undefined;
+    email?: string | undefined;
+    metadata?: Array<{
+        [k: string]: any;
+    }> | undefined;
+    logo_url?: string | undefined;
+    tags?: Array<string> | undefined;
+};
+/** @internal */
+export declare const StreamAgentContact$outboundSchema: z.ZodType<StreamAgentContact$Outbound, z.ZodTypeDef, StreamAgentContact>;
+export declare function streamAgentContactToJSON(streamAgentContact: StreamAgentContact): string;
+export declare function streamAgentContactFromJSON(jsonString: string): SafeParseResult<StreamAgentContact, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentThread$inboundSchema: z.ZodType<StreamAgentThread, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentThread$Outbound = {
+    id: string;
+    tags?: Array<string> | undefined;
+};
+/** @internal */
+export declare const StreamAgentThread$outboundSchema: z.ZodType<StreamAgentThread$Outbound, z.ZodTypeDef, StreamAgentThread>;
+export declare function streamAgentThreadToJSON(streamAgentThread: StreamAgentThread): string;
+export declare function streamAgentThreadFromJSON(jsonString: string): SafeParseResult<StreamAgentThread, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentMemory$inboundSchema: z.ZodType<StreamAgentMemory, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentMemory$Outbound = {
+    entity_id: string;
+};
+/** @internal */
+export declare const StreamAgentMemory$outboundSchema: z.ZodType<StreamAgentMemory$Outbound, z.ZodTypeDef, StreamAgentMemory>;
+export declare function streamAgentMemoryToJSON(streamAgentMemory: StreamAgentMemory): string;
+export declare function streamAgentMemoryFromJSON(jsonString: string): SafeParseResult<StreamAgentMemory, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentRequestBody$inboundSchema: z.ZodType<StreamAgentRequestBody, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentRequestBody$Outbound = {
+    task_id?: string | undefined;
+    message: StreamAgentA2AMessage$Outbound;
+    variables?: {
+        [k: string]: any;
+    } | undefined;
+    contact?: StreamAgentContact$Outbound | undefined;
+    thread?: StreamAgentThread$Outbound | undefined;
     memory?: StreamAgentMemory$Outbound | undefined;
     metadata?: {
         [k: string]: any;
     } | undefined;
-    stream_timeout_seconds?: number | undefined;
+    stream_timeout_seconds?: number | undefined;
+};
+/** @internal */
+export declare const StreamAgentRequestBody$outboundSchema: z.ZodType<StreamAgentRequestBody$Outbound, z.ZodTypeDef, StreamAgentRequestBody>;
+export declare function streamAgentRequestBodyToJSON(streamAgentRequestBody: StreamAgentRequestBody): string;
+export declare function streamAgentRequestBodyFromJSON(jsonString: string): SafeParseResult<StreamAgentRequestBody, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentRequest$inboundSchema: z.ZodType<StreamAgentRequest, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentRequest$Outbound = {
+    key: string;
+    RequestBody?: StreamAgentRequestBody$Outbound | undefined;
+};
+/** @internal */
+export declare const StreamAgentRequest$outboundSchema: z.ZodType<StreamAgentRequest$Outbound, z.ZodTypeDef, StreamAgentRequest>;
+export declare function streamAgentRequestToJSON(streamAgentRequest: StreamAgentRequest): string;
+export declare function streamAgentRequestFromJSON(jsonString: string): SafeParseResult<StreamAgentRequest, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Data$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Data, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Data$Outbound = {
+    error: string;
+    code: string;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Data$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Data$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Data>;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody17DataToJSON(streamAgentDataAgentsResponse200TextEventStreamResponseBody17Data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Data): string;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody17DataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Data, SDKValidationError>;
+/** @internal */
+export declare const Data17$inboundSchema: z.ZodType<Data17, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Data17$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody17Data$Outbound;
+};
+/** @internal */
+export declare const Data17$outboundSchema: z.ZodType<Data17$Outbound, z.ZodTypeDef, Data17>;
+export declare function data17ToJSON(data17: Data17): string;
+export declare function data17FromJSON(jsonString: string): SafeParseResult<Data17, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Data$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Data, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Data$Outbound = {
+    message: string;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Data$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Data$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Data>;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody16DataToJSON(streamAgentDataAgentsResponse200TextEventStreamResponseBody16Data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Data): string;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody16DataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Data, SDKValidationError>;
+/** @internal */
+export declare const Data16$inboundSchema: z.ZodType<Data16, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Data16$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody16Data$Outbound;
+};
+/** @internal */
+export declare const Data16$outboundSchema: z.ZodType<Data16$Outbound, z.ZodTypeDef, Data16>;
+export declare function data16ToJSON(data16: Data16): string;
+export declare function data16FromJSON(jsonString: string): SafeParseResult<Data16, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Type>;
+/** @internal */
+export declare const DataError$inboundSchema: z.ZodType<DataError, z.ZodTypeDef, unknown>;
+/** @internal */
+export type DataError$Outbound = {
+    message: string;
+    stack?: string | undefined;
+};
+/** @internal */
+export declare const DataError$outboundSchema: z.ZodType<DataError$Outbound, z.ZodTypeDef, DataError>;
+export declare function dataErrorToJSON(dataError: DataError): string;
+export declare function dataErrorFromJSON(jsonString: string): SafeParseResult<DataError, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponseProduct$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponseProduct>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponseProduct$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponseProduct>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponseMemory$inboundSchema: z.ZodType<StreamAgentDataAgentsResponseMemory, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponseMemory$Outbound = {
+    entity_id: string;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponseMemory$outboundSchema: z.ZodType<StreamAgentDataAgentsResponseMemory$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponseMemory>;
+export declare function streamAgentDataAgentsResponseMemoryToJSON(streamAgentDataAgentsResponseMemory: StreamAgentDataAgentsResponseMemory): string;
+export declare function streamAgentDataAgentsResponseMemoryFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponseMemory, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponseToolExecutionContext$inboundSchema: z.ZodType<StreamAgentDataAgentsResponseToolExecutionContext, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponseToolExecutionContext$Outbound = {
+    action_id: string;
+    agent_tool_call_id: string;
+    workspace_id: string;
+    agent_manifest_id: string;
+    agent_execution_id: string;
+    product: string;
+    memory?: StreamAgentDataAgentsResponseMemory$Outbound | undefined;
+    parent_id?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponseToolExecutionContext$outboundSchema: z.ZodType<StreamAgentDataAgentsResponseToolExecutionContext$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponseToolExecutionContext>;
+export declare function streamAgentDataAgentsResponseToolExecutionContextToJSON(streamAgentDataAgentsResponseToolExecutionContext: StreamAgentDataAgentsResponseToolExecutionContext): string;
+export declare function streamAgentDataAgentsResponseToolExecutionContextFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponseToolExecutionContext, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Data$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Data, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Data$Outbound = {
+    error: DataError$Outbound;
+    action_type: string;
+    tool_execution_context: StreamAgentDataAgentsResponseToolExecutionContext$Outbound;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Data$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Data$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Data>;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody15DataToJSON(streamAgentDataAgentsResponse200TextEventStreamResponseBody15Data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Data): string;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody15DataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Data, SDKValidationError>;
+/** @internal */
+export declare const Data15$inboundSchema: z.ZodType<Data15, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Data15$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody15Data$Outbound;
+};
+/** @internal */
+export declare const Data15$outboundSchema: z.ZodType<Data15$Outbound, z.ZodTypeDef, Data15>;
+export declare function data15ToJSON(data15: Data15): string;
+export declare function data15FromJSON(jsonString: string): SafeParseResult<Data15, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsProduct$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsProduct>;
+/** @internal */
+export declare const StreamAgentDataAgentsProduct$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsProduct>;
+/** @internal */
+export declare const StreamAgentDataAgentsMemory$inboundSchema: z.ZodType<StreamAgentDataAgentsMemory, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsMemory$Outbound = {
+    entity_id: string;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsMemory$outboundSchema: z.ZodType<StreamAgentDataAgentsMemory$Outbound, z.ZodTypeDef, StreamAgentDataAgentsMemory>;
+export declare function streamAgentDataAgentsMemoryToJSON(streamAgentDataAgentsMemory: StreamAgentDataAgentsMemory): string;
+export declare function streamAgentDataAgentsMemoryFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsMemory, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsToolExecutionContext$inboundSchema: z.ZodType<StreamAgentDataAgentsToolExecutionContext, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsToolExecutionContext$Outbound = {
+    action_id: string;
+    agent_tool_call_id: string;
+    workspace_id: string;
+    agent_manifest_id: string;
+    agent_execution_id: string;
+    product: string;
+    memory?: StreamAgentDataAgentsMemory$Outbound | undefined;
+    parent_id?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsToolExecutionContext$outboundSchema: z.ZodType<StreamAgentDataAgentsToolExecutionContext$Outbound, z.ZodTypeDef, StreamAgentDataAgentsToolExecutionContext>;
+export declare function streamAgentDataAgentsToolExecutionContextToJSON(streamAgentDataAgentsToolExecutionContext: StreamAgentDataAgentsToolExecutionContext): string;
+export declare function streamAgentDataAgentsToolExecutionContextFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsToolExecutionContext, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Data$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Data, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Data$Outbound = {
+    result?: any | undefined;
+    action_type: string;
+    tool_execution_context: StreamAgentDataAgentsToolExecutionContext$Outbound;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Data$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Data$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Data>;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody14DataToJSON(streamAgentDataAgentsResponse200TextEventStreamResponseBody14Data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Data): string;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody14DataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Data, SDKValidationError>;
+/** @internal */
+export declare const Data14$inboundSchema: z.ZodType<Data14, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Data14$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody14Data$Outbound;
+};
+/** @internal */
+export declare const Data14$outboundSchema: z.ZodType<Data14$Outbound, z.ZodTypeDef, Data14>;
+export declare function data14ToJSON(data14: Data14): string;
+export declare function data14FromJSON(jsonString: string): SafeParseResult<Data14, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Type>;
+/** @internal */
+export declare const StreamAgentDataProduct$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataProduct>;
+/** @internal */
+export declare const StreamAgentDataProduct$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataProduct>;
+/** @internal */
+export declare const StreamAgentDataMemory$inboundSchema: z.ZodType<StreamAgentDataMemory, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataMemory$Outbound = {
+    entity_id: string;
+};
+/** @internal */
+export declare const StreamAgentDataMemory$outboundSchema: z.ZodType<StreamAgentDataMemory$Outbound, z.ZodTypeDef, StreamAgentDataMemory>;
+export declare function streamAgentDataMemoryToJSON(streamAgentDataMemory: StreamAgentDataMemory): string;
+export declare function streamAgentDataMemoryFromJSON(jsonString: string): SafeParseResult<StreamAgentDataMemory, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataToolExecutionContext$inboundSchema: z.ZodType<StreamAgentDataToolExecutionContext, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataToolExecutionContext$Outbound = {
+    action_id: string;
+    agent_tool_call_id: string;
+    workspace_id: string;
+    agent_manifest_id: string;
+    agent_execution_id: string;
+    product: string;
+    memory?: StreamAgentDataMemory$Outbound | undefined;
+    parent_id?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentDataToolExecutionContext$outboundSchema: z.ZodType<StreamAgentDataToolExecutionContext$Outbound, z.ZodTypeDef, StreamAgentDataToolExecutionContext>;
+export declare function streamAgentDataToolExecutionContextToJSON(streamAgentDataToolExecutionContext: StreamAgentDataToolExecutionContext): string;
+export declare function streamAgentDataToolExecutionContextFromJSON(jsonString: string): SafeParseResult<StreamAgentDataToolExecutionContext, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Data$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Data, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Data$Outbound = {
+    tool_id: string;
+    tool_key?: string | undefined;
+    tool_display_name?: string | undefined;
+    action_type: string;
+    tool_arguments: {
+        [k: string]: any;
+    };
+    tool_execution_context: StreamAgentDataToolExecutionContext$Outbound;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Data$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Data$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Data>;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody13DataToJSON(streamAgentDataAgentsResponse200TextEventStreamResponseBody13Data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Data): string;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody13DataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Data, SDKValidationError>;
+/** @internal */
+export declare const Data13$inboundSchema: z.ZodType<Data13, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Data13$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody13Data$Outbound;
+};
+/** @internal */
+export declare const Data13$outboundSchema: z.ZodType<Data13$Outbound, z.ZodTypeDef, Data13>;
+export declare function data13ToJSON(data13: Data13): string;
+export declare function data13FromJSON(jsonString: string): SafeParseResult<Data13, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponseRole$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponseRole>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponseRole$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponseRole>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage5Kind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage5Kind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage5Kind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage5Kind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseToolResultPart$inboundSchema: z.ZodType<StreamAgentPartsAgentsResponseToolResultPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsAgentsResponseToolResultPart$Outbound = {
+    kind: string;
+    tool_call_id: string;
+    result?: any | undefined;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseToolResultPart$outboundSchema: z.ZodType<StreamAgentPartsAgentsResponseToolResultPart$Outbound, z.ZodTypeDef, StreamAgentPartsAgentsResponseToolResultPart>;
+export declare function streamAgentPartsAgentsResponseToolResultPartToJSON(streamAgentPartsAgentsResponseToolResultPart: StreamAgentPartsAgentsResponseToolResultPart): string;
+export declare function streamAgentPartsAgentsResponseToolResultPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsAgentsResponseToolResultPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage4Kind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage4Kind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage4Kind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessage4Kind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseToolCallPart$inboundSchema: z.ZodType<StreamAgentPartsAgentsResponseToolCallPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsAgentsResponseToolCallPart$Outbound = {
+    kind: string;
+    tool_name: string;
+    tool_call_id: string;
+    arguments: {
+        [k: string]: any;
+    };
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseToolCallPart$outboundSchema: z.ZodType<StreamAgentPartsAgentsResponseToolCallPart$Outbound, z.ZodTypeDef, StreamAgentPartsAgentsResponseToolCallPart>;
+export declare function streamAgentPartsAgentsResponseToolCallPartToJSON(streamAgentPartsAgentsResponseToolCallPart: StreamAgentPartsAgentsResponseToolCallPart): string;
+export declare function streamAgentPartsAgentsResponseToolCallPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsAgentsResponseToolCallPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessageKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessageKind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessageKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataMessageKind>;
+/** @internal */
+export declare const StreamAgentFileAgentsResponse200FileInURIFormat$inboundSchema: z.ZodType<StreamAgentFileAgentsResponse200FileInURIFormat, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentFileAgentsResponse200FileInURIFormat$Outbound = {
+    uri: string;
+    mimeType?: string | undefined;
+    name?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentFileAgentsResponse200FileInURIFormat$outboundSchema: z.ZodType<StreamAgentFileAgentsResponse200FileInURIFormat$Outbound, z.ZodTypeDef, StreamAgentFileAgentsResponse200FileInURIFormat>;
+export declare function streamAgentFileAgentsResponse200FileInURIFormatToJSON(streamAgentFileAgentsResponse200FileInURIFormat: StreamAgentFileAgentsResponse200FileInURIFormat): string;
+export declare function streamAgentFileAgentsResponse200FileInURIFormatFromJSON(jsonString: string): SafeParseResult<StreamAgentFileAgentsResponse200FileInURIFormat, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentFileAgentsResponse200BinaryFormat$inboundSchema: z.ZodType<StreamAgentFileAgentsResponse200BinaryFormat, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentFileAgentsResponse200BinaryFormat$Outbound = {
+    bytes: string;
+    mimeType?: string | undefined;
+    name?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentFileAgentsResponse200BinaryFormat$outboundSchema: z.ZodType<StreamAgentFileAgentsResponse200BinaryFormat$Outbound, z.ZodTypeDef, StreamAgentFileAgentsResponse200BinaryFormat>;
+export declare function streamAgentFileAgentsResponse200BinaryFormatToJSON(streamAgentFileAgentsResponse200BinaryFormat: StreamAgentFileAgentsResponse200BinaryFormat): string;
+export declare function streamAgentFileAgentsResponse200BinaryFormatFromJSON(jsonString: string): SafeParseResult<StreamAgentFileAgentsResponse200BinaryFormat, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseFile$inboundSchema: z.ZodType<StreamAgentPartsAgentsResponseFile, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsAgentsResponseFile$Outbound = StreamAgentFileAgentsResponse200BinaryFormat$Outbound | StreamAgentFileAgentsResponse200FileInURIFormat$Outbound;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseFile$outboundSchema: z.ZodType<StreamAgentPartsAgentsResponseFile$Outbound, z.ZodTypeDef, StreamAgentPartsAgentsResponseFile>;
+export declare function streamAgentPartsAgentsResponseFileToJSON(streamAgentPartsAgentsResponseFile: StreamAgentPartsAgentsResponseFile): string;
+export declare function streamAgentPartsAgentsResponseFileFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsAgentsResponseFile, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseFilePart$inboundSchema: z.ZodType<StreamAgentPartsAgentsResponseFilePart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsAgentsResponseFilePart$Outbound = {
+    kind: string;
+    file: StreamAgentFileAgentsResponse200BinaryFormat$Outbound | StreamAgentFileAgentsResponse200FileInURIFormat$Outbound;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseFilePart$outboundSchema: z.ZodType<StreamAgentPartsAgentsResponseFilePart$Outbound, z.ZodTypeDef, StreamAgentPartsAgentsResponseFilePart>;
+export declare function streamAgentPartsAgentsResponseFilePartToJSON(streamAgentPartsAgentsResponseFilePart: StreamAgentPartsAgentsResponseFilePart): string;
+export declare function streamAgentPartsAgentsResponseFilePartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsAgentsResponseFilePart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataKind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12DataKind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseDataPart$inboundSchema: z.ZodType<StreamAgentPartsAgentsResponseDataPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsAgentsResponseDataPart$Outbound = {
+    kind: string;
+    data: {
+        [k: string]: any;
+    };
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseDataPart$outboundSchema: z.ZodType<StreamAgentPartsAgentsResponseDataPart$Outbound, z.ZodTypeDef, StreamAgentPartsAgentsResponseDataPart>;
+export declare function streamAgentPartsAgentsResponseDataPartToJSON(streamAgentPartsAgentsResponseDataPart: StreamAgentPartsAgentsResponseDataPart): string;
+export declare function streamAgentPartsAgentsResponseDataPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsAgentsResponseDataPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12Kind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12Kind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12Kind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData12Kind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseTextPart$inboundSchema: z.ZodType<StreamAgentPartsAgentsResponseTextPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsAgentsResponseTextPart$Outbound = {
+    kind: string;
+    text: string;
+};
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseTextPart$outboundSchema: z.ZodType<StreamAgentPartsAgentsResponseTextPart$Outbound, z.ZodTypeDef, StreamAgentPartsAgentsResponseTextPart>;
+export declare function streamAgentPartsAgentsResponseTextPartToJSON(streamAgentPartsAgentsResponseTextPart: StreamAgentPartsAgentsResponseTextPart): string;
+export declare function streamAgentPartsAgentsResponseTextPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsAgentsResponseTextPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponseParts$inboundSchema: z.ZodType<StreamAgentDataAgentsResponseParts, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponseParts$Outbound = StreamAgentPartsAgentsResponseToolCallPart$Outbound | StreamAgentPartsAgentsResponseTextPart$Outbound | StreamAgentPartsAgentsResponseDataPart$Outbound | StreamAgentPartsAgentsResponseFilePart$Outbound | StreamAgentPartsAgentsResponseToolResultPart$Outbound;
+/** @internal */
+export declare const StreamAgentDataAgentsResponseParts$outboundSchema: z.ZodType<StreamAgentDataAgentsResponseParts$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponseParts>;
+export declare function streamAgentDataAgentsResponsePartsToJSON(streamAgentDataAgentsResponseParts: StreamAgentDataAgentsResponseParts): string;
+export declare function streamAgentDataAgentsResponsePartsFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponseParts, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataMessage$inboundSchema: z.ZodType<StreamAgentDataMessage, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataMessage$Outbound = {
+    messageId?: string | undefined;
+    role: string;
+    parts: Array<StreamAgentPartsAgentsResponseToolCallPart$Outbound | StreamAgentPartsAgentsResponseTextPart$Outbound | StreamAgentPartsAgentsResponseDataPart$Outbound | StreamAgentPartsAgentsResponseFilePart$Outbound | StreamAgentPartsAgentsResponseToolResultPart$Outbound>;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const StreamAgentDataMessage$outboundSchema: z.ZodType<StreamAgentDataMessage$Outbound, z.ZodTypeDef, StreamAgentDataMessage>;
+export declare function streamAgentDataMessageToJSON(streamAgentDataMessage: StreamAgentDataMessage): string;
+export declare function streamAgentDataMessageFromJSON(jsonString: string): SafeParseResult<StreamAgentDataMessage, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Data$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Data, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Data$Outbound = {
+    workflowRunId: string;
+    spanId: string;
+    parentId: string;
+    message: Array<StreamAgentDataMessage$Outbound>;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Data$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Data$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Data>;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody12DataToJSON(streamAgentDataAgentsResponse200TextEventStreamResponseBody12Data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Data): string;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody12DataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Data, SDKValidationError>;
+/** @internal */
+export declare const Data12$inboundSchema: z.ZodType<Data12, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Data12$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody12Data$Outbound;
+};
+/** @internal */
+export declare const Data12$outboundSchema: z.ZodType<Data12$Outbound, z.ZodTypeDef, Data12>;
+export declare function data12ToJSON(data12: Data12): string;
+export declare function data12FromJSON(jsonString: string): SafeParseResult<Data12, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Data$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Data, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Data$Outbound = {
+    agent_id: string;
+    input: string;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Data$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Data$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Data>;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody11DataToJSON(streamAgentDataAgentsResponse200TextEventStreamResponseBody11Data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Data): string;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody11DataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Data, SDKValidationError>;
+/** @internal */
+export declare const Data11$inboundSchema: z.ZodType<Data11, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Data11$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody11Data$Outbound;
+};
+/** @internal */
+export declare const Data11$outboundSchema: z.ZodType<Data11$Outbound, z.ZodTypeDef, Data11>;
+export declare function data11ToJSON(data11: Data11): string;
+export declare function data11FromJSON(jsonString: string): SafeParseResult<Data11, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Data$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Data, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Data$Outbound = {
+    name: string;
+    agent_manifest_id: string;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Data$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Data$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Data>;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody10DataToJSON(streamAgentDataAgentsResponse200TextEventStreamResponseBody10Data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Data): string;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody10DataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Data, SDKValidationError>;
+/** @internal */
+export declare const Data10$inboundSchema: z.ZodType<Data10, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Data10$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody10Data$Outbound;
+};
+/** @internal */
+export declare const Data10$outboundSchema: z.ZodType<Data10$Outbound, z.ZodTypeDef, Data10>;
+export declare function data10ToJSON(data10: Data10): string;
+export declare function data10FromJSON(jsonString: string): SafeParseResult<Data10, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Data$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Data, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Data$Outbound = {};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Data$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Data$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Data>;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody9DataToJSON(streamAgentDataAgentsResponse200TextEventStreamResponseBody9Data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Data): string;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody9DataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Data, SDKValidationError>;
+/** @internal */
+export declare const Data9$inboundSchema: z.ZodType<Data9, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Data9$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody9Data$Outbound;
+};
+/** @internal */
+export declare const Data9$outboundSchema: z.ZodType<Data9$Outbound, z.ZodTypeDef, Data9>;
+export declare function data9ToJSON(data9: Data9): string;
+export declare function data9FromJSON(jsonString: string): SafeParseResult<Data9, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Data$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Data, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Data$Outbound = {};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Data$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Data$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Data>;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody8DataToJSON(streamAgentDataAgentsResponse200TextEventStreamResponseBody8Data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Data): string;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody8DataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Data, SDKValidationError>;
+/** @internal */
+export declare const Data8$inboundSchema: z.ZodType<Data8, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Data8$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody8Data$Outbound;
+};
+/** @internal */
+export declare const Data8$outboundSchema: z.ZodType<Data8$Outbound, z.ZodTypeDef, Data8>;
+export declare function data8ToJSON(data8: Data8): string;
+export declare function data8FromJSON(jsonString: string): SafeParseResult<Data8, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Type>;
+/** @internal */
+export declare const DataReview$inboundSchema: z.ZodNativeEnum<typeof DataReview>;
+/** @internal */
+export declare const DataReview$outboundSchema: z.ZodNativeEnum<typeof DataReview>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Data$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Data, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Data$Outbound = {
+    agent_id: string;
+    action_id: string;
+    agent_tool_call_id: string;
+    review: string;
+    mock_output?: {
+        [k: string]: any;
+    } | undefined;
+    review_source?: string | undefined;
+    reviewed_by_id?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Data$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Data$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Data>;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody7DataToJSON(streamAgentDataAgentsResponse200TextEventStreamResponseBody7Data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Data): string;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBody7DataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Data, SDKValidationError>;
+/** @internal */
+export declare const Data7$inboundSchema: z.ZodType<Data7, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Data7$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBody7Data$Outbound;
+};
+/** @internal */
+export declare const Data7$outboundSchema: z.ZodType<Data7$Outbound, z.ZodTypeDef, Data7>;
+export declare function data7ToJSON(data7: Data7): string;
+export declare function data7FromJSON(jsonString: string): SafeParseResult<Data7, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBodyType>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBodyType$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBodyType>;
+/** @internal */
+export declare const StreamAgentDataConditions$inboundSchema: z.ZodType<StreamAgentDataConditions, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataConditions$Outbound = {
+    condition: string;
+    operator: string;
+    value: string;
+};
+/** @internal */
+export declare const StreamAgentDataConditions$outboundSchema: z.ZodType<StreamAgentDataConditions$Outbound, z.ZodTypeDef, StreamAgentDataConditions>;
+export declare function streamAgentDataConditionsToJSON(streamAgentDataConditions: StreamAgentDataConditions): string;
+export declare function streamAgentDataConditionsFromJSON(jsonString: string): SafeParseResult<StreamAgentDataConditions, SDKValidationError>;
+/** @internal */
+export declare const DataTool$inboundSchema: z.ZodType<DataTool, z.ZodTypeDef, unknown>;
+/** @internal */
+export type DataTool$Outbound = {
+    id: string;
+    key?: string | undefined;
+    action_type: string;
+    display_name?: string | undefined;
+    description?: string | undefined;
+    requires_approval: boolean;
+    tool_id?: string | undefined;
+    conditions?: Array<StreamAgentDataConditions$Outbound> | undefined;
+    timeout: number;
+};
+/** @internal */
+export declare const DataTool$outboundSchema: z.ZodType<DataTool$Outbound, z.ZodTypeDef, DataTool>;
+export declare function dataToolToJSON(dataTool: DataTool): string;
+export declare function dataToolFromJSON(jsonString: string): SafeParseResult<DataTool, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBodyData$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBodyData, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200TextEventStreamResponseBodyData$Outbound = {
+    agent_id: string;
+    action_id: string;
+    requires_approval: boolean;
+    tool: DataTool$Outbound;
+    input: {
+        [k: string]: any;
+    };
+    agent_tool_call_id: string;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBodyData$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamResponseBodyData$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200TextEventStreamResponseBodyData>;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBodyDataToJSON(streamAgentDataAgentsResponse200TextEventStreamResponseBodyData: StreamAgentDataAgentsResponse200TextEventStreamResponseBodyData): string;
+export declare function streamAgentDataAgentsResponse200TextEventStreamResponseBodyDataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200TextEventStreamResponseBodyData, SDKValidationError>;
+/** @internal */
+export declare const Data6$inboundSchema: z.ZodType<Data6, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Data6$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamResponseBodyData$Outbound;
+};
+/** @internal */
+export declare const Data6$outboundSchema: z.ZodType<Data6$Outbound, z.ZodTypeDef, Data6>;
+export declare function data6ToJSON(data6: Data6): string;
+export declare function data6FromJSON(jsonString: string): SafeParseResult<Data6, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamType$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamType>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamType$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamType>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamData$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamData, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200TextEventStreamData$Outbound = {
+    error: string;
+    code: number;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamData$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200TextEventStreamData$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200TextEventStreamData>;
+export declare function streamAgentDataAgentsResponse200TextEventStreamDataToJSON(streamAgentDataAgentsResponse200TextEventStreamData: StreamAgentDataAgentsResponse200TextEventStreamData): string;
+export declare function streamAgentDataAgentsResponse200TextEventStreamDataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200TextEventStreamData, SDKValidationError>;
+/** @internal */
+export declare const Data5$inboundSchema: z.ZodType<Data5, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Data5$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200TextEventStreamData$Outbound;
+};
+/** @internal */
+export declare const Data5$outboundSchema: z.ZodType<Data5$Outbound, z.ZodTypeDef, Data5>;
+export declare function data5ToJSON(data5: Data5): string;
+export declare function data5FromJSON(jsonString: string): SafeParseResult<Data5, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200Type>;
+/** @internal */
+export declare const DataFinishReason$inboundSchema: z.ZodNativeEnum<typeof DataFinishReason>;
+/** @internal */
+export declare const DataFinishReason$outboundSchema: z.ZodNativeEnum<typeof DataFinishReason>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody4Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody4Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody4Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody4Type>;
+/** @internal */
+export declare const StreamAgentDataFunction$inboundSchema: z.ZodType<StreamAgentDataFunction, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataFunction$Outbound = {
+    name?: string | undefined;
+    arguments?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentDataFunction$outboundSchema: z.ZodType<StreamAgentDataFunction$Outbound, z.ZodTypeDef, StreamAgentDataFunction>;
+export declare function streamAgentDataFunctionToJSON(streamAgentDataFunction: StreamAgentDataFunction): string;
+export declare function streamAgentDataFunctionFromJSON(jsonString: string): SafeParseResult<StreamAgentDataFunction, SDKValidationError>;
+/** @internal */
+export declare const DataPendingToolCalls$inboundSchema: z.ZodType<DataPendingToolCalls, z.ZodTypeDef, unknown>;
+/** @internal */
+export type DataPendingToolCalls$Outbound = {
+    id: string;
+    type: string;
+    function: StreamAgentDataFunction$Outbound;
+};
+/** @internal */
+export declare const DataPendingToolCalls$outboundSchema: z.ZodType<DataPendingToolCalls$Outbound, z.ZodTypeDef, DataPendingToolCalls>;
+export declare function dataPendingToolCallsToJSON(dataPendingToolCalls: DataPendingToolCalls): string;
+export declare function dataPendingToolCallsFromJSON(jsonString: string): SafeParseResult<DataPendingToolCalls, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200Data$inboundSchema: z.ZodType<StreamAgentDataAgentsResponse200Data, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponse200Data$Outbound = {
+    last_message: string;
+    finish_reason: string;
+    pending_tool_calls?: Array<DataPendingToolCalls$Outbound> | undefined;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200Data$outboundSchema: z.ZodType<StreamAgentDataAgentsResponse200Data$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponse200Data>;
+export declare function streamAgentDataAgentsResponse200DataToJSON(streamAgentDataAgentsResponse200Data: StreamAgentDataAgentsResponse200Data): string;
+export declare function streamAgentDataAgentsResponse200DataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponse200Data, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentData4$inboundSchema: z.ZodType<StreamAgentData4, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentData4$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponse200Data$Outbound;
+};
+/** @internal */
+export declare const StreamAgentData4$outboundSchema: z.ZodType<StreamAgentData4$Outbound, z.ZodTypeDef, StreamAgentData4>;
+export declare function streamAgentData4ToJSON(streamAgentData4: StreamAgentData4): string;
+export declare function streamAgentData4FromJSON(jsonString: string): SafeParseResult<StreamAgentData4, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponseType$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponseType>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponseType$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponseType>;
+/** @internal */
+export declare const StreamAgentDataAgentsRole$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsRole>;
+/** @internal */
+export declare const StreamAgentDataAgentsRole$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsRole>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataMessageDifferenceKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataMessageDifferenceKind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataMessageDifferenceKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataMessageDifferenceKind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsToolResultPart$inboundSchema: z.ZodType<StreamAgentPartsAgentsToolResultPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsAgentsToolResultPart$Outbound = {
+    kind: string;
+    tool_call_id: string;
+    result?: any | undefined;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const StreamAgentPartsAgentsToolResultPart$outboundSchema: z.ZodType<StreamAgentPartsAgentsToolResultPart$Outbound, z.ZodTypeDef, StreamAgentPartsAgentsToolResultPart>;
+export declare function streamAgentPartsAgentsToolResultPartToJSON(streamAgentPartsAgentsToolResultPart: StreamAgentPartsAgentsToolResultPart): string;
+export declare function streamAgentPartsAgentsToolResultPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsAgentsToolResultPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataKind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3DataKind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsToolCallPart$inboundSchema: z.ZodType<StreamAgentPartsAgentsToolCallPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsAgentsToolCallPart$Outbound = {
+    kind: string;
+    tool_name: string;
+    tool_call_id: string;
+    arguments: {
+        [k: string]: any;
+    };
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const StreamAgentPartsAgentsToolCallPart$outboundSchema: z.ZodType<StreamAgentPartsAgentsToolCallPart$Outbound, z.ZodTypeDef, StreamAgentPartsAgentsToolCallPart>;
+export declare function streamAgentPartsAgentsToolCallPartToJSON(streamAgentPartsAgentsToolCallPart: StreamAgentPartsAgentsToolCallPart): string;
+export declare function streamAgentPartsAgentsToolCallPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsAgentsToolCallPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3Kind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3Kind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3Kind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyData3Kind>;
+/** @internal */
+export declare const StreamAgentFileAgentsResponseFileInURIFormat$inboundSchema: z.ZodType<StreamAgentFileAgentsResponseFileInURIFormat, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentFileAgentsResponseFileInURIFormat$Outbound = {
+    uri: string;
+    mimeType?: string | undefined;
+    name?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentFileAgentsResponseFileInURIFormat$outboundSchema: z.ZodType<StreamAgentFileAgentsResponseFileInURIFormat$Outbound, z.ZodTypeDef, StreamAgentFileAgentsResponseFileInURIFormat>;
+export declare function streamAgentFileAgentsResponseFileInURIFormatToJSON(streamAgentFileAgentsResponseFileInURIFormat: StreamAgentFileAgentsResponseFileInURIFormat): string;
+export declare function streamAgentFileAgentsResponseFileInURIFormatFromJSON(jsonString: string): SafeParseResult<StreamAgentFileAgentsResponseFileInURIFormat, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentFileAgentsResponseBinaryFormat$inboundSchema: z.ZodType<StreamAgentFileAgentsResponseBinaryFormat, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentFileAgentsResponseBinaryFormat$Outbound = {
+    bytes: string;
+    mimeType?: string | undefined;
+    name?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentFileAgentsResponseBinaryFormat$outboundSchema: z.ZodType<StreamAgentFileAgentsResponseBinaryFormat$Outbound, z.ZodTypeDef, StreamAgentFileAgentsResponseBinaryFormat>;
+export declare function streamAgentFileAgentsResponseBinaryFormatToJSON(streamAgentFileAgentsResponseBinaryFormat: StreamAgentFileAgentsResponseBinaryFormat): string;
+export declare function streamAgentFileAgentsResponseBinaryFormatFromJSON(jsonString: string): SafeParseResult<StreamAgentFileAgentsResponseBinaryFormat, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsFile$inboundSchema: z.ZodType<StreamAgentPartsAgentsFile, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsAgentsFile$Outbound = StreamAgentFileAgentsResponseBinaryFormat$Outbound | StreamAgentFileAgentsResponseFileInURIFormat$Outbound;
+/** @internal */
+export declare const StreamAgentPartsAgentsFile$outboundSchema: z.ZodType<StreamAgentPartsAgentsFile$Outbound, z.ZodTypeDef, StreamAgentPartsAgentsFile>;
+export declare function streamAgentPartsAgentsFileToJSON(streamAgentPartsAgentsFile: StreamAgentPartsAgentsFile): string;
+export declare function streamAgentPartsAgentsFileFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsAgentsFile, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsFilePart$inboundSchema: z.ZodType<StreamAgentPartsAgentsFilePart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsAgentsFilePart$Outbound = {
+    kind: string;
+    file: StreamAgentFileAgentsResponseBinaryFormat$Outbound | StreamAgentFileAgentsResponseFileInURIFormat$Outbound;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
 };
 /** @internal */
-export declare const StreamAgentRequestBody$outboundSchema: z.ZodType<StreamAgentRequestBody$Outbound, z.ZodTypeDef, StreamAgentRequestBody>;
-export declare function streamAgentRequestBodyToJSON(streamAgentRequestBody: StreamAgentRequestBody): string;
-export declare function streamAgentRequestBodyFromJSON(jsonString: string): SafeParseResult<StreamAgentRequestBody, SDKValidationError>;
+export declare const StreamAgentPartsAgentsFilePart$outboundSchema: z.ZodType<StreamAgentPartsAgentsFilePart$Outbound, z.ZodTypeDef, StreamAgentPartsAgentsFilePart>;
+export declare function streamAgentPartsAgentsFilePartToJSON(streamAgentPartsAgentsFilePart: StreamAgentPartsAgentsFilePart): string;
+export declare function streamAgentPartsAgentsFilePartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsAgentsFilePart, SDKValidationError>;
 /** @internal */
-export declare const StreamAgentRequest$inboundSchema: z.ZodType<StreamAgentRequest, z.ZodTypeDef, unknown>;
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyDataKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyDataKind>;
 /** @internal */
-export type StreamAgentRequest$Outbound = {
-    key: string;
-    RequestBody?: StreamAgentRequestBody$Outbound | undefined;
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyDataKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyDataKind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsDataPart$inboundSchema: z.ZodType<StreamAgentPartsAgentsDataPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsAgentsDataPart$Outbound = {
+    kind: string;
+    data: {
+        [k: string]: any;
+    };
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
 };
 /** @internal */
-export declare const StreamAgentRequest$outboundSchema: z.ZodType<StreamAgentRequest$Outbound, z.ZodTypeDef, StreamAgentRequest>;
-export declare function streamAgentRequestToJSON(streamAgentRequest: StreamAgentRequest): string;
-export declare function streamAgentRequestFromJSON(jsonString: string): SafeParseResult<StreamAgentRequest, SDKValidationError>;
+export declare const StreamAgentPartsAgentsDataPart$outboundSchema: z.ZodType<StreamAgentPartsAgentsDataPart$Outbound, z.ZodTypeDef, StreamAgentPartsAgentsDataPart>;
+export declare function streamAgentPartsAgentsDataPartToJSON(streamAgentPartsAgentsDataPart: StreamAgentPartsAgentsDataPart): string;
+export declare function streamAgentPartsAgentsDataPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsAgentsDataPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyKind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamResponseBodyKind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsTextPart$inboundSchema: z.ZodType<StreamAgentPartsAgentsTextPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsAgentsTextPart$Outbound = {
+    kind: string;
+    text: string;
+};
+/** @internal */
+export declare const StreamAgentPartsAgentsTextPart$outboundSchema: z.ZodType<StreamAgentPartsAgentsTextPart$Outbound, z.ZodTypeDef, StreamAgentPartsAgentsTextPart>;
+export declare function streamAgentPartsAgentsTextPartToJSON(streamAgentPartsAgentsTextPart: StreamAgentPartsAgentsTextPart): string;
+export declare function streamAgentPartsAgentsTextPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsAgentsTextPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsParts$inboundSchema: z.ZodType<StreamAgentDataAgentsParts, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsParts$Outbound = StreamAgentPartsAgentsToolCallPart$Outbound | StreamAgentPartsAgentsTextPart$Outbound | StreamAgentPartsAgentsDataPart$Outbound | StreamAgentPartsAgentsFilePart$Outbound | StreamAgentPartsAgentsToolResultPart$Outbound;
+/** @internal */
+export declare const StreamAgentDataAgentsParts$outboundSchema: z.ZodType<StreamAgentDataAgentsParts$Outbound, z.ZodTypeDef, StreamAgentDataAgentsParts>;
+export declare function streamAgentDataAgentsPartsToJSON(streamAgentDataAgentsParts: StreamAgentDataAgentsParts): string;
+export declare function streamAgentDataAgentsPartsFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsParts, SDKValidationError>;
+/** @internal */
+export declare const DataMessageDifference$inboundSchema: z.ZodType<DataMessageDifference, z.ZodTypeDef, unknown>;
+/** @internal */
+export type DataMessageDifference$Outbound = {
+    messageId: string;
+    role: string;
+    parts: Array<StreamAgentPartsAgentsToolCallPart$Outbound | StreamAgentPartsAgentsTextPart$Outbound | StreamAgentPartsAgentsDataPart$Outbound | StreamAgentPartsAgentsFilePart$Outbound | StreamAgentPartsAgentsToolResultPart$Outbound>;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+    agent_id: string;
+    agent_execution_id: string;
+    workspace_id: string;
+};
+/** @internal */
+export declare const DataMessageDifference$outboundSchema: z.ZodType<DataMessageDifference$Outbound, z.ZodTypeDef, DataMessageDifference>;
+export declare function dataMessageDifferenceToJSON(dataMessageDifference: DataMessageDifference): string;
+export declare function dataMessageDifferenceFromJSON(jsonString: string): SafeParseResult<DataMessageDifference, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataFinishReason$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataFinishReason>;
+/** @internal */
+export declare const StreamAgentDataFinishReason$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataFinishReason>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody3Type$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody3Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200TextEventStreamResponseBody3Type$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200TextEventStreamResponseBody3Type>;
+/** @internal */
+export declare const StreamAgentDataAgentsFunction$inboundSchema: z.ZodType<StreamAgentDataAgentsFunction, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsFunction$Outbound = {
+    name?: string | undefined;
+    arguments?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsFunction$outboundSchema: z.ZodType<StreamAgentDataAgentsFunction$Outbound, z.ZodTypeDef, StreamAgentDataAgentsFunction>;
+export declare function streamAgentDataAgentsFunctionToJSON(streamAgentDataAgentsFunction: StreamAgentDataAgentsFunction): string;
+export declare function streamAgentDataAgentsFunctionFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsFunction, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataToolCalls$inboundSchema: z.ZodType<StreamAgentDataToolCalls, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataToolCalls$Outbound = {
+    id?: string | undefined;
+    type?: string | undefined;
+    function?: StreamAgentDataAgentsFunction$Outbound | undefined;
+};
+/** @internal */
+export declare const StreamAgentDataToolCalls$outboundSchema: z.ZodType<StreamAgentDataToolCalls$Outbound, z.ZodTypeDef, StreamAgentDataToolCalls>;
+export declare function streamAgentDataToolCallsToJSON(streamAgentDataToolCalls: StreamAgentDataToolCalls): string;
+export declare function streamAgentDataToolCallsFromJSON(jsonString: string): SafeParseResult<StreamAgentDataToolCalls, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200Role$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200Role>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponse200Role$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsResponse200Role>;
+/** @internal */
+export declare const StreamAgentDataAudio$inboundSchema: z.ZodType<StreamAgentDataAudio, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAudio$Outbound = {
+    id: string;
+    expires_at: number;
+    data: string;
+    transcript: string;
+};
+/** @internal */
+export declare const StreamAgentDataAudio$outboundSchema: z.ZodType<StreamAgentDataAudio$Outbound, z.ZodTypeDef, StreamAgentDataAudio>;
+export declare function streamAgentDataAudioToJSON(streamAgentDataAudio: StreamAgentDataAudio): string;
+export declare function streamAgentDataAudioFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAudio, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsMessage$inboundSchema: z.ZodType<StreamAgentDataAgentsMessage, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsMessage$Outbound = {
+    content?: string | null | undefined;
+    refusal?: string | null | undefined;
+    tool_calls?: Array<StreamAgentDataToolCalls$Outbound> | undefined;
+    role?: string | undefined;
+    reasoning?: string | null | undefined;
+    reasoning_signature?: string | null | undefined;
+    redacted_reasoning?: string | undefined;
+    audio?: StreamAgentDataAudio$Outbound | null | undefined;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsMessage$outboundSchema: z.ZodType<StreamAgentDataAgentsMessage$Outbound, z.ZodTypeDef, StreamAgentDataAgentsMessage>;
+export declare function streamAgentDataAgentsMessageToJSON(streamAgentDataAgentsMessage: StreamAgentDataAgentsMessage): string;
+export declare function streamAgentDataAgentsMessageFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsMessage, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataTopLogprobs$inboundSchema: z.ZodType<StreamAgentDataTopLogprobs, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataTopLogprobs$Outbound = {
+    token: string;
+    logprob: number;
+    bytes: Array<number> | null;
+};
+/** @internal */
+export declare const StreamAgentDataTopLogprobs$outboundSchema: z.ZodType<StreamAgentDataTopLogprobs$Outbound, z.ZodTypeDef, StreamAgentDataTopLogprobs>;
+export declare function streamAgentDataTopLogprobsToJSON(streamAgentDataTopLogprobs: StreamAgentDataTopLogprobs): string;
+export declare function streamAgentDataTopLogprobsFromJSON(jsonString: string): SafeParseResult<StreamAgentDataTopLogprobs, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataContent$inboundSchema: z.ZodType<StreamAgentDataContent, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataContent$Outbound = {
+    token: string;
+    logprob: number;
+    bytes: Array<number> | null;
+    top_logprobs: Array<StreamAgentDataTopLogprobs$Outbound>;
+};
+/** @internal */
+export declare const StreamAgentDataContent$outboundSchema: z.ZodType<StreamAgentDataContent$Outbound, z.ZodTypeDef, StreamAgentDataContent>;
+export declare function streamAgentDataContentToJSON(streamAgentDataContent: StreamAgentDataContent): string;
+export declare function streamAgentDataContentFromJSON(jsonString: string): SafeParseResult<StreamAgentDataContent, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsTopLogprobs$inboundSchema: z.ZodType<StreamAgentDataAgentsTopLogprobs, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsTopLogprobs$Outbound = {
+    token: string;
+    logprob: number;
+    bytes: Array<number> | null;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsTopLogprobs$outboundSchema: z.ZodType<StreamAgentDataAgentsTopLogprobs$Outbound, z.ZodTypeDef, StreamAgentDataAgentsTopLogprobs>;
+export declare function streamAgentDataAgentsTopLogprobsToJSON(streamAgentDataAgentsTopLogprobs: StreamAgentDataAgentsTopLogprobs): string;
+export declare function streamAgentDataAgentsTopLogprobsFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsTopLogprobs, SDKValidationError>;
+/** @internal */
+export declare const DataRefusal$inboundSchema: z.ZodType<DataRefusal, z.ZodTypeDef, unknown>;
+/** @internal */
+export type DataRefusal$Outbound = {
+    token: string;
+    logprob: number;
+    bytes: Array<number> | null;
+    top_logprobs: Array<StreamAgentDataAgentsTopLogprobs$Outbound>;
+};
+/** @internal */
+export declare const DataRefusal$outboundSchema: z.ZodType<DataRefusal$Outbound, z.ZodTypeDef, DataRefusal>;
+export declare function dataRefusalToJSON(dataRefusal: DataRefusal): string;
+export declare function dataRefusalFromJSON(jsonString: string): SafeParseResult<DataRefusal, SDKValidationError>;
+/** @internal */
+export declare const DataLogprobs$inboundSchema: z.ZodType<DataLogprobs, z.ZodTypeDef, unknown>;
+/** @internal */
+export type DataLogprobs$Outbound = {
+    content: Array<StreamAgentDataContent$Outbound> | null;
+    refusal: Array<DataRefusal$Outbound> | null;
+};
+/** @internal */
+export declare const DataLogprobs$outboundSchema: z.ZodType<DataLogprobs$Outbound, z.ZodTypeDef, DataLogprobs>;
+export declare function dataLogprobsToJSON(dataLogprobs: DataLogprobs): string;
+export declare function dataLogprobsFromJSON(jsonString: string): SafeParseResult<DataLogprobs, SDKValidationError>;
+/** @internal */
+export declare const DataChoice$inboundSchema: z.ZodType<DataChoice, z.ZodTypeDef, unknown>;
+/** @internal */
+export type DataChoice$Outbound = {
+    finish_reason: string | null;
+    index: number;
+    message: StreamAgentDataAgentsMessage$Outbound;
+    logprobs?: DataLogprobs$Outbound | null | undefined;
+};
+/** @internal */
+export declare const DataChoice$outboundSchema: z.ZodType<DataChoice$Outbound, z.ZodTypeDef, DataChoice>;
+export declare function dataChoiceToJSON(dataChoice: DataChoice): string;
+export declare function dataChoiceFromJSON(jsonString: string): SafeParseResult<DataChoice, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsResponseData$inboundSchema: z.ZodType<StreamAgentDataAgentsResponseData, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsResponseData$Outbound = {
+    agent_id: string;
+    message_difference: {
+        [k: string]: DataMessageDifference$Outbound;
+    };
+    choice?: DataChoice$Outbound | undefined;
+    choiceIndex?: number | undefined;
+    iteration: number;
+    accumulated_execution_time: number;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsResponseData$outboundSchema: z.ZodType<StreamAgentDataAgentsResponseData$Outbound, z.ZodTypeDef, StreamAgentDataAgentsResponseData>;
+export declare function streamAgentDataAgentsResponseDataToJSON(streamAgentDataAgentsResponseData: StreamAgentDataAgentsResponseData): string;
+export declare function streamAgentDataAgentsResponseDataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsResponseData, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentData3$inboundSchema: z.ZodType<StreamAgentData3, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentData3$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsResponseData$Outbound;
+};
+/** @internal */
+export declare const StreamAgentData3$outboundSchema: z.ZodType<StreamAgentData3$Outbound, z.ZodTypeDef, StreamAgentData3>;
+export declare function streamAgentData3ToJSON(streamAgentData3: StreamAgentData3): string;
+export declare function streamAgentData3FromJSON(jsonString: string): SafeParseResult<StreamAgentData3, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsType$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsType>;
+/** @internal */
+export declare const StreamAgentDataAgentsType$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsType>;
+/** @internal */
+export declare const StreamAgentDataRole$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataRole>;
+/** @internal */
+export declare const StreamAgentDataRole$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataRole>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamKind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200TextEventStreamKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200TextEventStreamKind>;
+/** @internal */
+export declare const StreamAgentPartsToolResultPart$inboundSchema: z.ZodType<StreamAgentPartsToolResultPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsToolResultPart$Outbound = {
+    kind: string;
+    tool_call_id: string;
+    result?: any | undefined;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const StreamAgentPartsToolResultPart$outboundSchema: z.ZodType<StreamAgentPartsToolResultPart$Outbound, z.ZodTypeDef, StreamAgentPartsToolResultPart>;
+export declare function streamAgentPartsToolResultPartToJSON(streamAgentPartsToolResultPart: StreamAgentPartsToolResultPart): string;
+export declare function streamAgentPartsToolResultPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsToolResultPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200Kind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200Kind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponse200Kind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponse200Kind>;
+/** @internal */
+export declare const StreamAgentPartsToolCallPart$inboundSchema: z.ZodType<StreamAgentPartsToolCallPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsToolCallPart$Outbound = {
+    kind: string;
+    tool_name: string;
+    tool_call_id: string;
+    arguments: {
+        [k: string]: any;
+    };
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const StreamAgentPartsToolCallPart$outboundSchema: z.ZodType<StreamAgentPartsToolCallPart$Outbound, z.ZodTypeDef, StreamAgentPartsToolCallPart>;
+export declare function streamAgentPartsToolCallPartToJSON(streamAgentPartsToolCallPart: StreamAgentPartsToolCallPart): string;
+export declare function streamAgentPartsToolCallPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsToolCallPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponseKind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsResponseKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsResponseKind>;
+/** @internal */
+export declare const StreamAgentFileAgentsFileInURIFormat$inboundSchema: z.ZodType<StreamAgentFileAgentsFileInURIFormat, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentFileAgentsFileInURIFormat$Outbound = {
+    uri: string;
+    mimeType?: string | undefined;
+    name?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentFileAgentsFileInURIFormat$outboundSchema: z.ZodType<StreamAgentFileAgentsFileInURIFormat$Outbound, z.ZodTypeDef, StreamAgentFileAgentsFileInURIFormat>;
+export declare function streamAgentFileAgentsFileInURIFormatToJSON(streamAgentFileAgentsFileInURIFormat: StreamAgentFileAgentsFileInURIFormat): string;
+export declare function streamAgentFileAgentsFileInURIFormatFromJSON(jsonString: string): SafeParseResult<StreamAgentFileAgentsFileInURIFormat, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentFileAgentsBinaryFormat$inboundSchema: z.ZodType<StreamAgentFileAgentsBinaryFormat, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentFileAgentsBinaryFormat$Outbound = {
+    bytes: string;
+    mimeType?: string | undefined;
+    name?: string | undefined;
+};
+/** @internal */
+export declare const StreamAgentFileAgentsBinaryFormat$outboundSchema: z.ZodType<StreamAgentFileAgentsBinaryFormat$Outbound, z.ZodTypeDef, StreamAgentFileAgentsBinaryFormat>;
+export declare function streamAgentFileAgentsBinaryFormatToJSON(streamAgentFileAgentsBinaryFormat: StreamAgentFileAgentsBinaryFormat): string;
+export declare function streamAgentFileAgentsBinaryFormatFromJSON(jsonString: string): SafeParseResult<StreamAgentFileAgentsBinaryFormat, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsFile$inboundSchema: z.ZodType<StreamAgentPartsFile, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsFile$Outbound = StreamAgentFileAgentsBinaryFormat$Outbound | StreamAgentFileAgentsFileInURIFormat$Outbound;
+/** @internal */
+export declare const StreamAgentPartsFile$outboundSchema: z.ZodType<StreamAgentPartsFile$Outbound, z.ZodTypeDef, StreamAgentPartsFile>;
+export declare function streamAgentPartsFileToJSON(streamAgentPartsFile: StreamAgentPartsFile): string;
+export declare function streamAgentPartsFileFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsFile, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsFilePart$inboundSchema: z.ZodType<StreamAgentPartsFilePart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsFilePart$Outbound = {
+    kind: string;
+    file: StreamAgentFileAgentsBinaryFormat$Outbound | StreamAgentFileAgentsFileInURIFormat$Outbound;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const StreamAgentPartsFilePart$outboundSchema: z.ZodType<StreamAgentPartsFilePart$Outbound, z.ZodTypeDef, StreamAgentPartsFilePart>;
+export declare function streamAgentPartsFilePartToJSON(streamAgentPartsFilePart: StreamAgentPartsFilePart): string;
+export declare function streamAgentPartsFilePartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsFilePart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsAgentsKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsKind>;
+/** @internal */
+export declare const StreamAgentPartsAgentsKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsAgentsKind>;
+/** @internal */
+export declare const StreamAgentPartsDataPart$inboundSchema: z.ZodType<StreamAgentPartsDataPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsDataPart$Outbound = {
+    kind: string;
+    data: {
+        [k: string]: any;
+    };
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const StreamAgentPartsDataPart$outboundSchema: z.ZodType<StreamAgentPartsDataPart$Outbound, z.ZodTypeDef, StreamAgentPartsDataPart>;
+export declare function streamAgentPartsDataPartToJSON(streamAgentPartsDataPart: StreamAgentPartsDataPart): string;
+export declare function streamAgentPartsDataPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsDataPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentPartsKind$inboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsKind>;
+/** @internal */
+export declare const StreamAgentPartsKind$outboundSchema: z.ZodNativeEnum<typeof StreamAgentPartsKind>;
+/** @internal */
+export declare const StreamAgentPartsTextPart$inboundSchema: z.ZodType<StreamAgentPartsTextPart, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentPartsTextPart$Outbound = {
+    kind: string;
+    text: string;
+};
+/** @internal */
+export declare const StreamAgentPartsTextPart$outboundSchema: z.ZodType<StreamAgentPartsTextPart$Outbound, z.ZodTypeDef, StreamAgentPartsTextPart>;
+export declare function streamAgentPartsTextPartToJSON(streamAgentPartsTextPart: StreamAgentPartsTextPart): string;
+export declare function streamAgentPartsTextPartFromJSON(jsonString: string): SafeParseResult<StreamAgentPartsTextPart, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataParts$inboundSchema: z.ZodType<StreamAgentDataParts, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataParts$Outbound = StreamAgentPartsToolCallPart$Outbound | StreamAgentPartsTextPart$Outbound | StreamAgentPartsDataPart$Outbound | StreamAgentPartsFilePart$Outbound | StreamAgentPartsToolResultPart$Outbound;
+/** @internal */
+export declare const StreamAgentDataParts$outboundSchema: z.ZodType<StreamAgentDataParts$Outbound, z.ZodTypeDef, StreamAgentDataParts>;
+export declare function streamAgentDataPartsToJSON(streamAgentDataParts: StreamAgentDataParts): string;
+export declare function streamAgentDataPartsFromJSON(jsonString: string): SafeParseResult<StreamAgentDataParts, SDKValidationError>;
+/** @internal */
+export declare const DataInputMessage$inboundSchema: z.ZodType<DataInputMessage, z.ZodTypeDef, unknown>;
+/** @internal */
+export type DataInputMessage$Outbound = {
+    messageId?: string | undefined;
+    role: string;
+    parts: Array<StreamAgentPartsToolCallPart$Outbound | StreamAgentPartsTextPart$Outbound | StreamAgentPartsDataPart$Outbound | StreamAgentPartsFilePart$Outbound | StreamAgentPartsToolResultPart$Outbound>;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const DataInputMessage$outboundSchema: z.ZodType<DataInputMessage$Outbound, z.ZodTypeDef, DataInputMessage>;
+export declare function dataInputMessageToJSON(dataInputMessage: DataInputMessage): string;
+export declare function dataInputMessageFromJSON(jsonString: string): SafeParseResult<DataInputMessage, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataToolApprovalRequired$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataToolApprovalRequired>;
+/** @internal */
+export declare const StreamAgentDataToolApprovalRequired$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataToolApprovalRequired>;
+/** @internal */
+export declare const StreamAgentDataAgentsConditions$inboundSchema: z.ZodType<StreamAgentDataAgentsConditions, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsConditions$Outbound = {
+    condition: string;
+    operator: string;
+    value: string;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsConditions$outboundSchema: z.ZodType<StreamAgentDataAgentsConditions$Outbound, z.ZodTypeDef, StreamAgentDataAgentsConditions>;
+export declare function streamAgentDataAgentsConditionsToJSON(streamAgentDataAgentsConditions: StreamAgentDataAgentsConditions): string;
+export declare function streamAgentDataAgentsConditionsFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsConditions, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataTools$inboundSchema: z.ZodType<StreamAgentDataTools, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataTools$Outbound = {
+    id: string;
+    key?: string | undefined;
+    action_type: string;
+    display_name?: string | undefined;
+    description?: string | undefined;
+    requires_approval: boolean;
+    tool_id?: string | undefined;
+    conditions?: Array<StreamAgentDataAgentsConditions$Outbound> | undefined;
+    timeout: number;
+};
+/** @internal */
+export declare const StreamAgentDataTools$outboundSchema: z.ZodType<StreamAgentDataTools$Outbound, z.ZodTypeDef, StreamAgentDataTools>;
+export declare function streamAgentDataToolsToJSON(streamAgentDataTools: StreamAgentDataTools): string;
+export declare function streamAgentDataToolsFromJSON(jsonString: string): SafeParseResult<StreamAgentDataTools, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataExecuteOn$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataExecuteOn>;
+/** @internal */
+export declare const StreamAgentDataExecuteOn$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataExecuteOn>;
+/** @internal */
+export declare const StreamAgentDataEvaluators$inboundSchema: z.ZodType<StreamAgentDataEvaluators, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataEvaluators$Outbound = {
+    id: string;
+    sample_rate: number;
+    execute_on: string;
+};
+/** @internal */
+export declare const StreamAgentDataEvaluators$outboundSchema: z.ZodType<StreamAgentDataEvaluators$Outbound, z.ZodTypeDef, StreamAgentDataEvaluators>;
+export declare function streamAgentDataEvaluatorsToJSON(streamAgentDataEvaluators: StreamAgentDataEvaluators): string;
+export declare function streamAgentDataEvaluatorsFromJSON(jsonString: string): SafeParseResult<StreamAgentDataEvaluators, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsExecuteOn$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsExecuteOn>;
+/** @internal */
+export declare const StreamAgentDataAgentsExecuteOn$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataAgentsExecuteOn>;
+/** @internal */
+export declare const StreamAgentDataGuardrails$inboundSchema: z.ZodType<StreamAgentDataGuardrails, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataGuardrails$Outbound = {
+    id: string;
+    sample_rate: number;
+    execute_on: string;
+};
+/** @internal */
+export declare const StreamAgentDataGuardrails$outboundSchema: z.ZodType<StreamAgentDataGuardrails$Outbound, z.ZodTypeDef, StreamAgentDataGuardrails>;
+export declare function streamAgentDataGuardrailsToJSON(streamAgentDataGuardrails: StreamAgentDataGuardrails): string;
+export declare function streamAgentDataGuardrailsFromJSON(jsonString: string): SafeParseResult<StreamAgentDataGuardrails, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataSettings$inboundSchema: z.ZodType<StreamAgentDataSettings, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataSettings$Outbound = {
+    max_iterations: number;
+    max_execution_time: number;
+    tool_approval_required: string;
+    tools?: Array<StreamAgentDataTools$Outbound> | undefined;
+    evaluators?: Array<StreamAgentDataEvaluators$Outbound> | undefined;
+    guardrails?: Array<StreamAgentDataGuardrails$Outbound> | undefined;
+};
+/** @internal */
+export declare const StreamAgentDataSettings$outboundSchema: z.ZodType<StreamAgentDataSettings$Outbound, z.ZodTypeDef, StreamAgentDataSettings>;
+export declare function streamAgentDataSettingsToJSON(streamAgentDataSettings: StreamAgentDataSettings): string;
+export declare function streamAgentDataSettingsFromJSON(jsonString: string): SafeParseResult<StreamAgentDataSettings, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataAgentsData$inboundSchema: z.ZodType<StreamAgentDataAgentsData, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataAgentsData$Outbound = {
+    integration_id?: string | undefined;
+    inputMessage: DataInputMessage$Outbound;
+    modelId: string;
+    instructions: string;
+    system_prompt: string;
+    settings?: StreamAgentDataSettings$Outbound | undefined;
+    agent_manifest_id: string;
+    agent_key: string;
+    variables?: {
+        [k: string]: any;
+    } | undefined;
+    tool_execution_id?: string | undefined;
+    is_continuation?: boolean | undefined;
+    stream?: boolean | undefined;
+};
+/** @internal */
+export declare const StreamAgentDataAgentsData$outboundSchema: z.ZodType<StreamAgentDataAgentsData$Outbound, z.ZodTypeDef, StreamAgentDataAgentsData>;
+export declare function streamAgentDataAgentsDataToJSON(streamAgentDataAgentsData: StreamAgentDataAgentsData): string;
+export declare function streamAgentDataAgentsDataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataAgentsData, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentData2$inboundSchema: z.ZodType<StreamAgentData2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentData2$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataAgentsData$Outbound;
+};
+/** @internal */
+export declare const StreamAgentData2$outboundSchema: z.ZodType<StreamAgentData2$Outbound, z.ZodTypeDef, StreamAgentData2>;
+export declare function streamAgentData2ToJSON(streamAgentData2: StreamAgentData2): string;
+export declare function streamAgentData2FromJSON(jsonString: string): SafeParseResult<StreamAgentData2, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentDataType$inboundSchema: z.ZodNativeEnum<typeof StreamAgentDataType>;
+/** @internal */
+export declare const StreamAgentDataType$outboundSchema: z.ZodNativeEnum<typeof StreamAgentDataType>;
+/** @internal */
+export declare const StreamAgentDataData$inboundSchema: z.ZodType<StreamAgentDataData, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentDataData$Outbound = {
+    agent_task_id: string;
+    workspace_id: string;
+    trace_id: string;
+};
+/** @internal */
+export declare const StreamAgentDataData$outboundSchema: z.ZodType<StreamAgentDataData$Outbound, z.ZodTypeDef, StreamAgentDataData>;
+export declare function streamAgentDataDataToJSON(streamAgentDataData: StreamAgentDataData): string;
+export declare function streamAgentDataDataFromJSON(jsonString: string): SafeParseResult<StreamAgentDataData, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentData1$inboundSchema: z.ZodType<StreamAgentData1, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentData1$Outbound = {
+    type: string;
+    timestamp: string;
+    data: StreamAgentDataData$Outbound;
+};
+/** @internal */
+export declare const StreamAgentData1$outboundSchema: z.ZodType<StreamAgentData1$Outbound, z.ZodTypeDef, StreamAgentData1>;
+export declare function streamAgentData1ToJSON(streamAgentData1: StreamAgentData1): string;
+export declare function streamAgentData1FromJSON(jsonString: string): SafeParseResult<StreamAgentData1, SDKValidationError>;
+/** @internal */
+export declare const StreamAgentData$inboundSchema: z.ZodType<StreamAgentData, z.ZodTypeDef, unknown>;
+/** @internal */
+export type StreamAgentData$Outbound = StreamAgentData1$Outbound | StreamAgentData2$Outbound | StreamAgentData3$Outbound | StreamAgentData4$Outbound | Data5$Outbound | Data6$Outbound | Data7$Outbound | Data8$Outbound | Data9$Outbound | Data10$Outbound | Data11$Outbound | Data12$Outbound | Data13$Outbound | Data14$Outbound | Data15$Outbound | Data16$Outbound | Data17$Outbound;
+/** @internal */
+export declare const StreamAgentData$outboundSchema: z.ZodType<StreamAgentData$Outbound, z.ZodTypeDef, StreamAgentData>;
+export declare function streamAgentDataToJSON(streamAgentData: StreamAgentData): string;
+export declare function streamAgentDataFromJSON(jsonString: string): SafeParseResult<StreamAgentData, SDKValidationError>;
 /** @internal */
 export declare const StreamAgentResponseBody$inboundSchema: z.ZodType<StreamAgentResponseBody, z.ZodTypeDef, unknown>;
 /** @internal */
 export type StreamAgentResponseBody$Outbound = {
-    data: string;
+    data: StreamAgentData1$Outbound | StreamAgentData2$Outbound | StreamAgentData3$Outbound | StreamAgentData4$Outbound | Data5$Outbound | Data6$Outbound | Data7$Outbound | Data8$Outbound | Data9$Outbound | Data10$Outbound | Data11$Outbound | Data12$Outbound | Data13$Outbound | Data14$Outbound | Data15$Outbound | Data16$Outbound | Data17$Outbound;
 };
 /** @internal */
 export declare const StreamAgentResponseBody$outboundSchema: z.ZodType<StreamAgentResponseBody$Outbound, z.ZodTypeDef, StreamAgentResponseBody>;