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

package/src/resources/agents/messages.ts

@@ -6,21 +6,54 @@ import * as ToolsAPI from '../tools';
 import * as AgentsAPI from './agents';
 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>>;
   }
 
   /**
@@ -30,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,
+    });
   }
 
   /**
@@ -49,22 +85,13 @@ export class Messages extends APIResource {
   }
 
   /**
-   * Resets the messages for an agent
-   */
-  reset(
-    agentID: string,
-    body: MessageResetParams,
-    options?: RequestOptions,
-  ): APIPromise<AgentsAPI.AgentState> {
-    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.
+   * 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]),
+    });
   }
 
   /**
@@ -75,30 +102,45 @@ export class Messages extends APIResource {
    * 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 });
   }
 
   /**
-   * 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.
+   * Resets the messages for an agent
    */
-  stream(agentID: string, body: MessageStreamParams, options?: RequestOptions): APIPromise<unknown> {
-    return this._client.post(path`/v1/agents/${agentID}/messages/stream`, { body, ...options });
+  reset(
+    agentID: string,
+    body: MessageResetParams,
+    options?: RequestOptions,
+  ): APIPromise<AgentsAPI.AgentState | null> {
+    return this._client.patch(path`/v1/agents/${agentID}/reset-messages`, { body, ...options });
   }
 
   /**
-   * Summarize an agent's conversation history.
+   * 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.
    */
-  summarize(agentID: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.post(path`/v1/agents/${agentID}/summarize`, {
+  stream(
+    agentID: string,
+    body: MessageStreamParams,
+    options?: RequestOptions,
+  ): APIPromise<Stream<LettaStreamingResponse>> {
+    return this._client.post(path`/v1/agents/${agentID}/messages/stream`, {
+      body,
       ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+      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
  */
@@ -111,13 +153,18 @@ export interface ApprovalCreate {
   /**
    * The list of approval responses
    */
-  approvals?: Array<ApprovalCreate.ApprovalReturn | ToolReturn> | null;
+  approvals?: Array<ApprovalReturn | ToolReturn> | null;
 
   /**
    * @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
    */
@@ -129,30 +176,6 @@ export interface ApprovalCreate {
   type?: 'approval';
 }
 
-export namespace ApprovalCreate {
-  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 representing a request for approval to call a tool (generated by the
  * LLM to trigger tool execution).
@@ -220,7 +243,7 @@ export interface ApprovalResponseMessage {
   /**
    * The list of approval responses
    */
-  approvals?: Array<ApprovalResponseMessage.ApprovalReturn | ToolReturn> | null;
+  approvals?: Array<ApprovalReturn | ToolReturn> | null;
 
   /**
    * @deprecated Whether the tool has been approved
@@ -252,28 +275,26 @@ export interface ApprovalResponseMessage {
   step_id?: string | null;
 }
 
-export namespace ApprovalResponseMessage {
-  export interface ApprovalReturn {
-    /**
-     * Whether the tool has been approved
-     */
-    approve: boolean;
+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;
+  /**
+   * 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;
+  /**
+   * An optional explanation for the provided approval status
+   */
+  reason?: string | null;
 
-    /**
-     * The message type to be created.
-     */
-    type?: 'approval';
-  }
+  /**
+   * The message type to be created.
+   */
+  type?: 'approval';
 }
 
 /**
@@ -315,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.
@@ -432,173 +483,300 @@ 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 type JobType = 'job' | 'run' | 'batch';
+export interface InternalMessage {
+  /**
+   * The human-friendly ID of the Message
+   */
+  id: string;
 
-export interface LettaAssistantMessageContentUnion {
   /**
-   * The text content of the message.
+   * The role of the participant.
    */
-  text: string;
+  role: MessageRole;
 
   /**
-   * Stores a unique identifier for any reasoning associated with this text content.
+   * The unique identifier of the agent.
    */
-  signature?: string | null;
+  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;
 
   /**
-   * @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.
+   * The id of the LLMBatchItem that this message is associated with
    */
-  assistant_message_tool_kwarg?: string;
+  batch_item_id?: string | null;
 
   /**
-   * @deprecated The name of the designated message tool. Still supported for legacy
-   * agent types, but deprecated for letta_v1_agent onward.
+   * The content of the message.
    */
-  assistant_message_tool_name?: string;
+  content?: Array<
+    | TextContent
+    | ImageContent
+    | ToolCallContent
+    | ToolReturnContent
+    | ReasoningContent
+    | RedactedReasoningContent
+    | OmittedReasoningContent
+    | InternalMessage.SummarizedReasoningContent
+  > | null;
 
   /**
-   * @deprecated 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;
 
   /**
-   * @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.
+   * 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 offline threading id associated with this message
+   */
+  otid?: string | null;
+
+  /**
+   * The id of the run that this message was created in.
+   */
+  run_id?: string | null;
+
+  /**
+   * The id of the sender of the message, can be an identity id or agent id
+   */
+  sender_id?: string | null;
+
+  /**
+   * 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 type of the message.
+     * The status of the tool call
      */
-    message_type?: 'stop_reason';
+    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;
   }
 
   /**
-   * The usage statistics of the agent.
+   * The style of reasoning content returned by the OpenAI Responses API
    */
-  export interface Usage {
+  export interface SummarizedReasoningContent {
     /**
-     * The number of tokens generated by the agent.
+     * The unique identifier for this reasoning step.
      */
-    completion_tokens?: number;
+    id: string;
 
-    message_type?: 'usage_statistics';
+    /**
+     * Summaries of the reasoning content.
+     */
+    summary: Array<SummarizedReasoningContent.Summary>;
 
     /**
-     * The number of tokens in the prompt.
+     * The encrypted reasoning content.
      */
-    prompt_tokens?: number;
+    encrypted_content?: string;
 
     /**
-     * The background task run IDs associated with the agent interaction
+     * Indicates this is a summarized reasoning step.
      */
-    run_ids?: Array<string> | null;
+    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 number of steps taken by the agent.
+     * The status of the tool call
      */
-    step_count?: number;
+    status: 'success' | 'error';
 
     /**
-     * The total number of tokens processed by the agent.
+     * The function response string
      */
-    total_tokens?: number;
+    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.
+   */
+  text: string;
+
+  /**
+   * Stores a unique identifier for any reasoning associated with this text content.
    */
-  messages: Array<AgentsAPI.MessageCreate | ApprovalCreate>;
+  signature?: string | null;
 
+  /**
+   * The type of the message.
+   */
+  type?: 'text';
+}
+
+export interface LettaRequest {
   /**
    * @deprecated The name of the message argument in the designated message tool.
    * Still supported for legacy agent types, but deprecated for letta_v1_agent
@@ -612,39 +790,45 @@ export interface LettaStreamingRequest {
    */
   assistant_message_tool_name?: string;
 
-  /**
-   * Whether to process the request in the background.
-   */
-  background?: boolean;
-
   /**
    * @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.
-   */
-  include_pings?: boolean;
-
   /**
    * Only return specified message types in the response. If `None` (default) returns
    * all messages.
    */
   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;
 
   /**
    * @deprecated Whether the server should parse specific tool call arguments
@@ -654,213 +838,209 @@ export interface LettaStreamingRequest {
   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 {
-  /**
-   * The role of the participant.
-   */
-  role: MessageRole;
-
+export interface LettaResponse {
   /**
-   * The human-friendly ID of the Message
+   * The messages returned by the agent.
    */
-  id?: string;
+  messages: Array<Message>;
 
   /**
-   * The unique identifier of the agent.
+   * The stop reason from Letta indicating why agent loop stopped execution.
    */
-  agent_id?: string | null;
+  stop_reason: LettaResponse.StopReason;
 
   /**
-   * The id of the approval request if this message is associated with a tool call
-   * request.
+   * The usage statistics of the agent.
    */
-  approval_request_id?: string | null;
+  usage: LettaResponse.Usage;
+}
 
+export namespace LettaResponse {
   /**
-   * The list of approvals for this message.
+   * The stop reason from Letta indicating why agent loop stopped execution.
    */
-  approvals?: Array<Message.ApprovalReturn | Message.LettaSchemasMessageToolReturn> | null;
+  export interface StopReason {
+    /**
+     * The reason why execution stopped.
+     */
+    stop_reason: RunsAPI.StopReasonType;
 
-  /**
-   * Whether tool call is approved.
-   */
-  approve?: boolean | null;
+    /**
+     * The type of the message.
+     */
+    message_type?: 'stop_reason';
+  }
 
   /**
-   * The id of the LLMBatchItem that this message is associated with
+   * The usage statistics of the agent.
    */
-  batch_item_id?: string | null;
+  export interface Usage {
+    /**
+     * The number of tokens generated by the agent.
+     */
+    completion_tokens?: number;
 
-  /**
-   * The content of the message.
-   */
-  content?: Array<
-    | TextContent
-    | ImageContent
-    | ToolCallContent
-    | ToolReturnContent
-    | ReasoningContent
-    | RedactedReasoningContent
-    | OmittedReasoningContent
-    | Message.SummarizedReasoningContent
-  > | null;
+    message_type?: 'usage_statistics';
 
-  /**
-   * The timestamp when the object was created.
-   */
-  created_at?: string;
+    /**
+     * The number of tokens in the prompt.
+     */
+    prompt_tokens?: number;
 
-  /**
-   * The id of the user that made this object.
-   */
-  created_by_id?: string | null;
+    /**
+     * The background task run IDs associated with the agent interaction
+     */
+    run_ids?: Array<string> | null;
 
-  /**
-   * The reason the tool call request was denied.
-   */
-  denial_reason?: string | null;
+    /**
+     * The number of steps taken by the agent.
+     */
+    step_count?: number;
 
-  /**
-   * The multi-agent group that the message was sent in
-   */
-  group_id?: string | null;
+    /**
+     * The total number of tokens processed by the agent.
+     */
+    total_tokens?: number;
+  }
+}
 
+export interface LettaStreamingRequest {
   /**
-   * Whether this message is part of an error step. Used only for debugging purposes.
+   * @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.
    */
-  is_err?: boolean | null;
+  assistant_message_tool_kwarg?: string;
 
   /**
-   * The id of the user that made this object.
+   * @deprecated The name of the designated message tool. Still supported for legacy
+   * agent types, but deprecated for letta_v1_agent onward.
    */
-  last_updated_by_id?: string | null;
+  assistant_message_tool_name?: string;
 
   /**
-   * The model used to make the function call.
+   * Whether to process the request in the background (only used when
+   * streaming=true).
    */
-  model?: string | null;
+  background?: boolean;
 
   /**
-   * For role user/assistant: the (optional) name of the participant. For role
-   * tool/function: the name of the function called.
+   * @deprecated If set to True, enables reasoning before responses or tool calls
+   * from the agent.
    */
-  name?: string | null;
+  enable_thinking?: string;
 
   /**
-   * The offline threading id associated with this message
+   * Whether to include periodic keepalive ping messages in the stream to prevent
+   * connection timeouts (only used when streaming=true).
    */
-  otid?: string | null;
+  include_pings?: boolean;
 
   /**
-   * The id of the run that this message was created in.
+   * Only return specified message types in the response. If `None` (default) returns
+   * all messages.
    */
-  run_id?: string | null;
+  include_return_message_types?: Array<MessageType> | null;
 
   /**
-   * The id of the sender of the message, can be an identity id or agent id
+   * Syntactic sugar for a single user message. Equivalent to messages=[{'role':
+   * 'user', 'content': input}].
    */
-  sender_id?: string | null;
+  input?:
+    | string
+    | Array<
+        | TextContent
+        | ImageContent
+        | ToolCallContent
+        | ToolReturnContent
+        | ReasoningContent
+        | RedactedReasoningContent
+        | OmittedReasoningContent
+        | LettaStreamingRequest.SummarizedReasoningContent
+      >
+    | null;
 
   /**
-   * The id of the step that this message was created in.
+   * Maximum number of steps the agent should take to process the request.
    */
-  step_id?: string | null;
+  max_steps?: number;
 
   /**
-   * The ID of the tool call. Only applicable for role tool.
+   * The messages to be sent to the agent.
    */
-  tool_call_id?: string | null;
+  messages?: Array<AgentsAPI.MessageCreate | ApprovalCreate> | null;
 
   /**
-   * The list of tool calls requested. Only applicable for role assistant.
+   * Flag to determine if individual tokens should be streamed, rather than streaming
+   * per step (only used when streaming=true).
    */
-  tool_calls?: Array<Message.ToolCall> | null;
+  stream_tokens?: boolean;
 
   /**
-   * Tool execution return information for prior tool calls
+   * If True, returns a streaming response (Server-Sent Events). If False (default),
+   * returns a complete response.
    */
-  tool_returns?: Array<Message.ToolReturn> | null;
+  streaming?: boolean;
 
   /**
-   * The timestamp when the object was last updated.
+   * @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.
    */
-  updated_at?: string | null;
+  use_assistant_message?: boolean;
 }
 
-export namespace Message {
-  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';
-  }
-
-  export interface LettaSchemasMessageToolReturn {
-    /**
-     * 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 namespace LettaStreamingRequest {
   /**
    * The style of reasoning content returned by the OpenAI Responses API
    */
@@ -899,55 +1079,114 @@ export namespace Message {
       text: string;
     }
   }
+}
 
-  export interface ToolCall {
-    id: string;
-
-    function: ToolCall.Function;
-
-    type: 'function';
+/**
+ * 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;
 
-    [k: string]: unknown;
+export namespace LettaStreamingResponse {
+  /**
+   * Ping messages are a keep-alive to prevent SSE streams from timing out during
+   * long running requests.
+   */
+  export interface LettaPing {
+    /**
+     * The type of the message.
+     */
+    message_type: 'ping';
   }
 
-  export namespace ToolCall {
-    export interface Function {
-      arguments: string;
-
-      name: string;
+  /**
+   * The stop reason from Letta indicating why agent loop stopped execution.
+   */
+  export interface LettaStopReason {
+    /**
+     * The reason why execution stopped.
+     */
+    stop_reason: RunsAPI.StopReasonType;
 
-      [k: string]: unknown;
-    }
+    /**
+     * The type of the message.
+     */
+    message_type?: 'stop_reason';
   }
 
-  export interface ToolReturn {
+  /**
+   * 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.
+   */
+  export interface LettaUsageStatistics {
     /**
-     * The status of the tool call
+     * The number of tokens generated by the agent.
      */
-    status: 'success' | 'error';
+    completion_tokens?: number;
+
+    message_type?: 'usage_statistics';
 
     /**
-     * The function response string
+     * The number of tokens in the prompt.
      */
-    func_response?: string | null;
+    prompt_tokens?: number;
 
     /**
-     * Captured stderr from the tool invocation
+     * The background task run IDs associated with the agent interaction
      */
-    stderr?: Array<string> | null;
+    run_ids?: Array<string> | null;
 
     /**
-     * Captured stdout (e.g. prints, logs) from the tool invocation
+     * The number of steps taken by the agent.
      */
-    stdout?: Array<string> | null;
+    step_count?: number;
 
     /**
-     * The ID for the tool call
+     * The total number of tokens processed by the agent.
      */
-    tool_call_id?: unknown;
+    total_tokens?: number;
   }
 }
 
+export type LettaUserMessageContentUnion = TextContent | ImageContent;
+
+/**
+ * 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';
 
 export type MessageType =
@@ -1063,27 +1302,17 @@ export interface RedactedReasoningContent {
  * 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.
- *
- * Parameters: id (str): The unique identifier of the run (prefixed with 'run-').
- * status (JobStatus): The current status of the run. created_at (datetime): The
- * timestamp when the run was created. completed_at (datetime): The timestamp when
- * the run was completed. agent_id (str): The unique identifier of the agent
- * associated with the run. base_template_id (str): The base template ID that the
- * run belongs to. stop_reason (StopReasonType): The reason why the run was
- * stopped. background (bool): Whether the run was created in background mode.
- * metadata (dict): Additional metadata for the run. request_config
- * (LettaRequestConfig): The request configuration for the run.
  */
 export interface Run {
   /**
-   * The unique identifier of the agent associated with the run.
+   * The human-friendly ID of the Run
    */
-  agent_id: string;
+  id: string;
 
   /**
-   * The human-friendly ID of the Run
+   * The unique identifier of the agent associated with the run.
    */
-  id?: string;
+  agent_id: string;
 
   /**
    * Whether the run was created in background mode.
@@ -1185,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.
@@ -1422,248 +1679,210 @@ export interface UserMessage {
 
   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 MessageStreamResponse = unknown;
-
-export type MessageUpdateParams =
-  | MessageUpdateParams.UpdateSystemMessage
-  | MessageUpdateParams.UpdateUserMessage
-  | MessageUpdateParams.UpdateReasoningMessage
-  | MessageUpdateParams.UpdateAssistantMessage;
-
-export declare namespace MessageUpdateParams {
-  export interface UpdateSystemMessage {
-    /**
-     * Path param: The ID of the agent in the format 'agent-<uuid4>'
-     */
-    agent_id: string;
-
-    /**
-     * Body param: The message content sent by the system (can be a string or an array
-     * of multi-modal content parts)
-     */
-    content: string;
+  /**
+   * The type of the message.
+   */
+  message_type?: 'user_message';
 
-    /**
-     * Body param:
-     */
-    message_type?: 'system_message';
-  }
+  name?: string | null;
 
-  export interface UpdateUserMessage {
-    /**
-     * Path param: The ID of the agent in the format 'agent-<uuid4>'
-     */
-    agent_id: string;
+  otid?: string | null;
 
-    /**
-     * 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;
+  run_id?: string | null;
 
-    /**
-     * Body param:
-     */
-    message_type?: 'user_message';
-  }
+  sender_id?: string | null;
 
-  export interface UpdateReasoningMessage {
-    /**
-     * Path param: The ID of the agent in the format 'agent-<uuid4>'
-     */
-    agent_id: string;
+  seq_id?: number | null;
 
-    /**
-     * Body param:
-     */
-    reasoning: string;
+  step_id?: string | null;
+}
 
-    /**
-     * Body param:
-     */
-    message_type?: 'reasoning_message';
-  }
+export type MessageCancelResponse = { [key: string]: unknown };
 
-  export interface UpdateAssistantMessage {
-    /**
-     * Path param: The ID of the agent in the format 'agent-<uuid4>'
-     */
-    agent_id: string;
+export type MessageCreateParams = MessageCreateParamsNonStreaming | MessageCreateParamsStreaming;
 
-    /**
-     * Body param: The message content sent by the assistant (can be a string or an
-     * array of content parts)
-     */
-    content: Array<LettaAssistantMessageContentUnion> | string;
+export interface MessageCreateParamsBase {
+  /**
+   * @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;
 
-    /**
-     * Body param:
-     */
-    message_type?: 'assistant_message';
-  }
-}
+  /**
+   * @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;
 
-export interface MessageListParams {
   /**
-   * Message ID cursor for pagination. Returns messages that come after this message
-   * ID in the specified sort order
+   * Whether to process the request in the background (only used when
+   * streaming=true).
    */
-  after?: string | null;
+  background?: boolean;
 
   /**
-   * @deprecated The name of the message argument.
+   * @deprecated If set to True, enables reasoning before responses or tool calls
+   * from the agent.
    */
-  assistant_message_tool_kwarg?: string;
+  enable_thinking?: string;
 
   /**
-   * @deprecated The name of the designated message tool.
+   * Whether to include periodic keepalive ping messages in the stream to prevent
+   * connection timeouts (only used when streaming=true).
    */
-  assistant_message_tool_name?: string;
+  include_pings?: boolean;
 
   /**
-   * Message ID cursor for pagination. Returns messages that come before this message
-   * ID in the specified sort order
+   * Only return specified message types in the response. If `None` (default) returns
+   * all messages.
    */
-  before?: string | null;
+  include_return_message_types?: Array<MessageType> | null;
 
   /**
-   * Group ID to filter messages by.
+   * Syntactic sugar for a single user message. Equivalent to messages=[{'role':
+   * 'user', 'content': input}].
    */
-  group_id?: string | null;
+  input?:
+    | string
+    | Array<
+        | TextContent
+        | ImageContent
+        | ToolCallContent
+        | ToolReturnContent
+        | ReasoningContent
+        | RedactedReasoningContent
+        | OmittedReasoningContent
+        | MessageCreateParams.SummarizedReasoningContent
+      >
+    | null;
 
   /**
-   * Whether to include error messages and error statuses. For debugging purposes
-   * only.
+   * Maximum number of steps the agent should take to process the request.
    */
-  include_err?: boolean | null;
+  max_steps?: number;
 
   /**
-   * Maximum number of messages to return
+   * The messages to be sent to the agent.
    */
-  limit?: number | null;
+  messages?: Array<AgentsAPI.MessageCreate | ApprovalCreate> | null;
 
   /**
-   * Sort order for messages by creation time. 'asc' for oldest first, 'desc' for
-   * newest first
+   * Flag to determine if individual tokens should be streamed, rather than streaming
+   * per step (only used when streaming=true).
    */
-  order?: 'asc' | 'desc';
+  stream_tokens?: boolean;
 
   /**
-   * Field to sort by
+   * If True, returns a streaming response (Server-Sent Events). If False (default),
+   * returns a complete response.
    */
-  order_by?: 'created_at';
+  streaming?: boolean;
 
   /**
-   * @deprecated Whether to use assistant messages
+   * @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 interface MessageCancelParams {
+export namespace MessageCreateParams {
   /**
-   * Optional list of run IDs to cancel
+   * The style of reasoning content returned by the OpenAI Responses API
    */
-  run_ids?: Array<string> | null;
+  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 type MessageCreateParamsNonStreaming = MessagesAPI.MessageCreateParamsNonStreaming;
+  export type MessageCreateParamsStreaming = MessagesAPI.MessageCreateParamsStreaming;
 }
 
-export interface MessageResetParams {
+export interface MessageCreateParamsNonStreaming extends MessageCreateParamsBase {
   /**
-   * If true, adds the default initial messages after resetting.
+   * If True, returns a streaming response (Server-Sent Events). If False (default),
+   * returns a complete response.
    */
-  add_default_initial_messages?: boolean;
+  streaming?: false;
 }
 
-export interface MessageSendParams {
+export interface MessageCreateParamsStreaming extends MessageCreateParamsBase {
   /**
-   * The messages to be sent to the agent.
+   * If True, returns a streaming response (Server-Sent Events). If False (default),
+   * returns a complete response.
    */
-  messages: Array<AgentsAPI.MessageCreate | ApprovalCreate>;
+  streaming: true;
+}
 
+export interface MessageListParams extends ArrayPageParams {
   /**
-   * @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.
+   * @deprecated The name of the message argument.
    */
   assistant_message_tool_kwarg?: string;
 
   /**
-   * @deprecated The name of the designated message tool. Still supported for legacy
-   * agent types, but deprecated for letta_v1_agent onward.
+   * @deprecated The name of the designated message tool.
    */
   assistant_message_tool_name?: string;
 
   /**
-   * @deprecated If set to True, enables reasoning before responses or tool calls
-   * from the agent.
-   */
-  enable_thinking?: string;
-
-  /**
-   * Only return specified message types in the response. If `None` (default) returns
-   * all messages.
+   * Group ID to filter messages by.
    */
-  include_return_message_types?: Array<MessageType> | null;
+  group_id?: string | null;
 
   /**
-   * Maximum number of steps the agent should take to process the request.
+   * Whether to include error messages and error statuses. For debugging purposes
+   * only.
    */
-  max_steps?: number;
+  include_err?: boolean | null;
 
   /**
-   * @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.
+   * @deprecated Whether to use assistant messages
    */
   use_assistant_message?: boolean;
 }
 
-export interface MessageSendAsyncParams {
+export interface MessageCancelParams {
   /**
-   * The messages to be sent to the agent.
+   * Optional list of run IDs to cancel
    */
-  messages: Array<AgentsAPI.MessageCreate | ApprovalCreate>;
+  run_ids?: Array<string> | null;
+}
 
+export interface MessageCreateAsyncParams {
   /**
    * @deprecated The name of the message argument in the designated message tool.
    * Still supported for legacy agent types, but deprecated for letta_v1_agent
@@ -1694,11 +1913,34 @@ export interface MessageSendAsyncParams {
    */
   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
+        | MessageCreateAsyncParams.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;
+
   /**
    * @deprecated Whether the server should parse specific tool call arguments
    * (default `send_message`) as `AssistantMessage` objects. Still supported for
@@ -1707,12 +1949,55 @@ export interface MessageSendAsyncParams {
   use_assistant_message?: boolean;
 }
 
-export interface MessageStreamParams {
+export namespace MessageCreateAsyncParams {
   /**
-   * The messages to be sent to the agent.
+   * 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 MessageResetParams {
+  /**
+   * If true, adds the default initial messages after resetting.
    */
-  messages: Array<AgentsAPI.MessageCreate | ApprovalCreate>;
+  add_default_initial_messages?: boolean;
+}
 
+export interface MessageStreamParams {
   /**
    * @deprecated The name of the message argument in the designated message tool.
    * Still supported for legacy agent types, but deprecated for letta_v1_agent
@@ -1727,7 +2012,8 @@ export interface MessageStreamParams {
   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;
 
@@ -1739,7 +2025,7 @@ export interface MessageStreamParams {
 
   /**
    * Whether to include periodic keepalive ping messages in the stream to prevent
-   * connection timeouts.
+   * connection timeouts (only used when streaming=true).
    */
   include_pings?: boolean;
 
@@ -1749,17 +2035,46 @@ export interface MessageStreamParams {
    */
   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;
 
+  /**
+   * 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
@@ -1768,21 +2083,65 @@ export interface MessageStreamParams {
   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,
@@ -1792,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,
@@ -1805,16 +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 MessageStreamResponse as MessageStreamResponse,
-    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 MessageCreateAsyncParams as MessageCreateAsyncParams,
     type MessageResetParams as MessageResetParams,
-    type MessageSendParams as MessageSendParams,
-    type MessageSendAsyncParams as MessageSendAsyncParams,
     type MessageStreamParams as MessageStreamParams,
   };
 }