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

package/src/client.ts

@@ -14,41 +14,48 @@ import * as Opts from './internal/request-options';
 import * as qs from './internal/qs';
 import { VERSION } from './version';
 import * as Errors from './core/error';
+import * as Pagination from './core/pagination';
+import {
+  AbstractPage,
+  type ArrayPageParams,
+  ArrayPageResponse,
+  type NextFilesPageParams,
+  NextFilesPageResponse,
+  type ObjectPageParams,
+  ObjectPageResponse,
+} from './core/pagination';
 import * as Uploads from './core/uploads';
 import * as API from './resources/index';
 import * as TopLevelAPI from './resources/top-level';
 import { HealthResponse } from './resources/top-level';
 import { APIPromise } from './core/api-promise';
 import {
-  Archive,
-  ArchiveCreateParams,
-  ArchiveListParams,
-  ArchiveListResponse,
-  ArchiveUpdateParams,
-  Archives,
-  VectorDBProvider,
-} from './resources/archives';
+  AccessTokenCreateParams,
+  AccessTokenCreateResponse,
+  AccessTokenDeleteParams,
+  AccessTokenDeleteResponse,
+  AccessTokenListParams,
+  AccessTokenListResponse,
+  AccessTokens,
+} from './resources/access-tokens';
 import { TagListParams, TagListResponse, Tags } from './resources/tags';
 import {
   NpmRequirement,
   PipRequirement,
   Tool,
-  ToolCountParams,
-  ToolCountResponse,
   ToolCreate,
   ToolCreateParams,
   ToolDeleteResponse,
   ToolListParams,
-  ToolListResponse,
   ToolReturnMessage,
   ToolType,
   ToolUpdateParams,
   ToolUpsertBaseToolsResponse,
   ToolUpsertParams,
   Tools,
+  ToolsArrayPage,
 } from './resources/tools';
 import {
-  AgentCountResponse,
   AgentCreateParams,
   AgentDeleteResponse,
   AgentEnvironmentVariable,
@@ -57,65 +64,82 @@ import {
   AgentImportFileParams,
   AgentImportFileResponse,
   AgentListParams,
-  AgentListResponse,
   AgentRetrieveParams,
   AgentState,
+  AgentStatesArrayPage,
   AgentType,
   AgentUpdateParams,
   Agents,
+  AnthropicModelSettings,
+  AzureModelSettings,
+  BedrockModelSettings,
   ChildToolRule,
   ConditionalToolRule,
   ContinueToolRule,
+  DeepseekModelSettings,
+  GoogleAIModelSettings,
+  GoogleVertexModelSettings,
+  GroqModelSettings,
   InitToolRule,
   JsonObjectResponseFormat,
   JsonSchemaResponseFormat,
   LettaMessageContentUnion,
   MaxCountPerStepToolRule,
   MessageCreate,
+  OpenAIModelSettings,
   ParentToolRule,
   RequiredBeforeExitToolRule,
   RequiresApprovalToolRule,
   TerminalToolRule,
   TextResponseFormat,
+  TogetherModelSettings,
+  XaiModelSettings,
 } from './resources/agents/agents';
+import {
+  Archive,
+  ArchiveCreateParams,
+  ArchiveListParams,
+  ArchiveUpdateParams,
+  Archives,
+  ArchivesArrayPage,
+  VectorDBProvider,
+} from './resources/archives/archives';
 import {
   BatchCancelResponse,
   BatchCreateParams,
   BatchJob,
+  BatchJobsArrayPage,
   BatchListParams,
-  BatchListResponse,
   Batches,
 } from './resources/batches/batches';
 import {
-  BlockCountResponse,
   BlockCreateParams,
   BlockDeleteResponse,
   BlockListParams,
-  BlockListResponse,
+  BlockResponse,
+  BlockResponsesArrayPage,
   BlockUpdateParams,
   Blocks,
   CreateBlock,
 } from './resources/blocks/blocks';
 import {
   Folder,
-  FolderCountResponse,
   FolderCreateParams,
   FolderDeleteResponse,
   FolderListParams,
-  FolderListResponse,
   FolderUpdateParams,
   Folders,
+  FoldersArrayPage,
 } from './resources/folders/folders';
 import {
   DynamicManager,
   Group,
-  GroupCountResponse,
   GroupCreateParams,
   GroupDeleteResponse,
   GroupListParams,
-  GroupListResponse,
   GroupUpdateParams,
   Groups,
+  GroupsArrayPage,
   ManagerType,
   RoundRobinManager,
   SleeptimeManager,
@@ -124,28 +148,51 @@ import {
 } from './resources/groups/groups';
 import {
   Identities,
+  IdentitiesArrayPage,
   Identity,
-  IdentityCountResponse,
   IdentityCreateParams,
   IdentityDeleteResponse,
   IdentityListParams,
-  IdentityListResponse,
   IdentityProperty,
   IdentityType,
   IdentityUpdateParams,
   IdentityUpsertParams,
 } from './resources/identities/identities';
+import {
+  CreateSseMcpServer,
+  CreateStdioMcpServer,
+  CreateStreamableHTTPMcpServer,
+  McpServerCreateParams,
+  McpServerCreateResponse,
+  McpServerListResponse,
+  McpServerRefreshParams,
+  McpServerRefreshResponse,
+  McpServerRetrieveResponse,
+  McpServerUpdateParams,
+  McpServerUpdateResponse,
+  McpServers,
+  McpToolExecuteRequest,
+  SseMcpServer,
+  StdioMcpServer,
+  StreamableHTTPMcpServer,
+  ToolExecutionResult,
+  UpdateSseMcpServer,
+  UpdateStdioMcpServer,
+  UpdateStreamableHTTPMcpServer,
+} from './resources/mcp-servers/mcp-servers';
 import {
   EmbeddingConfig,
+  EmbeddingModel,
   LlmConfig,
+  Model,
   ModelListParams,
   ModelListResponse,
   Models,
   ProviderCategory,
   ProviderType,
 } from './resources/models/models';
-import { Job, RunListParams, RunListResponse, Runs, StopReasonType } from './resources/runs/runs';
-import { ProviderTrace, Step, StepListParams, StepListResponse, Steps } from './resources/steps/steps';
+import { Job, RunListParams, Runs, StopReasonType } from './resources/runs/runs';
+import { ProviderTrace, Step, StepListParams, Steps, StepsArrayPage } from './resources/steps/steps';
 import { Templates } from './resources/templates/templates';
 import { type Fetch } from './internal/builtin-types';
 import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
@@ -161,7 +208,7 @@ import {
 import { isEmptyObj } from './internal/utils/values';
 
 const environments = {
-  cloud: 'https://app.letta.com',
+  cloud: 'https://api.letta.com',
   local: 'http://localhost:8283',
 };
 type Environment = keyof typeof environments;
@@ -170,13 +217,20 @@ export interface ClientOptions {
   /**
    * Defaults to process.env['LETTA_API_KEY'].
    */
-  apiKey?: string | undefined;
+  apiKey?: string | null | undefined;
+
+  projectID?: string | null | undefined;
+
+  /**
+   * Deprecated, please use project_id instead.
+   */
+  project?: string | null | undefined;
 
   /**
    * Specifies the environment to use for the API.
    *
    * Each environment maps to a different base URL:
-   * - `cloud` corresponds to `https://app.letta.com`
+   * - `cloud` corresponds to `https://api.letta.com`
    * - `local` corresponds to `http://localhost:8283`
    */
   environment?: Environment | undefined;
@@ -254,7 +308,9 @@ export interface ClientOptions {
  * API Client for interfacing with the Letta API.
  */
 export class Letta {
-  apiKey: string;
+  apiKey: string | null;
+  projectID: string | null;
+  project: string | null;
 
   baseURL: string;
   maxRetries: number;
@@ -271,9 +327,11 @@ export class Letta {
   /**
    * API Client for interfacing with the Letta API.
    *
-   * @param {string | undefined} [opts.apiKey=process.env['LETTA_API_KEY'] ?? undefined]
+   * @param {string | null | undefined} [opts.apiKey=process.env['LETTA_API_KEY'] ?? null]
+   * @param {string | null | undefined} [opts.projectID]
+   * @param {string | null | undefined} [opts.project]
    * @param {Environment} [opts.environment=cloud] - Specifies the environment URL to use for the API.
-   * @param {string} [opts.baseURL=process.env['LETTA_BASE_URL'] ?? https://app.letta.com] - Override the default base URL for the API.
+   * @param {string} [opts.baseURL=process.env['LETTA_BASE_URL'] ?? https://api.letta.com] - Override the default base URL for the API.
    * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
    * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
    * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
@@ -283,17 +341,15 @@ export class Letta {
    */
   constructor({
     baseURL = readEnv('LETTA_BASE_URL'),
-    apiKey = readEnv('LETTA_API_KEY'),
+    apiKey = readEnv('LETTA_API_KEY') ?? null,
+    projectID = null,
+    project = null,
     ...opts
   }: ClientOptions = {}) {
-    if (apiKey === undefined) {
-      throw new Errors.LettaError(
-        "The LETTA_API_KEY environment variable is missing or empty; either provide it, or instantiate the Letta client with an apiKey option, like new Letta({ apiKey: 'My API Key' }).",
-      );
-    }
-
     const options: ClientOptions = {
       apiKey,
+      projectID,
+      project,
       ...opts,
       baseURL,
       environment: opts.environment ?? 'cloud',
@@ -323,6 +379,8 @@ export class Letta {
     this._options = options;
 
     this.apiKey = apiKey;
+    this.projectID = projectID;
+    this.project = project;
   }
 
   /**
@@ -340,6 +398,8 @@ export class Letta {
       fetch: this.fetch,
       fetchOptions: this.fetchOptions,
       apiKey: this.apiKey,
+      projectID: this.projectID,
+      project: this.project,
       ...options,
     });
     return client;
@@ -353,7 +413,7 @@ export class Letta {
   }
 
   /**
-   * Check Health
+   * Async health check endpoint.
    */
   health(options?: RequestOptions): APIPromise<TopLevelAPI.HealthResponse> {
     return this.get('/v1/health/', options);
@@ -364,15 +424,27 @@ export class Letta {
   }
 
   protected validateHeaders({ values, nulls }: NullableHeaders) {
-    return;
+    if (this.apiKey && values.get('authorization')) {
+      return;
+    }
+    if (nulls.has('authorization')) {
+      return;
+    }
+
+    throw new Error(
+      'Could not resolve authentication method. Expected the apiKey to be set. Or for the "Authorization" headers to be explicitly omitted',
+    );
   }
 
   protected async authHeaders(opts: FinalRequestOptions): Promise<NullableHeaders | undefined> {
+    if (this.apiKey == null) {
+      return undefined;
+    }
     return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
   }
 
   protected stringifyQuery(query: Record<string, unknown>): string {
-    return qs.stringify(query, { arrayFormat: 'comma' });
+    return qs.stringify(query, { allowDots: true, arrayFormat: 'repeat' });
   }
 
   private getUserAgent(): string {
@@ -627,6 +699,25 @@ export class Letta {
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
   }
 
+  getAPIList<Item, PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>>(
+    path: string,
+    Page: new (...args: any[]) => PageClass,
+    opts?: RequestOptions,
+  ): Pagination.PagePromise<PageClass, Item> {
+    return this.requestAPIList(Page, { method: 'get', path, ...opts });
+  }
+
+  requestAPIList<
+    Item = unknown,
+    PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>,
+  >(
+    Page: new (...args: ConstructorParameters<typeof Pagination.AbstractPage>) => PageClass,
+    options: FinalRequestOptions,
+  ): Pagination.PagePromise<PageClass, Item> {
+    const request = this.makeRequest(options, null, undefined);
+    return new Pagination.PagePromise<PageClass, Item>(this as any as Letta, request, Page);
+  }
+
   async fetchWithTimeout(
     url: RequestInfo,
     init: RequestInit | undefined,
@@ -791,6 +882,8 @@ export class Letta {
         'X-Stainless-Retry-Count': String(retryCount),
         ...(options.timeout ? { 'X-Stainless-Timeout': String(Math.trunc(options.timeout / 1000)) } : {}),
         ...getPlatformHeaders(),
+        'X-Project-Id': this.projectID,
+        'X-Project': this.project,
       },
       await this.authHeaders(options),
       this._options.defaultHeaders,
@@ -859,104 +952,89 @@ export class Letta {
 
   static toFile = Uploads.toFile;
 
-  archives: API.Archives = new API.Archives(this);
+  agents: API.Agents = new API.Agents(this);
   tools: API.Tools = new API.Tools(this);
+  blocks: API.Blocks = new API.Blocks(this);
+  archives: API.Archives = new API.Archives(this);
   folders: API.Folders = new API.Folders(this);
-  agents: API.Agents = new API.Agents(this);
-  groups: API.Groups = new API.Groups(this);
-  identities: API.Identities = new API.Identities(this);
   models: API.Models = new API.Models(this);
-  blocks: API.Blocks = new API.Blocks(this);
+  mcpServers: API.McpServers = new API.McpServers(this);
   runs: API.Runs = new API.Runs(this);
   steps: API.Steps = new API.Steps(this);
+  templates: API.Templates = new API.Templates(this);
   tags: API.Tags = new API.Tags(this);
+  identities: API.Identities = new API.Identities(this);
+  groups: API.Groups = new API.Groups(this);
   batches: API.Batches = new API.Batches(this);
-  templates: API.Templates = new API.Templates(this);
+  accessTokens: API.AccessTokens = new API.AccessTokens(this);
 }
 
-Letta.Archives = Archives;
+Letta.Agents = Agents;
 Letta.Tools = Tools;
+Letta.Blocks = Blocks;
+Letta.Archives = Archives;
 Letta.Folders = Folders;
-Letta.Agents = Agents;
-Letta.Groups = Groups;
-Letta.Identities = Identities;
 Letta.Models = Models;
-Letta.Blocks = Blocks;
+Letta.McpServers = McpServers;
 Letta.Runs = Runs;
 Letta.Steps = Steps;
+Letta.Templates = Templates;
 Letta.Tags = Tags;
+Letta.Identities = Identities;
+Letta.Groups = Groups;
 Letta.Batches = Batches;
-Letta.Templates = Templates;
+Letta.AccessTokens = AccessTokens;
 
 export declare namespace Letta {
   export type RequestOptions = Opts.RequestOptions;
 
-  export { type HealthResponse as HealthResponse };
+  export import ArrayPage = Pagination.ArrayPage;
+  export { type ArrayPageParams as ArrayPageParams, type ArrayPageResponse as ArrayPageResponse };
 
-  export {
-    Archives as Archives,
-    type Archive as Archive,
-    type VectorDBProvider as VectorDBProvider,
-    type ArchiveListResponse as ArchiveListResponse,
-    type ArchiveCreateParams as ArchiveCreateParams,
-    type ArchiveUpdateParams as ArchiveUpdateParams,
-    type ArchiveListParams as ArchiveListParams,
-  };
+  export import ObjectPage = Pagination.ObjectPage;
+  export { type ObjectPageParams as ObjectPageParams, type ObjectPageResponse as ObjectPageResponse };
 
+  export import NextFilesPage = Pagination.NextFilesPage;
   export {
-    Tools as Tools,
-    type NpmRequirement as NpmRequirement,
-    type PipRequirement as PipRequirement,
-    type Tool as Tool,
-    type ToolCreate as ToolCreate,
-    type ToolReturnMessage as ToolReturnMessage,
-    type ToolType as ToolType,
-    type ToolListResponse as ToolListResponse,
-    type ToolDeleteResponse as ToolDeleteResponse,
-    type ToolCountResponse as ToolCountResponse,
-    type ToolUpsertBaseToolsResponse as ToolUpsertBaseToolsResponse,
-    type ToolCreateParams as ToolCreateParams,
-    type ToolUpdateParams as ToolUpdateParams,
-    type ToolListParams as ToolListParams,
-    type ToolCountParams as ToolCountParams,
-    type ToolUpsertParams as ToolUpsertParams,
+    type NextFilesPageParams as NextFilesPageParams,
+    type NextFilesPageResponse as NextFilesPageResponse,
   };
 
-  export {
-    Folders as Folders,
-    type Folder as Folder,
-    type FolderListResponse as FolderListResponse,
-    type FolderDeleteResponse as FolderDeleteResponse,
-    type FolderCountResponse as FolderCountResponse,
-    type FolderCreateParams as FolderCreateParams,
-    type FolderUpdateParams as FolderUpdateParams,
-    type FolderListParams as FolderListParams,
-  };
+  export { type HealthResponse as HealthResponse };
 
   export {
     Agents as Agents,
     type AgentEnvironmentVariable as AgentEnvironmentVariable,
     type AgentState as AgentState,
     type AgentType as AgentType,
+    type AnthropicModelSettings as AnthropicModelSettings,
+    type AzureModelSettings as AzureModelSettings,
+    type BedrockModelSettings as BedrockModelSettings,
     type ChildToolRule as ChildToolRule,
     type ConditionalToolRule as ConditionalToolRule,
     type ContinueToolRule as ContinueToolRule,
+    type DeepseekModelSettings as DeepseekModelSettings,
+    type GoogleAIModelSettings as GoogleAIModelSettings,
+    type GoogleVertexModelSettings as GoogleVertexModelSettings,
+    type GroqModelSettings as GroqModelSettings,
     type InitToolRule as InitToolRule,
     type JsonObjectResponseFormat as JsonObjectResponseFormat,
     type JsonSchemaResponseFormat as JsonSchemaResponseFormat,
     type LettaMessageContentUnion as LettaMessageContentUnion,
     type MaxCountPerStepToolRule as MaxCountPerStepToolRule,
     type MessageCreate as MessageCreate,
+    type OpenAIModelSettings as OpenAIModelSettings,
     type ParentToolRule as ParentToolRule,
     type RequiredBeforeExitToolRule as RequiredBeforeExitToolRule,
     type RequiresApprovalToolRule as RequiresApprovalToolRule,
     type TerminalToolRule as TerminalToolRule,
     type TextResponseFormat as TextResponseFormat,
-    type AgentListResponse as AgentListResponse,
+    type TogetherModelSettings as TogetherModelSettings,
+    type XaiModelSettings as XaiModelSettings,
     type AgentDeleteResponse as AgentDeleteResponse,
-    type AgentCountResponse as AgentCountResponse,
     type AgentExportFileResponse as AgentExportFileResponse,
     type AgentImportFileResponse as AgentImportFileResponse,
+    type AgentStatesArrayPage as AgentStatesArrayPage,
     type AgentCreateParams as AgentCreateParams,
     type AgentRetrieveParams as AgentRetrieveParams,
     type AgentUpdateParams as AgentUpdateParams,
@@ -966,40 +1044,59 @@ export declare namespace Letta {
   };
 
   export {
-    Groups as Groups,
-    type DynamicManager as DynamicManager,
-    type Group as Group,
-    type ManagerType as ManagerType,
-    type RoundRobinManager as RoundRobinManager,
-    type SleeptimeManager as SleeptimeManager,
-    type SupervisorManager as SupervisorManager,
-    type VoiceSleeptimeManager as VoiceSleeptimeManager,
-    type GroupListResponse as GroupListResponse,
-    type GroupDeleteResponse as GroupDeleteResponse,
-    type GroupCountResponse as GroupCountResponse,
-    type GroupCreateParams as GroupCreateParams,
-    type GroupUpdateParams as GroupUpdateParams,
-    type GroupListParams as GroupListParams,
+    Tools as Tools,
+    type NpmRequirement as NpmRequirement,
+    type PipRequirement as PipRequirement,
+    type Tool as Tool,
+    type ToolCreate as ToolCreate,
+    type ToolReturnMessage as ToolReturnMessage,
+    type ToolType as ToolType,
+    type ToolDeleteResponse as ToolDeleteResponse,
+    type ToolUpsertBaseToolsResponse as ToolUpsertBaseToolsResponse,
+    type ToolsArrayPage as ToolsArrayPage,
+    type ToolCreateParams as ToolCreateParams,
+    type ToolUpdateParams as ToolUpdateParams,
+    type ToolListParams as ToolListParams,
+    type ToolUpsertParams as ToolUpsertParams,
   };
 
   export {
-    Identities as Identities,
-    type Identity as Identity,
-    type IdentityProperty as IdentityProperty,
-    type IdentityType as IdentityType,
-    type IdentityListResponse as IdentityListResponse,
-    type IdentityDeleteResponse as IdentityDeleteResponse,
-    type IdentityCountResponse as IdentityCountResponse,
-    type IdentityCreateParams as IdentityCreateParams,
-    type IdentityUpdateParams as IdentityUpdateParams,
-    type IdentityListParams as IdentityListParams,
-    type IdentityUpsertParams as IdentityUpsertParams,
+    Blocks as Blocks,
+    type BlockResponse as BlockResponse,
+    type CreateBlock as CreateBlock,
+    type BlockDeleteResponse as BlockDeleteResponse,
+    type BlockResponsesArrayPage as BlockResponsesArrayPage,
+    type BlockCreateParams as BlockCreateParams,
+    type BlockUpdateParams as BlockUpdateParams,
+    type BlockListParams as BlockListParams,
+  };
+
+  export {
+    Archives as Archives,
+    type Archive as Archive,
+    type VectorDBProvider as VectorDBProvider,
+    type ArchivesArrayPage as ArchivesArrayPage,
+    type ArchiveCreateParams as ArchiveCreateParams,
+    type ArchiveUpdateParams as ArchiveUpdateParams,
+    type ArchiveListParams as ArchiveListParams,
+  };
+
+  export {
+    Folders as Folders,
+    type Folder as Folder,
+    type FolderDeleteResponse as FolderDeleteResponse,
+    type FoldersArrayPage as FoldersArrayPage,
+    type FolderCreateParams as FolderCreateParams,
+    type FolderUpdateParams as FolderUpdateParams,
+    type FolderListParams as FolderListParams,
   };
 
   export {
     Models as Models,
     type EmbeddingConfig as EmbeddingConfig,
+    type EmbeddingModel as EmbeddingModel,
     type LlmConfig as LlmConfig,
+    type Model as Model,
     type ProviderCategory as ProviderCategory,
     type ProviderType as ProviderType,
     type ModelListResponse as ModelListResponse,
@@ -1007,21 +1104,32 @@ export declare namespace Letta {
   };
 
   export {
-    Blocks as Blocks,
-    type CreateBlock as CreateBlock,
-    type BlockListResponse as BlockListResponse,
-    type BlockDeleteResponse as BlockDeleteResponse,
-    type BlockCountResponse as BlockCountResponse,
-    type BlockCreateParams as BlockCreateParams,
-    type BlockUpdateParams as BlockUpdateParams,
-    type BlockListParams as BlockListParams,
+    McpServers as McpServers,
+    type CreateSseMcpServer as CreateSseMcpServer,
+    type CreateStdioMcpServer as CreateStdioMcpServer,
+    type CreateStreamableHTTPMcpServer as CreateStreamableHTTPMcpServer,
+    type McpToolExecuteRequest as McpToolExecuteRequest,
+    type SseMcpServer as SseMcpServer,
+    type StdioMcpServer as StdioMcpServer,
+    type StreamableHTTPMcpServer as StreamableHTTPMcpServer,
+    type ToolExecutionResult as ToolExecutionResult,
+    type UpdateSseMcpServer as UpdateSseMcpServer,
+    type UpdateStdioMcpServer as UpdateStdioMcpServer,
+    type UpdateStreamableHTTPMcpServer as UpdateStreamableHTTPMcpServer,
+    type McpServerCreateResponse as McpServerCreateResponse,
+    type McpServerRetrieveResponse as McpServerRetrieveResponse,
+    type McpServerUpdateResponse as McpServerUpdateResponse,
+    type McpServerListResponse as McpServerListResponse,
+    type McpServerRefreshResponse as McpServerRefreshResponse,
+    type McpServerCreateParams as McpServerCreateParams,
+    type McpServerUpdateParams as McpServerUpdateParams,
+    type McpServerRefreshParams as McpServerRefreshParams,
   };
 
   export {
     Runs as Runs,
     type Job as Job,
     type StopReasonType as StopReasonType,
-    type RunListResponse as RunListResponse,
     type RunListParams as RunListParams,
   };
 
@@ -1029,20 +1137,59 @@ export declare namespace Letta {
     Steps as Steps,
     type ProviderTrace as ProviderTrace,
     type Step as Step,
-    type StepListResponse as StepListResponse,
+    type StepsArrayPage as StepsArrayPage,
     type StepListParams as StepListParams,
   };
 
+  export { Templates as Templates };
+
   export { Tags as Tags, type TagListResponse as TagListResponse, type TagListParams as TagListParams };
 
+  export {
+    Identities as Identities,
+    type Identity as Identity,
+    type IdentityProperty as IdentityProperty,
+    type IdentityType as IdentityType,
+    type IdentityDeleteResponse as IdentityDeleteResponse,
+    type IdentitiesArrayPage as IdentitiesArrayPage,
+    type IdentityCreateParams as IdentityCreateParams,
+    type IdentityUpdateParams as IdentityUpdateParams,
+    type IdentityListParams as IdentityListParams,
+    type IdentityUpsertParams as IdentityUpsertParams,
+  };
+
+  export {
+    Groups as Groups,
+    type DynamicManager as DynamicManager,
+    type Group as Group,
+    type ManagerType as ManagerType,
+    type RoundRobinManager as RoundRobinManager,
+    type SleeptimeManager as SleeptimeManager,
+    type SupervisorManager as SupervisorManager,
+    type VoiceSleeptimeManager as VoiceSleeptimeManager,
+    type GroupDeleteResponse as GroupDeleteResponse,
+    type GroupsArrayPage as GroupsArrayPage,
+    type GroupCreateParams as GroupCreateParams,
+    type GroupUpdateParams as GroupUpdateParams,
+    type GroupListParams as GroupListParams,
+  };
+
   export {
     Batches as Batches,
     type BatchJob as BatchJob,
-    type BatchListResponse as BatchListResponse,
     type BatchCancelResponse as BatchCancelResponse,
+    type BatchJobsArrayPage as BatchJobsArrayPage,
     type BatchCreateParams as BatchCreateParams,
     type BatchListParams as BatchListParams,
   };
 
-  export { Templates as Templates };
+  export {
+    AccessTokens as AccessTokens,
+    type AccessTokenCreateResponse as AccessTokenCreateResponse,
+    type AccessTokenListResponse as AccessTokenListResponse,
+    type AccessTokenDeleteResponse as AccessTokenDeleteResponse,
+    type AccessTokenCreateParams as AccessTokenCreateParams,
+    type AccessTokenListParams as AccessTokenListParams,
+    type AccessTokenDeleteParams as AccessTokenDeleteParams,
+  };
 }