@letta-ai/letta-client 1.0.0-alpha.6 → 1.0.0

package/src/resources/agents/messages.ts

@@ -2,24 +2,58 @@
 
 import { APIResource } from '../../core/resource';
 import * as MessagesAPI from './messages';
-import * as RunsAPI from '../runs';
+import * as ToolsAPI from '../tools';
 import * as AgentsAPI from './agents';
-import * as ToolsAPI from '../tools/tools';
+import * as RunsAPI from '../runs/runs';
 import { APIPromise } from '../../core/api-promise';
+import { ArrayPage, type ArrayPageParams, ObjectPage, PagePromise } from '../../core/pagination';
+import { Stream } from '../../core/streaming';
+import { buildHeaders } from '../../internal/headers';
 import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 
 export class Messages extends APIResource {
   /**
-   * Update the details of a message associated with an agent.
+   * Process a user message and return the agent's response. This endpoint accepts a
+   * message from a user and processes it through the agent.
+   *
+   * The response format is controlled by the `streaming` field in the request body:
+   *
+   * - If `streaming=false` (default): Returns a complete LettaResponse with all
+   *   messages
+   * - If `streaming=true`: Returns a Server-Sent Events (SSE) stream
+   *
+   * Additional streaming options (only used when streaming=true):
+   *
+   * - `stream_tokens`: Stream individual tokens instead of complete steps
+   * - `include_pings`: Include keepalive pings to prevent connection timeouts
+   * - `background`: Process the request in the background
    */
-  update(
-    messageID: string,
-    params: MessageUpdateParams,
+  create(
+    agentID: string,
+    body: MessageCreateParamsNonStreaming,
+    options?: RequestOptions,
+  ): APIPromise<LettaResponse>;
+  create(
+    agentID: string,
+    body: MessageCreateParamsStreaming,
+    options?: RequestOptions,
+  ): APIPromise<Stream<LettaStreamingResponse>>;
+  create(
+    agentID: string,
+    body: MessageCreateParamsBase,
+    options?: RequestOptions,
+  ): APIPromise<Stream<LettaStreamingResponse> | LettaResponse>;
+  create(
+    agentID: string,
+    body: MessageCreateParams,
     options?: RequestOptions,
-  ): APIPromise<MessageUpdateResponse> {
-    const { agent_id, ...body } = params;
-    return this._client.patch(path`/v1/agents/${agent_id}/messages/${messageID}`, { body, ...options });
+  ): APIPromise<LettaResponse> | APIPromise<Stream<LettaStreamingResponse>> {
+    return this._client.post(path`/v1/agents/${agentID}/messages`, {
+      body,
+      ...options,
+      stream: body.streaming ?? false,
+    }) as APIPromise<LettaResponse> | APIPromise<Stream<LettaStreamingResponse>>;
   }
 
   /**
@@ -29,8 +63,11 @@ export class Messages extends APIResource {
     agentID: string,
     query: MessageListParams | null | undefined = {},
     options?: RequestOptions,
-  ): APIPromise<MessageListResponse> {
-    return this._client.get(path`/v1/agents/${agentID}/messages`, { query, ...options });
+  ): PagePromise<MessagesArrayPage, Message> {
+    return this._client.getAPIList(path`/v1/agents/${agentID}/messages`, ArrayPage<Message>, {
+      query,
+      ...options,
+    });
   }
 
   /**
@@ -48,36 +85,13 @@ export class Messages extends APIResource {
   }
 
   /**
-   * Inspect the raw LLM request payload without sending it.
-   *
-   * This endpoint processes the message through the agent loop up until the LLM
-   * request, then returns the raw request payload that would be sent to the LLM
-   * provider. Useful for debugging and inspection.
-   */
-  previewRawPayload(
-    agentID: string,
-    body: MessagePreviewRawPayloadParams,
-    options?: RequestOptions,
-  ): APIPromise<MessagePreviewRawPayloadResponse> {
-    return this._client.post(path`/v1/agents/${agentID}/messages/preview-raw-payload`, { body, ...options });
-  }
-
-  /**
-   * Search messages across the entire organization with optional project and
-   * template filtering. Returns messages with FTS/vector ranks and total RRF score.
-   *
-   * This is a cloud-only feature.
-   */
-  search(body: MessageSearchParams, options?: RequestOptions): APIPromise<MessageSearchResponse> {
-    return this._client.post('/v1/agents/messages/search', { body, ...options });
-  }
-
-  /**
-   * Process a user message and return the agent's response. This endpoint accepts a
-   * message from a user and processes it through the agent.
+   * Summarize an agent's conversation history.
    */
-  send(agentID: string, body: MessageSendParams, options?: RequestOptions): APIPromise<LettaResponse> {
-    return this._client.post(path`/v1/agents/${agentID}/messages`, { body, ...options });
+  compact(agentID: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.post(path`/v1/agents/${agentID}/summarize`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
   }
 
   /**
@@ -85,39 +99,74 @@ export class Messages extends APIResource {
    * processing happens in the background, and the status can be checked using the
    * run ID.
    *
-   * This is "asynchronous" in the sense that it's a background job and explicitly
-   * must be fetched by the run ID. This is more like `send_message_job`
+   * This is "asynchronous" in the sense that it's a background run and explicitly
+   * must be fetched by the run ID.
    */
-  sendAsync(agentID: string, body: MessageSendAsyncParams, options?: RequestOptions): APIPromise<Run> {
+  createAsync(agentID: string, body: MessageCreateAsyncParams, options?: RequestOptions): APIPromise<Run> {
     return this._client.post(path`/v1/agents/${agentID}/messages/async`, { body, ...options });
   }
 
+  /**
+   * Resets the messages for an agent
+   */
+  reset(
+    agentID: string,
+    body: MessageResetParams,
+    options?: RequestOptions,
+  ): APIPromise<AgentsAPI.AgentState | null> {
+    return this._client.patch(path`/v1/agents/${agentID}/reset-messages`, { body, ...options });
+  }
+
   /**
    * Process a user message and return the agent's response. This endpoint accepts a
    * message from a user and processes it through the agent. It will stream the steps
    * of the response always, and stream the tokens if 'stream_tokens' is set to True.
    */
-  sendStream(agentID: string, body: MessageSendStreamParams, options?: RequestOptions): APIPromise<unknown> {
-    return this._client.post(path`/v1/agents/${agentID}/messages/stream`, { body, ...options });
+  stream(
+    agentID: string,
+    body: MessageStreamParams,
+    options?: RequestOptions,
+  ): APIPromise<Stream<LettaStreamingResponse>> {
+    return this._client.post(path`/v1/agents/${agentID}/messages/stream`, {
+      body,
+      ...options,
+      stream: true,
+    }) as APIPromise<Stream<LettaStreamingResponse>>;
   }
 }
 
+export type MessagesArrayPage = ArrayPage<Message>;
+
+export type RunsArrayPage = ArrayPage<Run>;
+
+export type InternalMessagesObjectPage = ObjectPage<InternalMessage>;
+
 /**
  * Input to approve or deny a tool call request
  */
 export interface ApprovalCreate {
   /**
-   * The message ID of the approval request
+   * @deprecated The message ID of the approval request
    */
-  approval_request_id: string;
+  approval_request_id?: string | null;
 
   /**
-   * Whether the tool has been approved
+   * The list of approval responses
    */
-  approve: boolean;
+  approvals?: Array<ApprovalReturn | ToolReturn> | null;
 
   /**
-   * An optional explanation for the provided approval status
+   * @deprecated Whether the tool has been approved
+   */
+  approve?: boolean | null;
+
+  /**
+   * The multi-agent group that the message was sent in
+   */
+  group_id?: string | null;
+
+  /**
+   * @deprecated An optional explanation for the provided approval status
    */
   reason?: string | null;
 
@@ -141,7 +190,7 @@ export interface ApprovalRequestMessage {
   date: string;
 
   /**
-   * The tool call that has been requested by the llm to run
+   * @deprecated The tool call that has been requested by the llm to run
    */
   tool_call: ToolCall | ToolCallDelta;
 
@@ -163,6 +212,12 @@ export interface ApprovalRequestMessage {
   seq_id?: number | null;
 
   step_id?: string | null;
+
+  /**
+   * The tool calls that have been requested by the llm to run, which are pending
+   * approval
+   */
+  tool_calls?: Array<ToolCall> | ToolCallDelta | null;
 }
 
 /**
@@ -178,17 +233,22 @@ export interface ApprovalRequestMessage {
 export interface ApprovalResponseMessage {
   id: string;
 
+  date: string;
+
   /**
-   * The message ID of the approval request
+   * @deprecated The message ID of the approval request
    */
-  approval_request_id: string;
+  approval_request_id?: string | null;
 
   /**
-   * Whether the tool has been approved
+   * The list of approval responses
    */
-  approve: boolean;
+  approvals?: Array<ApprovalReturn | ToolReturn> | null;
 
-  date: string;
+  /**
+   * @deprecated Whether the tool has been approved
+   */
+  approve?: boolean | null;
 
   is_err?: boolean | null;
 
@@ -202,7 +262,7 @@ export interface ApprovalResponseMessage {
   otid?: string | null;
 
   /**
-   * An optional explanation for the provided approval status
+   * @deprecated An optional explanation for the provided approval status
    */
   reason?: string | null;
 
@@ -215,6 +275,28 @@ export interface ApprovalResponseMessage {
   step_id?: string | null;
 }
 
+export interface ApprovalReturn {
+  /**
+   * Whether the tool has been approved
+   */
+  approve: boolean;
+
+  /**
+   * The ID of the tool call that corresponds to this approval
+   */
+  tool_call_id: string;
+
+  /**
+   * An optional explanation for the provided approval status
+   */
+  reason?: string | null;
+
+  /**
+   * The message type to be created.
+   */
+  type?: 'approval';
+}
+
 /**
  * A message sent by the LLM in response to user input. Used in the LLM context.
  *
@@ -254,6 +336,36 @@ export interface AssistantMessage {
   step_id?: string | null;
 }
 
+/**
+ * A message for notifying the developer that an event that has occured (e.g. a
+ * compaction). Events are NOT part of the context window.
+ */
+export interface EventMessage {
+  id: string;
+
+  date: string;
+
+  event_data: { [key: string]: unknown };
+
+  event_type: 'compaction';
+
+  is_err?: boolean | null;
+
+  message_type?: 'event';
+
+  name?: string | null;
+
+  otid?: string | null;
+
+  run_id?: string | null;
+
+  sender_id?: string | null;
+
+  seq_id?: number | null;
+
+  step_id?: string | null;
+}
+
 /**
  * Representation of an agent's internal reasoning where reasoning content has been
  * hidden from the response.
@@ -371,193 +483,318 @@ export namespace ImageContent {
 }
 
 /**
- * Status of the job.
+ * Letta's internal representation of a message. Includes methods to convert to/from LLM provider formats.
+ *
+ *     Attributes:
+ *         id (str): The unique identifier of the message.
+ *         role (MessageRole): The role of the participant.
+ *         text (str): The text of the message.
+ *         user_id (str): The unique identifier of the user.
+ *         agent_id (str): The unique identifier of the agent.
+ *         model (str): The model used to make the function call.
+ *         name (str): The name of the participant.
+ *         created_at (datetime): The time the message was created.
+ *         tool_calls (List[OpenAIToolCall,]): The list of tool calls requested.
+ *         tool_call_id (str): The id of the tool call.
+ *         step_id (str): The id of the step that this message was created in.
+ *         otid (str): The offline threading id associated with this message.
+ *         tool_returns (List[ToolReturn]): The list of tool returns requested.
+ *         group_id (str): The multi-agent group that the message was sent in.
+ *         sender_id (str): The id of the sender of the message, can be an identity id or agent id.
+ *
+ * t
  */
-export type JobStatus = 'created' | 'running' | 'completed' | 'failed' | 'pending' | 'cancelled' | 'expired';
+export interface InternalMessage {
+  /**
+   * The human-friendly ID of the Message
+   */
+  id: string;
 
-export type JobType = 'job' | 'run' | 'batch';
+  /**
+   * The role of the participant.
+   */
+  role: MessageRole;
 
-export interface LettaAssistantMessageContentUnion {
   /**
-   * The text content of the message.
+   * The unique identifier of the agent.
    */
-  text: string;
+  agent_id?: string | null;
 
   /**
-   * The type of the message.
+   * The id of the approval request if this message is associated with a tool call
+   * request.
    */
-  type?: 'text';
-}
+  approval_request_id?: string | null;
 
-/**
- * A message generated by the system. Never streamed back on a response, only used
- * for cursor pagination.
- *
- * Args: id (str): The ID of the message date (datetime): The date the message was
- * created in ISO format name (Optional[str]): The name of the sender of the
- * message content (str): The message content sent by the system
- */
-export type LettaMessageUnion =
-  | SystemMessage
-  | UserMessage
-  | ReasoningMessage
-  | HiddenReasoningMessage
-  | ToolCallMessage
-  | ToolsAPI.ToolReturnMessage
-  | AssistantMessage
-  | ApprovalRequestMessage
-  | ApprovalResponseMessage;
+  /**
+   * The list of approvals for this message.
+   */
+  approvals?: Array<ApprovalReturn | InternalMessage.LettaSchemasMessageToolReturn> | null;
 
-export interface LettaRequest {
   /**
-   * The messages to be sent to the agent.
+   * Whether tool call is approved.
    */
-  messages: Array<AgentsAPI.MessageCreate | ApprovalCreate>;
+  approve?: boolean | null;
 
   /**
-   * The name of the message argument in the designated message tool.
+   * The id of the LLMBatchItem that this message is associated with
    */
-  assistant_message_tool_kwarg?: string;
+  batch_item_id?: string | null;
 
   /**
-   * The name of the designated message tool.
+   * The content of the message.
    */
-  assistant_message_tool_name?: string;
+  content?: Array<
+    | TextContent
+    | ImageContent
+    | ToolCallContent
+    | ToolReturnContent
+    | ReasoningContent
+    | RedactedReasoningContent
+    | OmittedReasoningContent
+    | InternalMessage.SummarizedReasoningContent
+  > | null;
 
   /**
-   * If set to True, enables reasoning before responses or tool calls from the agent.
+   * The timestamp when the object was created.
    */
-  enable_thinking?: string;
+  created_at?: string;
 
   /**
-   * Only return specified message types in the response. If `None` (default) returns
-   * all messages.
+   * The id of the user that made this object.
    */
-  include_return_message_types?: Array<MessageType> | null;
+  created_by_id?: string | null;
 
   /**
-   * Maximum number of steps the agent should take to process the request.
+   * The reason the tool call request was denied.
    */
-  max_steps?: number;
+  denial_reason?: string | null;
 
   /**
-   * Whether the server should parse specific tool call arguments (default
-   * `send_message`) as `AssistantMessage` objects.
+   * The multi-agent group that the message was sent in
    */
-  use_assistant_message?: boolean;
-}
+  group_id?: string | null;
 
-/**
- * Response object from an agent interaction, consisting of the new messages
- * generated by the agent and usage statistics. The type of the returned messages
- * can be either `Message` or `LettaMessage`, depending on what was specified in
- * the request.
- *
- * Attributes: messages (List[Union[Message, LettaMessage]]): The messages returned
- * by the agent. usage (LettaUsageStatistics): The usage statistics
- */
-export interface LettaResponse {
   /**
-   * The messages returned by the agent.
+   * Whether this message is part of an error step. Used only for debugging purposes.
    */
-  messages: Array<LettaMessageUnion>;
+  is_err?: boolean | null;
 
   /**
-   * The stop reason from Letta indicating why agent loop stopped execution.
+   * The id of the user that made this object.
    */
-  stop_reason: LettaResponse.StopReason;
+  last_updated_by_id?: string | null;
 
   /**
-   * The usage statistics of the agent.
+   * The model used to make the function call.
    */
-  usage: LettaResponse.Usage;
-}
+  model?: string | null;
 
-export namespace LettaResponse {
   /**
-   * The stop reason from Letta indicating why agent loop stopped execution.
+   * For role user/assistant: the (optional) name of the participant. For role
+   * tool/function: the name of the function called.
    */
-  export interface StopReason {
-    /**
-     * The reason why execution stopped.
-     */
-    stop_reason: RunsAPI.StopReasonType;
+  name?: string | null;
 
-    /**
-     * The type of the message.
-     */
-    message_type?: 'stop_reason';
-  }
+  /**
+   * The offline threading id associated with this message
+   */
+  otid?: string | null;
 
   /**
-   * The usage statistics of the agent.
+   * The id of the run that this message was created in.
    */
-  export interface Usage {
-    /**
-     * The number of tokens generated by the agent.
-     */
-    completion_tokens?: number;
+  run_id?: string | null;
 
-    message_type?: 'usage_statistics';
+  /**
+   * The id of the sender of the message, can be an identity id or agent id
+   */
+  sender_id?: string | null;
 
-    /**
-     * The number of tokens in the prompt.
+  /**
+   * The id of the step that this message was created in.
+   */
+  step_id?: string | null;
+
+  /**
+   * The ID of the tool call. Only applicable for role tool.
+   */
+  tool_call_id?: string | null;
+
+  /**
+   * The list of tool calls requested. Only applicable for role assistant.
+   */
+  tool_calls?: Array<InternalMessage.ToolCall> | null;
+
+  /**
+   * Tool execution return information for prior tool calls
+   */
+  tool_returns?: Array<InternalMessage.ToolReturn> | null;
+
+  /**
+   * The timestamp when the object was last updated.
+   */
+  updated_at?: string | null;
+}
+
+export namespace InternalMessage {
+  export interface LettaSchemasMessageToolReturn {
+    /**
+     * The status of the tool call
      */
-    prompt_tokens?: number;
+    status: 'success' | 'error';
 
     /**
-     * The background task run IDs associated with the agent interaction
+     * The function response string
      */
-    run_ids?: Array<string> | null;
+    func_response?: string | null;
 
     /**
-     * The number of steps taken by the agent.
+     * Captured stderr from the tool invocation
      */
-    step_count?: number;
+    stderr?: Array<string> | null;
 
     /**
-     * The messages generated per step
+     * Captured stdout (e.g. prints, logs) from the tool invocation
      */
-    steps_messages?: Array<Array<MessagesAPI.Message>> | null;
+    stdout?: Array<string> | null;
 
     /**
-     * The total number of tokens processed by the agent.
+     * The ID for the tool call
      */
-    total_tokens?: number;
+    tool_call_id?: unknown;
+  }
+
+  /**
+   * The style of reasoning content returned by the OpenAI Responses API
+   */
+  export interface SummarizedReasoningContent {
+    /**
+     * The unique identifier for this reasoning step.
+     */
+    id: string;
+
+    /**
+     * Summaries of the reasoning content.
+     */
+    summary: Array<SummarizedReasoningContent.Summary>;
+
+    /**
+     * The encrypted reasoning content.
+     */
+    encrypted_content?: string;
+
+    /**
+     * Indicates this is a summarized reasoning step.
+     */
+    type?: 'summarized_reasoning';
+  }
+
+  export namespace SummarizedReasoningContent {
+    export interface Summary {
+      /**
+       * The index of the summary part.
+       */
+      index: number;
+
+      /**
+       * The text of the summary part.
+       */
+      text: string;
+    }
+  }
+
+  export interface ToolCall {
+    id: string;
+
+    function: ToolCall.Function;
+
+    type: 'function';
+
+    [k: string]: unknown;
+  }
+
+  export namespace ToolCall {
+    export interface Function {
+      arguments: string;
+
+      name: string;
+
+      [k: string]: unknown;
+    }
+  }
+
+  export interface ToolReturn {
+    /**
+     * The status of the tool call
+     */
+    status: 'success' | 'error';
+
+    /**
+     * The function response string
+     */
+    func_response?: string | null;
+
+    /**
+     * Captured stderr from the tool invocation
+     */
+    stderr?: Array<string> | null;
+
+    /**
+     * Captured stdout (e.g. prints, logs) from the tool invocation
+     */
+    stdout?: Array<string> | null;
+
+    /**
+     * The ID for the tool call
+     */
+    tool_call_id?: unknown;
   }
 }
 
-export interface LettaStreamingRequest {
+/**
+ * Status of the job.
+ */
+export type JobStatus = 'created' | 'running' | 'completed' | 'failed' | 'pending' | 'cancelled' | 'expired';
+
+export type JobType = 'job' | 'run' | 'batch';
+
+export interface LettaAssistantMessageContentUnion {
   /**
-   * The messages to be sent to the agent.
+   * The text content of the message.
    */
-  messages: Array<AgentsAPI.MessageCreate | ApprovalCreate>;
+  text: string;
 
   /**
-   * The name of the message argument in the designated message tool.
+   * Stores a unique identifier for any reasoning associated with this text content.
    */
-  assistant_message_tool_kwarg?: string;
+  signature?: string | null;
 
   /**
-   * The name of the designated message tool.
+   * The type of the message.
    */
-  assistant_message_tool_name?: string;
+  type?: 'text';
+}
 
+export interface LettaRequest {
   /**
-   * Whether to process the request in the background.
+   * @deprecated The name of the message argument in the designated message tool.
+   * Still supported for legacy agent types, but deprecated for letta_v1_agent
+   * onward.
    */
-  background?: boolean;
+  assistant_message_tool_kwarg?: string;
 
   /**
-   * If set to True, enables reasoning before responses or tool calls from the agent.
+   * @deprecated The name of the designated message tool. Still supported for legacy
+   * agent types, but deprecated for letta_v1_agent onward.
    */
-  enable_thinking?: string;
+  assistant_message_tool_name?: string;
 
   /**
-   * Whether to include periodic keepalive ping messages in the stream to prevent
-   * connection timeouts.
+   * @deprecated If set to True, enables reasoning before responses or tool calls
+   * from the agent.
    */
-  include_pings?: boolean;
+  enable_thinking?: string;
 
   /**
    * Only return specified message types in the response. If `None` (default) returns
@@ -565,191 +802,390 @@ export interface LettaStreamingRequest {
    */
   include_return_message_types?: Array<MessageType> | null;
 
+  /**
+   * Syntactic sugar for a single user message. Equivalent to messages=[{'role':
+   * 'user', 'content': input}].
+   */
+  input?:
+    | string
+    | Array<
+        | TextContent
+        | ImageContent
+        | ToolCallContent
+        | ToolReturnContent
+        | ReasoningContent
+        | RedactedReasoningContent
+        | OmittedReasoningContent
+        | LettaRequest.SummarizedReasoningContent
+      >
+    | null;
+
   /**
    * Maximum number of steps the agent should take to process the request.
    */
   max_steps?: number;
 
   /**
-   * Flag to determine if individual tokens should be streamed, rather than streaming
-   * per step.
+   * The messages to be sent to the agent.
    */
-  stream_tokens?: boolean;
+  messages?: Array<AgentsAPI.MessageCreate | ApprovalCreate> | null;
 
   /**
-   * Whether the server should parse specific tool call arguments (default
-   * `send_message`) as `AssistantMessage` objects.
+   * @deprecated Whether the server should parse specific tool call arguments
+   * (default `send_message`) as `AssistantMessage` objects. Still supported for
+   * legacy agent types, but deprecated for letta_v1_agent onward.
    */
   use_assistant_message?: boolean;
 }
 
-export type LettaUserMessageContentUnion = TextContent | ImageContent;
+export namespace LettaRequest {
+  /**
+   * The style of reasoning content returned by the OpenAI Responses API
+   */
+  export interface SummarizedReasoningContent {
+    /**
+     * The unique identifier for this reasoning step.
+     */
+    id: string;
+
+    /**
+     * Summaries of the reasoning content.
+     */
+    summary: Array<SummarizedReasoningContent.Summary>;
+
+    /**
+     * The encrypted reasoning content.
+     */
+    encrypted_content?: string;
+
+    /**
+     * Indicates this is a summarized reasoning step.
+     */
+    type?: 'summarized_reasoning';
+  }
+
+  export namespace SummarizedReasoningContent {
+    export interface Summary {
+      /**
+       * The index of the summary part.
+       */
+      index: number;
+
+      /**
+       * The text of the summary part.
+       */
+      text: string;
+    }
+  }
+}
 
 /**
- * Letta's internal representation of a message. Includes methods to convert to/from LLM provider formats.
- *
- *     Attributes:
- *         id (str): The unique identifier of the message.
- *         role (MessageRole): The role of the participant.
- *         text (str): The text of the message.
- *         user_id (str): The unique identifier of the user.
- *         agent_id (str): The unique identifier of the agent.
- *         model (str): The model used to make the function call.
- *         name (str): The name of the participant.
- *         created_at (datetime): The time the message was created.
- *         tool_calls (List[OpenAIToolCall,]): The list of tool calls requested.
- *         tool_call_id (str): The id of the tool call.
- *         step_id (str): The id of the step that this message was created in.
- *         otid (str): The offline threading id associated with this message.
- *         tool_returns (List[ToolReturn]): The list of tool returns requested.
- *         group_id (str): The multi-agent group that the message was sent in.
- *         sender_id (str): The id of the sender of the message, can be an identity id or agent id.
+ * Response object from an agent interaction, consisting of the new messages
+ * generated by the agent and usage statistics. The type of the returned messages
+ * can be either `Message` or `LettaMessage`, depending on what was specified in
+ * the request.
  *
- * t
+ * Attributes: messages (List[Union[Message, LettaMessage]]): The messages returned
+ * by the agent. usage (LettaUsageStatistics): The usage statistics
  */
-export interface Message {
+export interface LettaResponse {
   /**
-   * The role of the participant.
+   * The messages returned by the agent.
    */
-  role: MessageRole;
+  messages: Array<Message>;
 
   /**
-   * The human-friendly ID of the Message
+   * The stop reason from Letta indicating why agent loop stopped execution.
    */
-  id?: string;
+  stop_reason: LettaResponse.StopReason;
 
   /**
-   * The unique identifier of the agent.
+   * The usage statistics of the agent.
    */
-  agent_id?: string | null;
+  usage: LettaResponse.Usage;
+}
 
+export namespace LettaResponse {
   /**
-   * The id of the approval request if this message is associated with a tool call
-   * request.
+   * The stop reason from Letta indicating why agent loop stopped execution.
    */
-  approval_request_id?: string | null;
+  export interface StopReason {
+    /**
+     * The reason why execution stopped.
+     */
+    stop_reason: RunsAPI.StopReasonType;
+
+    /**
+     * The type of the message.
+     */
+    message_type?: 'stop_reason';
+  }
 
   /**
-   * Whether tool call is approved.
+   * The usage statistics of the agent.
    */
-  approve?: boolean | null;
+  export interface Usage {
+    /**
+     * The number of tokens generated by the agent.
+     */
+    completion_tokens?: number;
+
+    message_type?: 'usage_statistics';
+
+    /**
+     * The number of tokens in the prompt.
+     */
+    prompt_tokens?: number;
+
+    /**
+     * The background task run IDs associated with the agent interaction
+     */
+    run_ids?: Array<string> | null;
+
+    /**
+     * The number of steps taken by the agent.
+     */
+    step_count?: number;
 
+    /**
+     * The total number of tokens processed by the agent.
+     */
+    total_tokens?: number;
+  }
+}
+
+export interface LettaStreamingRequest {
   /**
-   * The id of the LLMBatchItem that this message is associated with
+   * @deprecated The name of the message argument in the designated message tool.
+   * Still supported for legacy agent types, but deprecated for letta_v1_agent
+   * onward.
    */
-  batch_item_id?: string | null;
+  assistant_message_tool_kwarg?: string;
 
   /**
-   * The content of the message.
+   * @deprecated The name of the designated message tool. Still supported for legacy
+   * agent types, but deprecated for letta_v1_agent onward.
    */
-  content?: Array<
-    | TextContent
-    | ImageContent
-    | ToolCallContent
-    | ToolReturnContent
-    | ReasoningContent
-    | RedactedReasoningContent
-    | OmittedReasoningContent
-  > | null;
+  assistant_message_tool_name?: string;
 
   /**
-   * The timestamp when the object was created.
+   * Whether to process the request in the background (only used when
+   * streaming=true).
    */
-  created_at?: string;
+  background?: boolean;
 
   /**
-   * The id of the user that made this object.
+   * @deprecated If set to True, enables reasoning before responses or tool calls
+   * from the agent.
    */
-  created_by_id?: string | null;
+  enable_thinking?: string;
 
   /**
-   * The reason the tool call request was denied.
+   * Whether to include periodic keepalive ping messages in the stream to prevent
+   * connection timeouts (only used when streaming=true).
    */
-  denial_reason?: string | null;
+  include_pings?: boolean;
 
   /**
-   * The multi-agent group that the message was sent in
+   * Only return specified message types in the response. If `None` (default) returns
+   * all messages.
    */
-  group_id?: string | null;
+  include_return_message_types?: Array<MessageType> | null;
 
   /**
-   * Whether this message is part of an error step. Used only for debugging purposes.
+   * Syntactic sugar for a single user message. Equivalent to messages=[{'role':
+   * 'user', 'content': input}].
    */
-  is_err?: boolean | null;
+  input?:
+    | string
+    | Array<
+        | TextContent
+        | ImageContent
+        | ToolCallContent
+        | ToolReturnContent
+        | ReasoningContent
+        | RedactedReasoningContent
+        | OmittedReasoningContent
+        | LettaStreamingRequest.SummarizedReasoningContent
+      >
+    | null;
 
   /**
-   * The id of the user that made this object.
+   * Maximum number of steps the agent should take to process the request.
    */
-  last_updated_by_id?: string | null;
+  max_steps?: number;
 
   /**
-   * The model used to make the function call.
+   * The messages to be sent to the agent.
    */
-  model?: string | null;
+  messages?: Array<AgentsAPI.MessageCreate | ApprovalCreate> | null;
 
   /**
-   * For role user/assistant: the (optional) name of the participant. For role
-   * tool/function: the name of the function called.
+   * Flag to determine if individual tokens should be streamed, rather than streaming
+   * per step (only used when streaming=true).
    */
-  name?: string | null;
+  stream_tokens?: boolean;
 
   /**
-   * The offline threading id associated with this message
+   * If True, returns a streaming response (Server-Sent Events). If False (default),
+   * returns a complete response.
    */
-  otid?: string | null;
+  streaming?: boolean;
 
   /**
-   * The id of the sender of the message, can be an identity id or agent id
+   * @deprecated Whether the server should parse specific tool call arguments
+   * (default `send_message`) as `AssistantMessage` objects. Still supported for
+   * legacy agent types, but deprecated for letta_v1_agent onward.
    */
-  sender_id?: string | null;
+  use_assistant_message?: boolean;
+}
+
+export namespace LettaStreamingRequest {
+  /**
+   * The style of reasoning content returned by the OpenAI Responses API
+   */
+  export interface SummarizedReasoningContent {
+    /**
+     * The unique identifier for this reasoning step.
+     */
+    id: string;
+
+    /**
+     * Summaries of the reasoning content.
+     */
+    summary: Array<SummarizedReasoningContent.Summary>;
+
+    /**
+     * The encrypted reasoning content.
+     */
+    encrypted_content?: string;
+
+    /**
+     * Indicates this is a summarized reasoning step.
+     */
+    type?: 'summarized_reasoning';
+  }
+
+  export namespace SummarizedReasoningContent {
+    export interface Summary {
+      /**
+       * The index of the summary part.
+       */
+      index: number;
+
+      /**
+       * The text of the summary part.
+       */
+      text: string;
+    }
+  }
+}
+
+/**
+ * Streaming response type for Server-Sent Events (SSE) endpoints. Each event in
+ * the stream will be one of these types.
+ */
+export type LettaStreamingResponse =
+  | SystemMessage
+  | UserMessage
+  | ReasoningMessage
+  | HiddenReasoningMessage
+  | ToolCallMessage
+  | ToolsAPI.ToolReturnMessage
+  | AssistantMessage
+  | ApprovalRequestMessage
+  | ApprovalResponseMessage
+  | LettaStreamingResponse.LettaPing
+  | LettaStreamingResponse.LettaStopReason
+  | LettaStreamingResponse.LettaUsageStatistics;
 
+export namespace LettaStreamingResponse {
   /**
-   * The id of the step that this message was created in.
+   * Ping messages are a keep-alive to prevent SSE streams from timing out during
+   * long running requests.
    */
-  step_id?: string | null;
+  export interface LettaPing {
+    /**
+     * The type of the message.
+     */
+    message_type: 'ping';
+  }
 
   /**
-   * The ID of the tool call. Only applicable for role tool.
+   * The stop reason from Letta indicating why agent loop stopped execution.
    */
-  tool_call_id?: string | null;
+  export interface LettaStopReason {
+    /**
+     * The reason why execution stopped.
+     */
+    stop_reason: RunsAPI.StopReasonType;
 
-  /**
-   * The list of tool calls requested. Only applicable for role assistant.
-   */
-  tool_calls?: Array<Message.ToolCall> | null;
+    /**
+     * The type of the message.
+     */
+    message_type?: 'stop_reason';
+  }
 
   /**
-   * Tool execution return information for prior tool calls
+   * Usage statistics for the agent interaction.
+   *
+   * Attributes: completion_tokens (int): The number of tokens generated by the
+   * agent. prompt_tokens (int): The number of tokens in the prompt. total_tokens
+   * (int): The total number of tokens processed by the agent. step_count (int): The
+   * number of steps taken by the agent.
    */
-  tool_returns?: Array<ToolReturn> | null;
+  export interface LettaUsageStatistics {
+    /**
+     * The number of tokens generated by the agent.
+     */
+    completion_tokens?: number;
 
-  /**
-   * The timestamp when the object was last updated.
-   */
-  updated_at?: string | null;
-}
+    message_type?: 'usage_statistics';
 
-export namespace Message {
-  export interface ToolCall {
-    id: string;
+    /**
+     * The number of tokens in the prompt.
+     */
+    prompt_tokens?: number;
 
-    function: ToolCall.Function;
+    /**
+     * The background task run IDs associated with the agent interaction
+     */
+    run_ids?: Array<string> | null;
 
-    type: 'function';
+    /**
+     * The number of steps taken by the agent.
+     */
+    step_count?: number;
 
-    [k: string]: unknown;
+    /**
+     * The total number of tokens processed by the agent.
+     */
+    total_tokens?: number;
   }
+}
 
-  export namespace ToolCall {
-    export interface Function {
-      arguments: string;
-
-      name: string;
+export type LettaUserMessageContentUnion = TextContent | ImageContent;
 
-      [k: string]: unknown;
-    }
-  }
-}
+/**
+ * A message generated by the system. Never streamed back on a response, only used
+ * for cursor pagination.
+ *
+ * Args: id (str): The ID of the message date (datetime): The date the message was
+ * created in ISO format name (Optional[str]): The name of the sender of the
+ * message content (str): The message content sent by the system
+ */
+export type Message =
+  | SystemMessage
+  | UserMessage
+  | ReasoningMessage
+  | HiddenReasoningMessage
+  | ToolCallMessage
+  | ToolsAPI.ToolReturnMessage
+  | AssistantMessage
+  | ApprovalRequestMessage
+  | ApprovalResponseMessage
+  | SummaryMessage
+  | EventMessage;
 
 export type MessageRole = 'assistant' | 'user' | 'tool' | 'function' | 'system' | 'approval';
 
@@ -764,13 +1200,25 @@ export type MessageType =
   | 'approval_request_message'
   | 'approval_response_message';
 
+/**
+ * A placeholder for reasoning content we know is present, but isn't returned by
+ * the provider (e.g. OpenAI GPT-5 on ChatCompletions)
+ */
 export interface OmittedReasoningContent {
+  /**
+   * A unique identifier for this reasoning step.
+   */
+  signature?: string | null;
+
   /**
    * Indicates this is an omitted reasoning step.
    */
   type?: 'omitted_reasoning';
 }
 
+/**
+ * Sent via the Anthropic Messages API
+ */
 export interface ReasoningContent {
   /**
    * Whether the reasoning content was generated by a reasoner model that processed
@@ -835,6 +1283,9 @@ export interface ReasoningMessage {
   step_id?: string | null;
 }
 
+/**
+ * Sent via the Anthropic Messages API
+ */
 export interface RedactedReasoningContent {
   /**
    * The redacted or filtered intermediate reasoning content.
@@ -848,20 +1299,30 @@ export interface RedactedReasoningContent {
 }
 
 /**
- * Representation of a run, which is a job with a 'run' prefix in its ID. Inherits
- * all fields and behavior from Job except for the ID prefix.
- *
- * Parameters: id (str): The unique identifier of the run (prefixed with 'run-').
- * status (JobStatus): The status of the run. created_at (datetime): The unix
- * timestamp of when the run was created. completed_at (datetime): The unix
- * timestamp of when the run was completed. user_id (str): The unique identifier of
- * the user associated with the run.
+ * Representation of a run - a conversation or processing session for an agent.
+ * Runs track when agents process messages and maintain the relationship between
+ * agents, steps, and messages.
  */
 export interface Run {
   /**
    * The human-friendly ID of the Run
    */
-  id?: string;
+  id: string;
+
+  /**
+   * The unique identifier of the agent associated with the run.
+   */
+  agent_id: string;
+
+  /**
+   * Whether the run was created in background mode.
+   */
+  background?: boolean | null;
+
+  /**
+   * The base template ID that the run belongs to.
+   */
+  base_template_id?: string | null;
 
   /**
    * Optional error message from attempting to POST the callback endpoint.
@@ -879,34 +1340,22 @@ export interface Run {
   callback_status_code?: number | null;
 
   /**
-   * If set, POST to this URL when the job completes.
+   * If set, POST to this URL when the run completes.
    */
   callback_url?: string | null;
 
   /**
-   * The unix timestamp of when the job was completed.
+   * The timestamp when the run was completed.
    */
   completed_at?: string | null;
 
   /**
-   * The unix timestamp of when the job was created.
+   * The timestamp when the run was created.
    */
   created_at?: string;
 
   /**
-   * The id of the user that made this object.
-   */
-  created_by_id?: string | null;
-
-  job_type?: JobType;
-
-  /**
-   * The id of the user that made this object.
-   */
-  last_updated_by_id?: string | null;
-
-  /**
-   * The metadata of the job.
+   * Additional metadata for the run.
    */
   metadata?: { [key: string]: unknown } | null;
 
@@ -916,9 +1365,9 @@ export interface Run {
   request_config?: Run.RequestConfig | null;
 
   /**
-   * The status of the job.
+   * The current status of the run.
    */
-  status?: JobStatus;
+  status?: 'created' | 'running' | 'completed' | 'failed' | 'cancelled';
 
   /**
    * The reason why the run was stopped.
@@ -934,11 +1383,6 @@ export interface Run {
    * Time to first token for a run in nanoseconds
    */
   ttft_ns?: number | null;
-
-  /**
-   * The timestamp when the object was last updated.
-   */
-  updated_at?: string | null;
 }
 
 export namespace Run {
@@ -970,6 +1414,34 @@ export namespace Run {
   }
 }
 
+/**
+ * A message representing a summary of the conversation. Sent to the LLM as a user
+ * or system message depending on the provider.
+ */
+export interface SummaryMessage {
+  id: string;
+
+  date: string;
+
+  summary: string;
+
+  is_err?: boolean | null;
+
+  message_type?: 'summary';
+
+  name?: string | null;
+
+  otid?: string | null;
+
+  run_id?: string | null;
+
+  sender_id?: string | null;
+
+  seq_id?: number | null;
+
+  step_id?: string | null;
+}
+
 /**
  * A message generated by the system. Never streamed back on a response, only used
  * for cursor pagination.
@@ -1014,6 +1486,11 @@ export interface TextContent {
    */
   text: string;
 
+  /**
+   * Stores a unique identifier for any reasoning associated with this text content.
+   */
+  signature?: string | null;
+
   /**
    * The type of the message.
    */
@@ -1045,6 +1522,11 @@ export interface ToolCallContent {
    */
   name: string;
 
+  /**
+   * Stores a unique identifier for any reasoning associated with this tool call.
+   */
+  signature?: string | null;
+
   /**
    * Indicates this content represents a tool call event.
    */
@@ -1072,6 +1554,9 @@ export interface ToolCallMessage {
 
   date: string;
 
+  /**
+   * @deprecated
+   */
   tool_call: ToolCall | ToolCallDelta;
 
   is_err?: boolean | null;
@@ -1092,23 +1577,25 @@ export interface ToolCallMessage {
   seq_id?: number | null;
 
   step_id?: string | null;
+
+  tool_calls?: Array<ToolCall> | ToolCallDelta | null;
 }
 
 export interface ToolReturn {
-  /**
-   * The status of the tool call
-   */
   status: 'success' | 'error';
 
-  /**
-   * Captured stderr from the tool invocation
-   */
+  tool_call_id: string;
+
+  tool_return: string;
+
   stderr?: Array<string> | null;
 
+  stdout?: Array<string> | null;
+
   /**
-   * Captured stdout (e.g. prints, logs) from the tool invocation
+   * The message type to be created.
    */
-  stdout?: Array<string> | null;
+  type?: 'tool';
 }
 
 export interface ToolReturnContent {
@@ -1159,408 +1646,264 @@ export interface UpdateSystemMessage {
   message_type?: 'system_message';
 }
 
-export interface UpdateUserMessage {
-  /**
-   * The message content sent by the user (can be a string or an array of multi-modal
-   * content parts)
-   */
-  content: Array<LettaUserMessageContentUnion> | string;
-
-  message_type?: 'user_message';
-}
-
-/**
- * A message sent by the user. Never streamed back on a response, only used for
- * cursor pagination.
- *
- * Args: id (str): The ID of the message date (datetime): The date the message was
- * created in ISO format name (Optional[str]): The name of the sender of the
- * message content (Union[str, List[LettaUserMessageContentUnion]]): The message
- * content sent by the user (can be a string or an array of multi-modal content
- * parts)
- */
-export interface UserMessage {
-  id: string;
-
-  /**
-   * The message content sent by the user (can be a string or an array of multi-modal
-   * content parts)
-   */
-  content: Array<LettaUserMessageContentUnion> | string;
-
-  date: string;
-
-  is_err?: boolean | null;
-
-  /**
-   * The type of the message.
-   */
-  message_type?: 'user_message';
-
-  name?: string | null;
-
-  otid?: string | null;
-
-  run_id?: string | null;
-
-  sender_id?: string | null;
-
-  seq_id?: number | null;
-
-  step_id?: string | null;
-}
-
-/**
- * A message generated by the system. Never streamed back on a response, only used
- * for cursor pagination.
- *
- * Args: id (str): The ID of the message date (datetime): The date the message was
- * created in ISO format name (Optional[str]): The name of the sender of the
- * message content (str): The message content sent by the system
- */
-export type MessageUpdateResponse =
-  | SystemMessage
-  | UserMessage
-  | ReasoningMessage
-  | HiddenReasoningMessage
-  | ToolCallMessage
-  | ToolsAPI.ToolReturnMessage
-  | AssistantMessage
-  | ApprovalRequestMessage
-  | ApprovalResponseMessage;
-
-export type MessageListResponse = Array<LettaMessageUnion>;
-
-export type MessageCancelResponse = { [key: string]: unknown };
-
-export type MessagePreviewRawPayloadResponse = { [key: string]: unknown };
-
-export type MessageSearchResponse = Array<MessageSearchResponse.MessageSearchResponseItem>;
-
-export namespace MessageSearchResponse {
-  /**
-   * Result from a message search operation with scoring details.
-   */
-  export interface MessageSearchResponseItem {
-    /**
-     * The embedded content (LLM-friendly)
-     */
-    embedded_text: string;
-
-    /**
-     * The raw message object
-     */
-    message: MessagesAPI.Message;
-
-    /**
-     * Reciprocal Rank Fusion combined score
-     */
-    rrf_score: number;
-
-    /**
-     * Full-text search rank position if FTS was used
-     */
-    fts_rank?: number | null;
-
-    /**
-     * Vector search rank position if vector search was used
-     */
-    vector_rank?: number | null;
-  }
-}
-
-export type MessageSendStreamResponse = unknown;
-
-export type MessageUpdateParams =
-  | MessageUpdateParams.UpdateSystemMessage
-  | MessageUpdateParams.UpdateUserMessage
-  | MessageUpdateParams.UpdateReasoningMessage
-  | MessageUpdateParams.UpdateAssistantMessage;
+export interface UpdateUserMessage {
+  /**
+   * The message content sent by the user (can be a string or an array of multi-modal
+   * content parts)
+   */
+  content: Array<LettaUserMessageContentUnion> | string;
 
-export declare namespace MessageUpdateParams {
-  export interface UpdateSystemMessage {
-    /**
-     * Path param:
-     */
-    agent_id: string;
+  message_type?: 'user_message';
+}
 
-    /**
-     * Body param: The message content sent by the system (can be a string or an array
-     * of multi-modal content parts)
-     */
-    content: string;
+/**
+ * A message sent by the user. Never streamed back on a response, only used for
+ * cursor pagination.
+ *
+ * Args: id (str): The ID of the message date (datetime): The date the message was
+ * created in ISO format name (Optional[str]): The name of the sender of the
+ * message content (Union[str, List[LettaUserMessageContentUnion]]): The message
+ * content sent by the user (can be a string or an array of multi-modal content
+ * parts)
+ */
+export interface UserMessage {
+  id: string;
 
-    /**
-     * Body param:
-     */
-    message_type?: 'system_message';
-  }
+  /**
+   * The message content sent by the user (can be a string or an array of multi-modal
+   * content parts)
+   */
+  content: Array<LettaUserMessageContentUnion> | string;
 
-  export interface UpdateUserMessage {
-    /**
-     * Path param:
-     */
-    agent_id: string;
+  date: string;
 
-    /**
-     * Body param: The message content sent by the user (can be a string or an array of
-     * multi-modal content parts)
-     */
-    content: Array<LettaUserMessageContentUnion> | string;
+  is_err?: boolean | null;
 
-    /**
-     * Body param:
-     */
-    message_type?: 'user_message';
-  }
+  /**
+   * The type of the message.
+   */
+  message_type?: 'user_message';
 
-  export interface UpdateReasoningMessage {
-    /**
-     * Path param:
-     */
-    agent_id: string;
+  name?: string | null;
 
-    /**
-     * Body param:
-     */
-    reasoning: string;
+  otid?: string | null;
 
-    /**
-     * Body param:
-     */
-    message_type?: 'reasoning_message';
-  }
+  run_id?: string | null;
 
-  export interface UpdateAssistantMessage {
-    /**
-     * Path param:
-     */
-    agent_id: string;
+  sender_id?: string | null;
 
-    /**
-     * Body param: The message content sent by the assistant (can be a string or an
-     * array of content parts)
-     */
-    content: Array<LettaAssistantMessageContentUnion> | string;
+  seq_id?: number | null;
 
-    /**
-     * Body param:
-     */
-    message_type?: 'assistant_message';
-  }
+  step_id?: string | null;
 }
 
-export interface MessageListParams {
-  /**
-   * Message after which to retrieve the returned messages.
-   */
-  after?: string | null;
+export type MessageCancelResponse = { [key: string]: unknown };
+
+export type MessageCreateParams = MessageCreateParamsNonStreaming | MessageCreateParamsStreaming;
 
+export interface MessageCreateParamsBase {
   /**
-   * The name of the message argument.
+   * @deprecated The name of the message argument in the designated message tool.
+   * Still supported for legacy agent types, but deprecated for letta_v1_agent
+   * onward.
    */
   assistant_message_tool_kwarg?: string;
 
   /**
-   * The name of the designated message tool.
+   * @deprecated The name of the designated message tool. Still supported for legacy
+   * agent types, but deprecated for letta_v1_agent onward.
    */
   assistant_message_tool_name?: string;
 
   /**
-   * Message before which to retrieve the returned messages.
+   * Whether to process the request in the background (only used when
+   * streaming=true).
    */
-  before?: string | null;
+  background?: boolean;
 
   /**
-   * Group ID to filter messages by.
+   * @deprecated If set to True, enables reasoning before responses or tool calls
+   * from the agent.
    */
-  group_id?: string | null;
+  enable_thinking?: string;
 
   /**
-   * Whether to include error messages and error statuses. For debugging purposes
-   * only.
+   * Whether to include periodic keepalive ping messages in the stream to prevent
+   * connection timeouts (only used when streaming=true).
    */
-  include_err?: boolean | null;
+  include_pings?: boolean;
 
   /**
-   * Maximum number of messages to retrieve.
+   * Only return specified message types in the response. If `None` (default) returns
+   * all messages.
    */
-  limit?: number;
+  include_return_message_types?: Array<MessageType> | null;
 
   /**
-   * Whether to use assistant messages
+   * Syntactic sugar for a single user message. Equivalent to messages=[{'role':
+   * 'user', 'content': input}].
    */
-  use_assistant_message?: boolean;
-}
+  input?:
+    | string
+    | Array<
+        | TextContent
+        | ImageContent
+        | ToolCallContent
+        | ToolReturnContent
+        | ReasoningContent
+        | RedactedReasoningContent
+        | OmittedReasoningContent
+        | MessageCreateParams.SummarizedReasoningContent
+      >
+    | null;
 
-export interface MessageCancelParams {
   /**
-   * Optional list of run IDs to cancel
+   * Maximum number of steps the agent should take to process the request.
    */
-  run_ids?: Array<string> | null;
-}
+  max_steps?: number;
 
-export type MessagePreviewRawPayloadParams =
-  | MessagePreviewRawPayloadParams.LettaRequest
-  | MessagePreviewRawPayloadParams.LettaStreamingRequest;
+  /**
+   * The messages to be sent to the agent.
+   */
+  messages?: Array<AgentsAPI.MessageCreate | ApprovalCreate> | null;
 
-export declare namespace MessagePreviewRawPayloadParams {
-  export interface LettaRequest {
-    /**
-     * The messages to be sent to the agent.
-     */
-    messages: Array<AgentsAPI.MessageCreate | ApprovalCreate>;
+  /**
+   * Flag to determine if individual tokens should be streamed, rather than streaming
+   * per step (only used when streaming=true).
+   */
+  stream_tokens?: boolean;
 
-    /**
-     * The name of the message argument in the designated message tool.
-     */
-    assistant_message_tool_kwarg?: string;
+  /**
+   * If True, returns a streaming response (Server-Sent Events). If False (default),
+   * returns a complete response.
+   */
+  streaming?: boolean;
 
-    /**
-     * The name of the designated message tool.
-     */
-    assistant_message_tool_name?: string;
+  /**
+   * @deprecated Whether the server should parse specific tool call arguments
+   * (default `send_message`) as `AssistantMessage` objects. Still supported for
+   * legacy agent types, but deprecated for letta_v1_agent onward.
+   */
+  use_assistant_message?: boolean;
+}
 
+export namespace MessageCreateParams {
+  /**
+   * The style of reasoning content returned by the OpenAI Responses API
+   */
+  export interface SummarizedReasoningContent {
     /**
-     * If set to True, enables reasoning before responses or tool calls from the agent.
+     * The unique identifier for this reasoning step.
      */
-    enable_thinking?: string;
+    id: string;
 
     /**
-     * Only return specified message types in the response. If `None` (default) returns
-     * all messages.
+     * Summaries of the reasoning content.
      */
-    include_return_message_types?: Array<MessageType> | null;
+    summary: Array<SummarizedReasoningContent.Summary>;
 
     /**
-     * Maximum number of steps the agent should take to process the request.
+     * The encrypted reasoning content.
      */
-    max_steps?: number;
+    encrypted_content?: string;
 
     /**
-     * Whether the server should parse specific tool call arguments (default
-     * `send_message`) as `AssistantMessage` objects.
+     * Indicates this is a summarized reasoning step.
      */
-    use_assistant_message?: boolean;
+    type?: 'summarized_reasoning';
   }
 
-  export interface LettaStreamingRequest {
-    /**
-     * The messages to be sent to the agent.
-     */
-    messages: Array<AgentsAPI.MessageCreate | ApprovalCreate>;
-
-    /**
-     * The name of the message argument in the designated message tool.
-     */
-    assistant_message_tool_kwarg?: string;
-
-    /**
-     * The name of the designated message tool.
-     */
-    assistant_message_tool_name?: string;
-
-    /**
-     * Whether to process the request in the background.
-     */
-    background?: boolean;
-
-    /**
-     * If set to True, enables reasoning before responses or tool calls from the agent.
-     */
-    enable_thinking?: string;
-
-    /**
-     * Whether to include periodic keepalive ping messages in the stream to prevent
-     * connection timeouts.
-     */
-    include_pings?: boolean;
-
-    /**
-     * Only return specified message types in the response. If `None` (default) returns
-     * all messages.
-     */
-    include_return_message_types?: Array<MessageType> | null;
-
-    /**
-     * Maximum number of steps the agent should take to process the request.
-     */
-    max_steps?: number;
-
-    /**
-     * Flag to determine if individual tokens should be streamed, rather than streaming
-     * per step.
-     */
-    stream_tokens?: boolean;
-
-    /**
-     * Whether the server should parse specific tool call arguments (default
-     * `send_message`) as `AssistantMessage` objects.
-     */
-    use_assistant_message?: boolean;
+  export namespace SummarizedReasoningContent {
+    export interface Summary {
+      /**
+       * The index of the summary part.
+       */
+      index: number;
+
+      /**
+       * The text of the summary part.
+       */
+      text: string;
+    }
   }
+
+  export type MessageCreateParamsNonStreaming = MessagesAPI.MessageCreateParamsNonStreaming;
+  export type MessageCreateParamsStreaming = MessagesAPI.MessageCreateParamsStreaming;
 }
 
-export interface MessageSearchParams {
+export interface MessageCreateParamsNonStreaming extends MessageCreateParamsBase {
   /**
-   * Filter messages created on or before this date
+   * If True, returns a streaming response (Server-Sent Events). If False (default),
+   * returns a complete response.
    */
-  end_date?: string | null;
+  streaming?: false;
+}
 
+export interface MessageCreateParamsStreaming extends MessageCreateParamsBase {
   /**
-   * Maximum number of results to return
+   * If True, returns a streaming response (Server-Sent Events). If False (default),
+   * returns a complete response.
    */
-  limit?: number;
+  streaming: true;
+}
 
+export interface MessageListParams extends ArrayPageParams {
   /**
-   * Filter messages by project ID
+   * @deprecated The name of the message argument.
    */
-  project_id?: string | null;
+  assistant_message_tool_kwarg?: string;
 
   /**
-   * Text query for full-text search
+   * @deprecated The name of the designated message tool.
    */
-  query?: string | null;
+  assistant_message_tool_name?: string;
 
   /**
-   * Filter messages by role
+   * Group ID to filter messages by.
    */
-  roles?: Array<MessageRole> | null;
+  group_id?: string | null;
 
   /**
-   * Search mode to use
+   * Whether to include error messages and error statuses. For debugging purposes
+   * only.
    */
-  search_mode?: 'vector' | 'fts' | 'hybrid';
+  include_err?: boolean | null;
 
   /**
-   * Filter messages created after this date
+   * @deprecated Whether to use assistant messages
    */
-  start_date?: string | null;
+  use_assistant_message?: boolean;
+}
 
+export interface MessageCancelParams {
   /**
-   * Filter messages by template ID
+   * Optional list of run IDs to cancel
    */
-  template_id?: string | null;
+  run_ids?: Array<string> | null;
 }
 
-export interface MessageSendParams {
+export interface MessageCreateAsyncParams {
   /**
-   * The messages to be sent to the agent.
+   * @deprecated The name of the message argument in the designated message tool.
+   * Still supported for legacy agent types, but deprecated for letta_v1_agent
+   * onward.
    */
-  messages: Array<AgentsAPI.MessageCreate | ApprovalCreate>;
+  assistant_message_tool_kwarg?: string;
 
   /**
-   * The name of the message argument in the designated message tool.
+   * @deprecated The name of the designated message tool. Still supported for legacy
+   * agent types, but deprecated for letta_v1_agent onward.
    */
-  assistant_message_tool_kwarg?: string;
+  assistant_message_tool_name?: string;
 
   /**
-   * The name of the designated message tool.
+   * Optional callback URL to POST to when the job completes
    */
-  assistant_message_tool_name?: string;
+  callback_url?: string | null;
 
   /**
-   * If set to True, enables reasoning before responses or tool calls from the agent.
+   * @deprecated If set to True, enables reasoning before responses or tool calls
+   * from the agent.
    */
   enable_thinking?: string;
 
@@ -1571,90 +1914,118 @@ export interface MessageSendParams {
   include_return_message_types?: Array<MessageType> | null;
 
   /**
-   * Maximum number of steps the agent should take to process the request.
+   * Syntactic sugar for a single user message. Equivalent to messages=[{'role':
+   * 'user', 'content': input}].
    */
-  max_steps?: number;
+  input?:
+    | string
+    | Array<
+        | TextContent
+        | ImageContent
+        | ToolCallContent
+        | ToolReturnContent
+        | ReasoningContent
+        | RedactedReasoningContent
+        | OmittedReasoningContent
+        | MessageCreateAsyncParams.SummarizedReasoningContent
+      >
+    | null;
 
   /**
-   * Whether the server should parse specific tool call arguments (default
-   * `send_message`) as `AssistantMessage` objects.
+   * Maximum number of steps the agent should take to process the request.
    */
-  use_assistant_message?: boolean;
-}
+  max_steps?: number;
 
-export interface MessageSendAsyncParams {
   /**
    * The messages to be sent to the agent.
    */
-  messages: Array<AgentsAPI.MessageCreate | ApprovalCreate>;
-
-  /**
-   * The name of the message argument in the designated message tool.
-   */
-  assistant_message_tool_kwarg?: string;
+  messages?: Array<AgentsAPI.MessageCreate | ApprovalCreate> | null;
 
   /**
-   * The name of the designated message tool.
+   * @deprecated Whether the server should parse specific tool call arguments
+   * (default `send_message`) as `AssistantMessage` objects. Still supported for
+   * legacy agent types, but deprecated for letta_v1_agent onward.
    */
-  assistant_message_tool_name?: string;
+  use_assistant_message?: boolean;
+}
 
+export namespace MessageCreateAsyncParams {
   /**
-   * Optional callback URL to POST to when the job completes
+   * The style of reasoning content returned by the OpenAI Responses API
    */
-  callback_url?: string | null;
+  export interface SummarizedReasoningContent {
+    /**
+     * The unique identifier for this reasoning step.
+     */
+    id: string;
 
-  /**
-   * If set to True, enables reasoning before responses or tool calls from the agent.
-   */
-  enable_thinking?: string;
+    /**
+     * Summaries of the reasoning content.
+     */
+    summary: Array<SummarizedReasoningContent.Summary>;
 
-  /**
-   * Only return specified message types in the response. If `None` (default) returns
-   * all messages.
-   */
-  include_return_message_types?: Array<MessageType> | null;
+    /**
+     * The encrypted reasoning content.
+     */
+    encrypted_content?: string;
 
-  /**
-   * Maximum number of steps the agent should take to process the request.
-   */
-  max_steps?: number;
+    /**
+     * Indicates this is a summarized reasoning step.
+     */
+    type?: 'summarized_reasoning';
+  }
 
-  /**
-   * Whether the server should parse specific tool call arguments (default
-   * `send_message`) as `AssistantMessage` objects.
-   */
-  use_assistant_message?: boolean;
+  export namespace SummarizedReasoningContent {
+    export interface Summary {
+      /**
+       * The index of the summary part.
+       */
+      index: number;
+
+      /**
+       * The text of the summary part.
+       */
+      text: string;
+    }
+  }
 }
 
-export interface MessageSendStreamParams {
+export interface MessageResetParams {
   /**
-   * The messages to be sent to the agent.
+   * If true, adds the default initial messages after resetting.
    */
-  messages: Array<AgentsAPI.MessageCreate | ApprovalCreate>;
+  add_default_initial_messages?: boolean;
+}
 
+export interface MessageStreamParams {
   /**
-   * The name of the message argument in the designated message tool.
+   * @deprecated The name of the message argument in the designated message tool.
+   * Still supported for legacy agent types, but deprecated for letta_v1_agent
+   * onward.
    */
   assistant_message_tool_kwarg?: string;
 
   /**
-   * The name of the designated message tool.
+   * @deprecated The name of the designated message tool. Still supported for legacy
+   * agent types, but deprecated for letta_v1_agent onward.
    */
   assistant_message_tool_name?: string;
 
   /**
-   * Whether to process the request in the background.
+   * Whether to process the request in the background (only used when
+   * streaming=true).
    */
   background?: boolean;
 
   /**
-   * If set to True, enables reasoning before responses or tool calls from the agent.
+   * @deprecated If set to True, enables reasoning before responses or tool calls
+   * from the agent.
    */
   enable_thinking?: string;
 
   /**
    * Whether to include periodic keepalive ping messages in the stream to prevent
-   * connection timeouts.
+   * connection timeouts (only used when streaming=true).
    */
   include_pings?: boolean;
 
@@ -1664,39 +2035,113 @@ export interface MessageSendStreamParams {
    */
   include_return_message_types?: Array<MessageType> | null;
 
+  /**
+   * Syntactic sugar for a single user message. Equivalent to messages=[{'role':
+   * 'user', 'content': input}].
+   */
+  input?:
+    | string
+    | Array<
+        | TextContent
+        | ImageContent
+        | ToolCallContent
+        | ToolReturnContent
+        | ReasoningContent
+        | RedactedReasoningContent
+        | OmittedReasoningContent
+        | MessageStreamParams.SummarizedReasoningContent
+      >
+    | null;
+
   /**
    * Maximum number of steps the agent should take to process the request.
    */
   max_steps?: number;
 
+  /**
+   * The messages to be sent to the agent.
+   */
+  messages?: Array<AgentsAPI.MessageCreate | ApprovalCreate> | null;
+
   /**
    * Flag to determine if individual tokens should be streamed, rather than streaming
-   * per step.
+   * per step (only used when streaming=true).
    */
   stream_tokens?: boolean;
 
   /**
-   * Whether the server should parse specific tool call arguments (default
-   * `send_message`) as `AssistantMessage` objects.
+   * If True, returns a streaming response (Server-Sent Events). If False (default),
+   * returns a complete response.
+   */
+  streaming?: boolean;
+
+  /**
+   * @deprecated Whether the server should parse specific tool call arguments
+   * (default `send_message`) as `AssistantMessage` objects. Still supported for
+   * legacy agent types, but deprecated for letta_v1_agent onward.
    */
   use_assistant_message?: boolean;
 }
 
+export namespace MessageStreamParams {
+  /**
+   * The style of reasoning content returned by the OpenAI Responses API
+   */
+  export interface SummarizedReasoningContent {
+    /**
+     * The unique identifier for this reasoning step.
+     */
+    id: string;
+
+    /**
+     * Summaries of the reasoning content.
+     */
+    summary: Array<SummarizedReasoningContent.Summary>;
+
+    /**
+     * The encrypted reasoning content.
+     */
+    encrypted_content?: string;
+
+    /**
+     * Indicates this is a summarized reasoning step.
+     */
+    type?: 'summarized_reasoning';
+  }
+
+  export namespace SummarizedReasoningContent {
+    export interface Summary {
+      /**
+       * The index of the summary part.
+       */
+      index: number;
+
+      /**
+       * The text of the summary part.
+       */
+      text: string;
+    }
+  }
+}
+
 export declare namespace Messages {
   export {
     type ApprovalCreate as ApprovalCreate,
     type ApprovalRequestMessage as ApprovalRequestMessage,
     type ApprovalResponseMessage as ApprovalResponseMessage,
+    type ApprovalReturn as ApprovalReturn,
     type AssistantMessage as AssistantMessage,
+    type EventMessage as EventMessage,
     type HiddenReasoningMessage as HiddenReasoningMessage,
     type ImageContent as ImageContent,
+    type InternalMessage as InternalMessage,
     type JobStatus as JobStatus,
     type JobType as JobType,
     type LettaAssistantMessageContentUnion as LettaAssistantMessageContentUnion,
-    type LettaMessageUnion as LettaMessageUnion,
     type LettaRequest as LettaRequest,
     type LettaResponse as LettaResponse,
     type LettaStreamingRequest as LettaStreamingRequest,
+    type LettaStreamingResponse as LettaStreamingResponse,
     type LettaUserMessageContentUnion as LettaUserMessageContentUnion,
     type Message as Message,
     type MessageRole as MessageRole,
@@ -1706,6 +2151,7 @@ export declare namespace Messages {
     type ReasoningMessage as ReasoningMessage,
     type RedactedReasoningContent as RedactedReasoningContent,
     type Run as Run,
+    type SummaryMessage as SummaryMessage,
     type SystemMessage as SystemMessage,
     type TextContent as TextContent,
     type ToolCall as ToolCall,
@@ -1719,19 +2165,15 @@ export declare namespace Messages {
     type UpdateSystemMessage as UpdateSystemMessage,
     type UpdateUserMessage as UpdateUserMessage,
     type UserMessage as UserMessage,
-    type MessageUpdateResponse as MessageUpdateResponse,
-    type MessageListResponse as MessageListResponse,
     type MessageCancelResponse as MessageCancelResponse,
-    type MessagePreviewRawPayloadResponse as MessagePreviewRawPayloadResponse,
-    type MessageSearchResponse as MessageSearchResponse,
-    type MessageSendStreamResponse as MessageSendStreamResponse,
-    type MessageUpdateParams as MessageUpdateParams,
+    type MessagesArrayPage as MessagesArrayPage,
+    type MessageCreateParams as MessageCreateParams,
+    type MessageCreateParamsNonStreaming as MessageCreateParamsNonStreaming,
+    type MessageCreateParamsStreaming as MessageCreateParamsStreaming,
     type MessageListParams as MessageListParams,
     type MessageCancelParams as MessageCancelParams,
-    type MessagePreviewRawPayloadParams as MessagePreviewRawPayloadParams,
-    type MessageSearchParams as MessageSearchParams,
-    type MessageSendParams as MessageSendParams,
-    type MessageSendAsyncParams as MessageSendAsyncParams,
-    type MessageSendStreamParams as MessageSendStreamParams,
+    type MessageCreateAsyncParams as MessageCreateAsyncParams,
+    type MessageResetParams as MessageResetParams,
+    type MessageStreamParams as MessageStreamParams,
   };
 }