@anthropic-ai/sdk 0.91.1 → 0.93.0

package/src/resources/beta/index.ts

@@ -177,6 +177,7 @@ export {
   type BetaInputJSONDelta,
   type BetaInputTokensClearAtLeast,
   type BetaInputTokensTrigger,
+  type BetaIterationsUsage,
   type BetaJSONOutputFormat,
   type BetaMCPToolConfig,
   type BetaMCPToolDefaultConfig,

package/src/resources/beta/memory-stores/memories.ts

@@ -10,7 +10,7 @@ import { path } from '../../../internal/utils/path';
 
 export class Memories extends APIResource {
   /**
-   * CreateMemory
+   * Create a memory
    *
    * @example
    * ```ts
@@ -39,7 +39,7 @@ export class Memories extends APIResource {
   }
 
   /**
-   * GetMemory
+   * Retrieve a memory
    *
    * @example
    * ```ts
@@ -67,7 +67,7 @@ export class Memories extends APIResource {
   }
 
   /**
-   * UpdateMemory
+   * Update a memory
    *
    * @example
    * ```ts
@@ -96,7 +96,7 @@ export class Memories extends APIResource {
   }
 
   /**
-   * ListMemories
+   * List memories
    *
    * @example
    * ```ts
@@ -129,7 +129,7 @@ export class Memories extends APIResource {
   }
 
   /**
-   * DeleteMemory
+   * Delete a memory
    *
    * @example
    * ```ts
@@ -165,13 +165,37 @@ export interface BetaManagedAgentsConflictError {
   message?: string;
 }
 
+/**
+ * Optimistic-concurrency precondition: the update applies only if the memory's
+ * stored `content_sha256` equals the supplied value. On mismatch, the request
+ * returns `memory_precondition_failed_error` (HTTP 409); re-read the memory and
+ * retry against the fresh state. If the precondition fails but the stored state
+ * already exactly matches the requested `content` and `path`, the server returns
+ * 200 instead of 409.
+ */
 export interface BetaManagedAgentsContentSha256Precondition {
   type: 'content_sha256';
 
+  /**
+   * Expected `content_sha256` of the stored memory (64 lowercase hexadecimal
+   * characters). Typically the `content_sha256` returned by a prior read or list
+   * call. Because the server applies no content normalization, clients can also
+   * compute this locally as the SHA-256 of the UTF-8 content bytes.
+   */
   content_sha256?: string;
 }
 
+/**
+ * Tombstone returned by
+ * [Delete a memory](/en/api/beta/memory_stores/memories/delete). The memory's
+ * version history persists and remains listable via
+ * [List memory versions](/en/api/beta/memory_stores/memory_versions/list) until
+ * the store itself is deleted.
+ */
 export interface BetaManagedAgentsDeletedMemory {
+  /**
+   * ID of the deleted memory (a `mem_...` value).
+   */
   id: string;
 
   type: 'memory_deleted';
@@ -191,11 +215,33 @@ export type BetaManagedAgentsError =
   | BetaManagedAgentsMemoryPathConflictError
   | BetaManagedAgentsConflictError;
 
+/**
+ * A `memory` object: a single text document at a hierarchical path inside a memory
+ * store. The `content` field is populated when `view=full` and `null` when
+ * `view=basic`; the `content_size_bytes` and `content_sha256` fields are always
+ * populated so sync clients can diff without fetching content. Memories are
+ * addressed by their `mem_...` ID; the path is the create key and can be changed
+ * via update.
+ */
 export interface BetaManagedAgentsMemory {
+  /**
+   * Unique identifier for this memory (a `mem_...` value). Stable across renames;
+   * use this ID, not the path, to read, update, or delete the memory.
+   */
   id: string;
 
+  /**
+   * Lowercase hex SHA-256 digest of the UTF-8 `content` bytes (64 characters). The
+   * server applies no normalization, so clients can compute the same hash locally
+   * for staleness checks and as the value for a `content_sha256` precondition on
+   * update. Always populated, regardless of `view`.
+   */
   content_sha256: string;
 
+  /**
+   * Size of `content` in bytes (the UTF-8 plaintext length). Always populated,
+   * regardless of `view`.
+   */
   content_size_bytes: number;
 
   /**
@@ -203,10 +249,25 @@ export interface BetaManagedAgentsMemory {
    */
   created_at: string;
 
+  /**
+   * ID of the memory store this memory belongs to (a `memstore_...` value).
+   */
   memory_store_id: string;
 
+  /**
+   * ID of the `memory_version` representing this memory's current content (a
+   * `memver_...` value). This is the authoritative head pointer; `memory_version`
+   * objects do not carry an `is_latest` flag, so compare against this field instead.
+   * Enumerate the full history via
+   * [List memory versions](/en/api/beta/memory_stores/memory_versions/list).
+   */
   memory_version_id: string;
 
+  /**
+   * Hierarchical path of the memory within the store, e.g. `/projects/foo/notes.md`.
+   * Always starts with `/`. Paths are case-sensitive and unique within a store.
+   * Maximum 1,024 bytes.
+   */
   path: string;
 
   type: 'memory';
@@ -216,9 +277,18 @@ export interface BetaManagedAgentsMemory {
    */
   updated_at: string;
 
+  /**
+   * The memory's UTF-8 text content. Populated when `view=full`; `null` when
+   * `view=basic`. Maximum 100 kB (102,400 bytes).
+   */
   content?: string | null;
 }
 
+/**
+ * One item in a [List memories](/en/api/beta/memory_stores/memories/list)
+ * response: either a `memory` object or, when `depth` is set, a `memory_prefix`
+ * rollup marker.
+ */
 export type BetaManagedAgentsMemoryListItem = BetaManagedAgentsMemory | BetaManagedAgentsMemoryPrefix;
 
 export interface BetaManagedAgentsMemoryPathConflictError {
@@ -237,31 +307,66 @@ export interface BetaManagedAgentsMemoryPreconditionFailedError {
   message?: string;
 }
 
+/**
+ * A rolled-up directory marker returned by
+ * [List memories](/en/api/beta/memory_stores/memories/list) when `depth` is set.
+ * Indicates that one or more memories exist deeper than the requested depth under
+ * this prefix. This is a list-time rollup, not a stored resource; it has no ID and
+ * no lifecycle. Each prefix counts toward the page `limit` and interleaves with
+ * `memory` items in path order.
+ */
 export interface BetaManagedAgentsMemoryPrefix {
+  /**
+   * The rolled-up path prefix, including a trailing `/` (e.g. `/projects/foo/`).
+   * Pass this value as `path_prefix` on a subsequent list call to drill into the
+   * directory.
+   */
   path: string;
 
   type: 'memory_prefix';
 }
 
 /**
- * MemoryView enum
+ * Selects which projection of a `memory` or `memory_version` the server returns.
+ * `basic` returns the object with `content` set to `null`; `full` populates
+ * `content`. When omitted, the default is endpoint-specific: retrieve operations
+ * default to `full`; list, create, and update operations default to `basic`.
+ * Listing with `view=full` caps `limit` at 20.
  */
 export type BetaManagedAgentsMemoryView = 'basic' | 'full';
 
+/**
+ * Optimistic-concurrency precondition: the update applies only if the memory's
+ * stored `content_sha256` equals the supplied value. On mismatch, the request
+ * returns `memory_precondition_failed_error` (HTTP 409); re-read the memory and
+ * retry against the fresh state. If the precondition fails but the stored state
+ * already exactly matches the requested `content` and `path`, the server returns
+ * 200 instead of 409.
+ */
 export interface BetaManagedAgentsPrecondition {
   type: 'content_sha256';
 
+  /**
+   * Expected `content_sha256` of the stored memory (64 lowercase hexadecimal
+   * characters). Typically the `content_sha256` returned by a prior read or list
+   * call. Because the server applies no content normalization, clients can also
+   * compute this locally as the SHA-256 of the UTF-8 content bytes.
+   */
   content_sha256?: string;
 }
 
 export interface MemoryCreateParams {
   /**
-   * Body param
+   * Body param: UTF-8 text content for the new memory. Maximum 100 kB (102,400
+   * bytes). Required; pass `""` explicitly to create an empty memory.
    */
   content: string | null;
 
   /**
-   * Body param
+   * Body param: Hierarchical path for the new memory, e.g. `/projects/foo/notes.md`.
+   * Must start with `/`, contain at least one non-empty segment, and be at most
+   * 1,024 bytes. Must not contain empty segments, `.` or `..` segments, control or
+   * format characters, and must be NFC-normalized. Paths are case-sensitive.
    */
   path: string;
 
@@ -305,17 +410,27 @@ export interface MemoryUpdateParams {
   view?: BetaManagedAgentsMemoryView;
 
   /**
-   * Body param
+   * Body param: New UTF-8 text content for the memory. Maximum 100 kB (102,400
+   * bytes). Omit to leave the content unchanged (e.g., for a rename-only update).
    */
   content?: string | null;
 
   /**
-   * Body param
+   * Body param: New path for the memory (a rename). Must start with `/`, contain at
+   * least one non-empty segment, and be at most 1,024 bytes. Must not contain empty
+   * segments, `.` or `..` segments, control or format characters, and must be
+   * NFC-normalized. Paths are case-sensitive. The memory's `id` is preserved across
+   * renames. Omit to leave the path unchanged.
    */
   path?: string | null;
 
   /**
-   * Body param
+   * Body param: Optimistic-concurrency precondition: the update applies only if the
+   * memory's stored `content_sha256` equals the supplied value. On mismatch, the
+   * request returns `memory_precondition_failed_error` (HTTP 409); re-read the
+   * memory and retry against the fresh state. If the precondition fails but the
+   * stored state already exactly matches the requested `content` and `path`, the
+   * server returns 200 instead of 409.
    */
   precondition?: BetaManagedAgentsPrecondition;
 

package/src/resources/beta/memory-stores/memory-stores.ts

@@ -48,7 +48,7 @@ export class MemoryStores extends APIResource {
   memoryVersions: MemoryVersionsAPI.MemoryVersions = new MemoryVersionsAPI.MemoryVersions(this._client);
 
   /**
-   * CreateMemoryStore
+   * Create a memory store
    *
    * @example
    * ```ts
@@ -72,7 +72,7 @@ export class MemoryStores extends APIResource {
   }
 
   /**
-   * GetMemoryStore
+   * Retrieve a memory store
    *
    * @example
    * ```ts
@@ -98,7 +98,7 @@ export class MemoryStores extends APIResource {
   }
 
   /**
-   * UpdateMemoryStore
+   * Update a memory store
    *
    * @example
    * ```ts
@@ -123,7 +123,7 @@ export class MemoryStores extends APIResource {
   }
 
   /**
-   * ListMemoryStores
+   * List memory stores
    *
    * @example
    * ```ts
@@ -149,7 +149,7 @@ export class MemoryStores extends APIResource {
   }
 
   /**
-   * DeleteMemoryStore
+   * Delete a memory store
    *
    * @example
    * ```ts
@@ -173,7 +173,7 @@ export class MemoryStores extends APIResource {
   }
 
   /**
-   * ArchiveMemoryStore
+   * Archive a memory store
    *
    * @example
    * ```ts
@@ -199,13 +199,30 @@ export class MemoryStores extends APIResource {
 
 export type BetaManagedAgentsMemoryStoresPageCursor = PageCursor<BetaManagedAgentsMemoryStore>;
 
+/**
+ * Confirmation that a `memory_store` was deleted.
+ */
 export interface BetaManagedAgentsDeletedMemoryStore {
+  /**
+   * ID of the deleted memory store (a `memstore_...` identifier). The store and all
+   * its memories and versions are no longer retrievable.
+   */
   id: string;
 
   type: 'memory_store_deleted';
 }
 
+/**
+ * A `memory_store`: a named container for agent memories, scoped to a workspace.
+ * Attach a store to a session via `resources[]` to mount it as a directory the
+ * agent can read and write.
+ */
 export interface BetaManagedAgentsMemoryStore {
+  /**
+   * Unique identifier for the memory store (a `memstore_...` tagged ID). Use this
+   * when attaching the store to a session, or in the `{memory_store_id}` path
+   * parameter of subsequent calls.
+   */
   id: string;
 
   /**
@@ -213,6 +230,10 @@ export interface BetaManagedAgentsMemoryStore {
    */
   created_at: string;
 
+  /**
+   * Human-readable name for the store. 1–255 characters. The store's mount-path slug
+   * under `/mnt/memory/` is derived from this name.
+   */
   name: string;
 
   type: 'memory_store';
@@ -227,24 +248,41 @@ export interface BetaManagedAgentsMemoryStore {
    */
   archived_at?: string | null;
 
+  /**
+   * Free-text description of what the store contains, up to 1024 characters.
+   * Included in the agent's system prompt when the store is attached, so word it to
+   * be useful to the agent. Empty string when unset.
+   */
   description?: string;
 
+  /**
+   * Arbitrary key-value tags for your own bookkeeping (such as the end user a store
+   * belongs to). Up to 16 pairs; keys 1–64 characters; values up to 512 characters.
+   * Returned on retrieve/list but not filterable.
+   */
   metadata?: { [key: string]: string };
 }
 
 export interface MemoryStoreCreateParams {
   /**
-   * Body param
+   * Body param: Human-readable name for the store. Required; 1–255 characters; no
+   * control characters. The mount-path slug under `/mnt/memory/` is derived from
+   * this name (lowercased, non-alphanumeric runs collapsed to a hyphen). Names need
+   * not be unique within a workspace.
    */
   name: string;
 
   /**
-   * Body param
+   * Body param: Free-text description of what the store contains, up to 1024
+   * characters. Included in the agent's system prompt when the store is attached, so
+   * word it to be useful to the agent.
    */
   description?: string;
 
   /**
-   * Body param
+   * Body param: Arbitrary key-value tags for your own bookkeeping (such as the end
+   * user a store belongs to). Up to 16 pairs; keys 1–64 characters; values up to 512
+   * characters. Not visible to the agent.
    */
   metadata?: { [key: string]: string };
 
@@ -263,7 +301,8 @@ export interface MemoryStoreRetrieveParams {
 
 export interface MemoryStoreUpdateParams {
   /**
-   * Body param
+   * Body param: New description for the store, up to 1024 characters. Pass an empty
+   * string to clear it.
    */
   description?: string | null;
 
@@ -275,7 +314,9 @@ export interface MemoryStoreUpdateParams {
   metadata?: { [key: string]: string | null } | null;
 
   /**
-   * Body param
+   * Body param: New human-readable name for the store. 1–255 characters; no control
+   * characters. Renaming changes the slug used for the store's `mount_path` in
+   * sessions created after the update.
    */
   name?: string | null;
 
@@ -287,17 +328,20 @@ export interface MemoryStoreUpdateParams {
 
 export interface MemoryStoreListParams extends PageCursorParams {
   /**
-   * Query param: Return stores created at or after this time (inclusive).
+   * Query param: Return only stores whose `created_at` is at or after this time
+   * (inclusive). Sent on the wire as `created_at[gte]`.
    */
   'created_at[gte]'?: string;
 
   /**
-   * Query param: Return stores created at or before this time (inclusive).
+   * Query param: Return only stores whose `created_at` is at or before this time
+   * (inclusive). Sent on the wire as `created_at[lte]`.
    */
   'created_at[lte]'?: string;
 
   /**
-   * Query param: Query parameter for include_archived
+   * Query param: When `true`, archived stores are included in the results. Defaults
+   * to `false` (archived stores are excluded).
    */
   include_archived?: boolean;
 

package/src/resources/beta/memory-stores/memory-versions.ts

@@ -11,7 +11,7 @@ import { path } from '../../../internal/utils/path';
 
 export class MemoryVersions extends APIResource {
   /**
-   * GetMemoryVersion
+   * Retrieve a memory version
    *
    * @example
    * ```ts
@@ -42,7 +42,7 @@ export class MemoryVersions extends APIResource {
   }
 
   /**
-   * ListMemoryVersions
+   * List memory versions
    *
    * @example
    * ```ts
@@ -75,7 +75,7 @@ export class MemoryVersions extends APIResource {
   }
 
   /**
-   * RedactMemoryVersion
+   * Redact a memory version
    *
    * @example
    * ```ts
@@ -107,18 +107,44 @@ export class MemoryVersions extends APIResource {
 
 export type BetaManagedAgentsMemoryVersionsPageCursor = PageCursor<BetaManagedAgentsMemoryVersion>;
 
+/**
+ * Identifies who performed a write or redact operation. Captured at write time on
+ * the `memory_version` row. The API key that created a session is not recorded on
+ * agent writes; attribution answers who made the write, not who is ultimately
+ * responsible. Look up session provenance separately via the
+ * [Sessions API](/en/api/sessions-retrieve).
+ */
 export type BetaManagedAgentsActor =
   | BetaManagedAgentsSessionActor
   | BetaManagedAgentsAPIActor
   | BetaManagedAgentsUserActor;
 
+/**
+ * Attribution for a write made directly via the public API (outside of any
+ * session).
+ */
 export interface BetaManagedAgentsAPIActor {
+  /**
+   * ID of the API key that performed the write. This identifies the key, not the
+   * secret.
+   */
   api_key_id: string;
 
   type: 'api_actor';
 }
 
+/**
+ * A `memory_version` object: one immutable, attributed row in a memory's
+ * append-only history. Every non-no-op mutation to a memory produces a new
+ * version. Versions belong to the store (not the individual memory) and persist
+ * after the memory is deleted. Retrieving a redacted version returns 200 with
+ * `content`, `path`, `content_size_bytes`, and `content_sha256` set to `null`;
+ * branch on `redacted_at`, not HTTP status.
+ */
 export interface BetaManagedAgentsMemoryVersion {
+  /**
+   * Unique identifier for this version (a `memver_...` value).
+   */
   id: string;
 
   /**
@@ -126,25 +152,59 @@ export interface BetaManagedAgentsMemoryVersion {
    */
   created_at: string;
 
+  /**
+   * ID of the memory this version snapshots (a `mem_...` value). Remains valid after
+   * the memory is deleted; pass it as `memory_id` to
+   * [List memory versions](/en/api/beta/memory_stores/memory_versions/list) to
+   * retrieve the full lineage including the `deleted` row.
+   */
   memory_id: string;
 
+  /**
+   * ID of the memory store this version belongs to (a `memstore_...` value).
+   */
   memory_store_id: string;
 
   /**
-   * MemoryVersionOperation enum
+   * The kind of mutation a `memory_version` records. Every non-no-op mutation to a
+   * memory appends exactly one version row with one of these values.
    */
   operation: BetaManagedAgentsMemoryVersionOperation;
 
   type: 'memory_version';
 
+  /**
+   * The memory's UTF-8 text content as of this version. `null` when `view=basic`,
+   * when `operation` is `deleted`, or when `redacted_at` is set.
+   */
   content?: string | null;
 
+  /**
+   * Lowercase hex SHA-256 digest of `content` as of this version (64 characters).
+   * `null` when `redacted_at` is set or `operation` is `deleted`. Populated
+   * regardless of `view` otherwise.
+   */
   content_sha256?: string | null;
 
+  /**
+   * Size of `content` in bytes as of this version. `null` when `redacted_at` is set
+   * or `operation` is `deleted`. Populated regardless of `view` otherwise.
+   */
   content_size_bytes?: number | null;
 
+  /**
+   * Identifies who performed a write or redact operation. Captured at write time on
+   * the `memory_version` row. The API key that created a session is not recorded on
+   * agent writes; attribution answers who made the write, not who is ultimately
+   * responsible. Look up session provenance separately via the
+   * [Sessions API](/en/api/sessions-retrieve).
+   */
   created_by?: BetaManagedAgentsActor;
 
+  /**
+   * The memory's path at the time of this write. `null` if and only if `redacted_at`
+   * is set.
+   */
   path?: string | null;
 
   /**
@@ -152,23 +212,46 @@ export interface BetaManagedAgentsMemoryVersion {
    */
   redacted_at?: string | null;
 
+  /**
+   * Identifies who performed a write or redact operation. Captured at write time on
+   * the `memory_version` row. The API key that created a session is not recorded on
+   * agent writes; attribution answers who made the write, not who is ultimately
+   * responsible. Look up session provenance separately via the
+   * [Sessions API](/en/api/sessions-retrieve).
+   */
   redacted_by?: BetaManagedAgentsActor;
 }
 
 /**
- * MemoryVersionOperation enum
+ * The kind of mutation a `memory_version` records. Every non-no-op mutation to a
+ * memory appends exactly one version row with one of these values.
  */
 export type BetaManagedAgentsMemoryVersionOperation = 'created' | 'modified' | 'deleted';
 
+/**
+ * Attribution for a write made by an agent during a session, through the mounted
+ * filesystem at `/mnt/memory/`.
+ */
 export interface BetaManagedAgentsSessionActor {
+  /**
+   * ID of the session that performed the write (a `sesn_...` value). Look up the
+   * session via [Retrieve a session](/en/api/sessions-retrieve) for further
+   * provenance.
+   */
   session_id: string;
 
   type: 'session_actor';
 }
 
+/**
+ * Attribution for a write made by a human user through the Anthropic Console.
+ */
 export interface BetaManagedAgentsUserActor {
   type: 'user_actor';
 
+  /**
+   * ID of the user who performed the write (a `user_...` value).
+   */
   user_id: string;
 }
 

package/src/resources/beta/messages/batches.ts

@@ -459,6 +459,10 @@ export namespace BatchCreateParams {
        * Note that our models may stop _before_ reaching this maximum. This parameter
        * only specifies the absolute maximum number of tokens to generate.
        *
+       * Set to `0` to populate the
+       * [prompt cache](https://docs.claude.com/en/docs/build-with-claude/prompt-caching#pre-warming-the-cache)
+       * without generating a response.
+       *
        * Different models have different maximum values for this parameter. See
        * [models](https://docs.claude.com/en/docs/models-overview) for details.
        */

package/src/resources/beta/messages/index.ts

@@ -101,6 +101,7 @@ export {
   type BetaInputJSONDelta,
   type BetaInputTokensClearAtLeast,
   type BetaInputTokensTrigger,
+  type BetaIterationsUsage,
   type BetaJSONOutputFormat,
   type BetaMCPToolResultBlock,
   type BetaMCPToolUseBlock,

package/src/resources/beta/messages/messages.ts

@@ -2,6 +2,7 @@
 
 import { AnthropicError } from '../../../error';
 import { Anthropic } from '../../../client';
+import * as BatchesAPI from './batches';
 import { APIPromise } from '../../../core/api-promise';
 import { APIResource } from '../../../core/resource';
 import { Stream } from '../../../core/streaming';
@@ -25,7 +26,6 @@ import type { Model } from '../../messages/messages';
 import * as BetaMessagesAPI from './messages';
 import * as MessagesAPI from '../../messages/messages';
 import * as BetaAPI from '../beta';
-import * as BatchesAPI from './batches';
 import {
   BatchCancelParams,
   BatchCreateParams,
@@ -3755,6 +3755,10 @@ export interface MessageCreateParamsBase {
    * Note that our models may stop _before_ reaching this maximum. This parameter
    * only specifies the absolute maximum number of tokens to generate.
    *
+   * Set to `0` to populate the
+   * [prompt cache](https://docs.claude.com/en/docs/build-with-claude/prompt-caching#pre-warming-the-cache)
+   * without generating a response.
+   *
    * Different models have different maximum values for this parameter. See
    * [models](https://docs.claude.com/en/docs/models-overview) for details.
    */

package/src/resources/beta/sessions/sessions.ts

@@ -626,6 +626,12 @@ export interface SessionListParams extends PageCursorParams {
    */
   include_archived?: boolean;
 
+  /**
+   * Query param: Filter sessions whose resources contain a memory_store with this
+   * memory store ID.
+   */
+  memory_store_id?: string;
+
   /**
    * Query param: Sort direction for results, ordered by created_at. Defaults to desc
    * (newest first).