@anthropic-ai/sdk 0.120.0 → 0.121.0

package/src/lib/standard-schema.ts

@@ -0,0 +1,209 @@
+import { AnthropicError } from '../core/error';
+
+// Standard Schema spec types, copied from `@standard-schema/spec@1.1.0` (MIT) as the spec
+// recommends. See https://standardschema.dev
+
+/** The Standard Typed interface. This is a base type extended by other specs. */
+export interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly '~standard': StandardTypedV1.Props<Input, Output>;
+}
+
+export declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['input'];
+
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+
+export declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (
+      value: unknown,
+      options?: StandardSchemaV1.Options | undefined,
+    ) => Result<Output> | Promise<Result<Output>>;
+  }
+
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+
+/** The Standard JSON Schema interface. */
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly '~standard': StandardJSONSchemaV1.Props<Input, Output>;
+}
+
+export declare namespace StandardJSONSchemaV1 {
+  /** The Standard JSON Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: StandardJSONSchemaV1.Converter;
+  }
+
+  /** The Standard JSON Schema converter interface. */
+  interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+  }
+
+  /**
+   * The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they
+   * are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should
+   * throw if they don't support a specified target.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a
+   * superset of JSON Schema `"draft-04"`.
+   */
+  type Target = 'draft-2020-12' | 'draft-07' | 'openapi-3.0' | ({} & string);
+
+  /** The options for the input/output methods. */
+  interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+
+/**
+ * Returns `jsonSchema` if given, otherwise the schema's Standard JSON Schema `input`
+ * representation (the model produces the value that the validator consumes).
+ */
+export function standardSchemaToJSONSchema(
+  schema: StandardSchemaV1,
+  jsonSchema?: Record<string, unknown> | undefined,
+): Record<string, unknown> {
+  if (jsonSchema) {
+    return jsonSchema;
+  }
+
+  const std: StandardSchemaV1.Props & Partial<StandardJSONSchemaV1.Props> = schema['~standard'];
+  if (std.jsonSchema) {
+    return std.jsonSchema.input({ target: 'draft-2020-12' });
+  }
+
+  throw new AnthropicError(
+    `Could not derive a JSON Schema from this ${std.vendor} schema as it does not implement Standard JSON Schema (\`~standard.jsonSchema\`). Pass the \`jsonSchema\` option, or use a library version that implements it (e.g. zod >= 4.2, or valibot via \`toStandardJsonSchema()\`).`,
+  );
+}
+
+/**
+ * Validates `value` with `~standard.validate` and returns the typed output, throwing an
+ * `AnthropicError` on issues. Validation must be synchronous because `parse` hooks are.
+ */
+export function parseWithStandardSchema<Schema extends StandardSchemaV1>(
+  schema: Schema,
+  value: unknown,
+): StandardSchemaV1.InferOutput<Schema> {
+  const result = schema['~standard'].validate(value);
+
+  if (result instanceof Promise) {
+    // avoid an unhandled rejection from the discarded result
+    result.catch(() => {});
+    throw new AnthropicError(
+      `Async validation is not supported: the ${schema['~standard'].vendor} schema's \`~standard.validate()\` returned a Promise.`,
+    );
+  }
+
+  if (result.issues) {
+    const formattedIssues = result.issues.slice(0, 5).map(formatIssue).join('\n');
+    const issueCount = result.issues.length;
+    const suffix = issueCount > 5 ? `\n  ... and ${issueCount - 5} more issue(s)` : '';
+
+    throw new AnthropicError(
+      `Schema validation failed with ${issueCount} issue(s):\n${formattedIssues}${suffix}`,
+    );
+  }
+
+  return result.value;
+}
+
+function formatIssue(issue: StandardSchemaV1.Issue): string {
+  const path = (issue.path ?? [])
+    .map((segment) => String(typeof segment === 'object' ? segment.key : segment))
+    .join('.');
+  return path ? `  - ${path}: ${issue.message}` : `  - ${issue.message}`;
+}

package/src/lib/tools/BetaToolRunner.ts

@@ -8,6 +8,7 @@ import {
   BetaMessageParam,
   BetaRequestToolAdditionBlock,
   BetaRequestToolRemovalBlock,
+  BetaStopReason,
   BetaToolChangeMCPToolReference,
   BetaToolChangeMCPToolsetReference,
   BetaToolChangeToolReference,
@@ -18,6 +19,7 @@ import { BetaMessageStream } from '../BetaMessageStream';
 import { RequestOptions } from '../../internal/request-options';
 import { buildHeaders } from '../../internal/headers';
 import { promiseWithResolvers } from '../../internal/utils/promise';
+import { checkNever } from '../../internal/utils/values';
 import { CompactionControl, DEFAULT_SUMMARY_PROMPT, DEFAULT_TOKEN_THRESHOLD } from './CompactionControl';
 import {
   collectStainlessHelpers,
@@ -220,6 +222,7 @@ export class BetaToolRunner<Stream extends boolean> {
           if (!isCompacted) {
             if (!this.#mutated) {
               const message = await this.#message;
+              const nextStep = determineNextStepFromStopReason(message.stop_reason);
               this.#state.params.messages.push({ role: message.role, content: message.content });
 
               // Container-bound server tools reject a follow-up request that omits the container the
@@ -233,14 +236,12 @@ export class BetaToolRunner<Stream extends boolean> {
                 }
               }
 
-              // Refusal-terminated turns are terminal: the refusal may have cut a tool_use off
-              // with partial input, so executing this turn's tools would fire side effects the
-              // model never confirmed — and once middleware strips the refusal turn, their
-              // tool_results could never be replayed coherently. Surface the refusal as the
-              // final message instead.
-              if (message.stop_reason === 'refusal') {
+              if (nextStep === 'stop') {
                 break;
               }
+              if (nextStep === 'resume') {
+                continue;
+              }
             }
 
             const toolMessage = await this.#generateToolResponse(this.#state.params.messages.at(-1)!);
@@ -612,6 +613,37 @@ function referencedToolName(
   }
 }
 
+type NextStep = 'run_tools' | 'resume' | 'stop';
+
+/**
+ * Sorts every stop reason into one of three buckets: `run_tools` turns run their client tool
+ * calls and continue the loop; `resume` turns are sent back unchanged so the server continues
+ * them; `stop` turns end the loop without running any tool calls.
+ */
+function determineNextStepFromStopReason(stopReason: BetaStopReason | null): NextStep {
+  if (stopReason === null) return 'stop';
+  switch (stopReason) {
+    case 'tool_use':
+      return 'run_tools';
+    case 'pause_turn':
+    // pause_after_compaction hands the turn back before the model answers; sending it back
+    // unchanged continues it.
+    case 'compaction':
+      return 'resume';
+    case 'end_turn':
+    case 'stop_sequence':
+    case 'max_tokens':
+    case 'model_context_window_exceeded':
+    case 'refusal':
+      return 'stop';
+    default:
+      // The union is forward-compatible, so a stop reason this SDK doesn't know yet ends the
+      // loop rather than throwing; the `never` check makes tsc reject an unclassified member.
+      checkNever(stopReason);
+      return 'stop';
+  }
+}
+
 // vendored from typefest just to make things look a bit nicer on hover
 type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
 

package/src/resources/beta/beta.ts

@@ -595,6 +595,8 @@ import {
   BetaMCPToolConfig,
   BetaMCPToolDefaultConfig,
 } from './messages/messages';
+import * as OrganizationAPI from './organization/organization';
+import { BetaOrganization, BetaOrganizationRole, Organization } from './organization/organization';
 import * as SessionsAPI from './sessions/sessions';
 import {
   BetaManagedAgentsAdvisorParams,
@@ -696,6 +698,7 @@ export class Beta extends APIResource {
   userProfiles: UserProfilesAPI.UserProfiles = new UserProfilesAPI.UserProfiles(this._client);
   dreams: DreamsAPI.Dreams = new DreamsAPI.Dreams(this._client);
   tunnels: TunnelsAPI.Tunnels = new TunnelsAPI.Tunnels(this._client);
+  organization: OrganizationAPI.Organization = new OrganizationAPI.Organization(this._client);
 }
 
 export type AnthropicBeta =
@@ -733,7 +736,14 @@ export type AnthropicBeta =
   | 'fallback-credit-2026-06-01'
   | 'fallback-credit-2026-07-01'
   | 'agent-memory-2026-07-22'
-  | 'mid-conversation-tool-changes-2026-07-01';
+  | 'mid-conversation-tool-changes-2026-07-01'
+  | 'compact-2026-01-12'
+  | 'computer-use-2025-11-24'
+  | 'mcp-tunnels-2026-06-22'
+  | 'structured-outputs-2025-11-13'
+  | 'task-budgets-2026-03-13'
+  | 'thinking-display-updates-2026-08-18'
+  | 'ce-user-management-2026-07-13';
 
 export interface BetaAPIError {
   message: string;
@@ -844,6 +854,7 @@ Beta.Webhooks = Webhooks;
 Beta.UserProfiles = UserProfiles;
 Beta.Dreams = Dreams;
 Beta.Tunnels = Tunnels;
+Beta.Organization = Organization;
 
 export declare namespace Beta {
   export {
@@ -1540,4 +1551,10 @@ export declare namespace Beta {
     type TunnelRevealTokenParams as TunnelRevealTokenParams,
     type TunnelRotateTokenParams as TunnelRotateTokenParams,
   };
+
+  export {
+    Organization as Organization,
+    type BetaOrganization as BetaOrganization,
+    type BetaOrganizationRole as BetaOrganizationRole,
+  };
 }

package/src/resources/beta/environments/environments.ts

@@ -231,6 +231,9 @@ export interface BetaCloudConfigParams {
    * When versioning, use the version semantics relevant for the package manager,
    * e.g. for `pip` use `package==1.0.0`. You are responsible for validating the
    * package and version exist. Unversioned installs the latest.
+   *
+   * Under `limited` networking, requires `networking.allow_package_managers` to be
+   * `true`.
    */
   packages?: BetaPackagesParams | null;
 }
@@ -352,7 +355,8 @@ export interface BetaLimitedNetworkParams {
 
   /**
    * Permits outbound access to public package registries (PyPI, npm, etc.) beyond
-   * those listed in the `allowed_hosts` array. Defaults to `false`.
+   * those listed in the `allowed_hosts` array. Defaults to `false` on creation. Must
+   * be `true` when `packages` are specified.
    */
   allow_package_managers?: boolean | null;
 
@@ -408,6 +412,9 @@ export interface BetaPackages {
  * When versioning, use the version semantics relevant for the package manager,
  * e.g. for `pip` use `package==1.0.0`. You are responsible for validating the
  * package and version exist. Unversioned installs the latest.
+ *
+ * Under `limited` networking, requires `networking.allow_package_managers` to be
+ * `true`.
  */
 export interface BetaPackagesParams {
   /**

package/src/resources/beta/index.ts

@@ -548,6 +548,7 @@ export {
   type ModelListParams,
   type BetaModelInfosPage,
 } from './models';
+export { Organization, type BetaOrganization, type BetaOrganizationRole } from './organization/index';
 export {
   Sessions,
   type BetaManagedAgentsAdvisorParams,

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

@@ -187,10 +187,11 @@ export interface BetaManagedAgentsContentSha256Precondition {
 
 /**
  * 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.
+ * [Delete a memory](/en/api/beta/memory_stores/memories/delete). Deleting a memory
+ * does not erase its version history: its versions remain listable via
+ * [List memory versions](/en/api/beta/memory_stores/memory_versions/list) while
+ * they are retained (each version is kept for at least the version retention
+ * period after it was written, unless the store itself is deleted).
  */
 export interface BetaManagedAgentsDeletedMemory {
   /**
@@ -258,7 +259,7 @@ export interface BetaManagedAgentsMemory {
    * 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
+   * Enumerate the history via
    * [List memory versions](/en/api/beta/memory_stores/memory_versions/list).
    */
   memory_version_id: string;

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

@@ -137,10 +137,12 @@ export interface BetaManagedAgentsAPIActor {
 /**
  * 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.
+ * version. Versions belong to the store (not the individual memory) and are not
+ * deleted with the memory; each version is retained for at least the version
+ * retention period after it was written, unless the store itself 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 {
   /**
@@ -157,7 +159,8 @@ export interface BetaManagedAgentsMemoryVersion {
    * 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.
+   * retrieve the memory's retained versions, including the `deleted` row while the
+   * lineage is retained.
    */
   memory_id: string;
 

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

@@ -3256,11 +3256,25 @@ export interface BetaInputTokensTrigger {
  * Per-iteration token usage breakdown.
  *
  * Each entry represents one sampling iteration, with its own input/output token
- * counts and cache statistics. This allows you to:
+ * counts and cache statistics, discriminated by `type`. For `message` entries
+ * (model sampling iterations, such as the turns of a server-side tool use loop),
+ * this allows you to:
  *
  * - Determine which iterations exceeded long context thresholds (>=200k tokens)
- * - Calculate the true context window size from the last iteration
+ * - Calculate the context window size from the last `message` entry
  * - Understand token accumulation across server-side tool use loops
+ *
+ * A `compaction` entry reports the token usage of the compaction operation itself
+ * — the server-side request that summarizes the context being closed — NOT the
+ * size of the context that was compacted away, and its token counts can be much
+ * smaller than that closed context (for example, a compaction that closes a
+ * ~200k-token context can report only a few thousand tokens). Do not derive the
+ * context window size from a `compaction` entry, even when it is the last entry. A
+ * `compaction` entry's tokens are not included in the top-level `usage` fields.
+ * When an input-token trigger is in effect (the default — 150,000 tokens unless
+ * configured otherwise), each `compaction` entry closes a context that had reached
+ * at least that threshold, though the context can exceed it by the final
+ * iteration's output and tool results.
  */
 export type BetaIterationsUsage = Array<
   | BetaMessageIterationUsage
@@ -3685,11 +3699,25 @@ export interface BetaMessageDeltaUsage {
    * Per-iteration token usage breakdown.
    *
    * Each entry represents one sampling iteration, with its own input/output token
-   * counts and cache statistics. This allows you to:
+   * counts and cache statistics, discriminated by `type`. For `message` entries
+   * (model sampling iterations, such as the turns of a server-side tool use loop),
+   * this allows you to:
    *
    * - Determine which iterations exceeded long context thresholds (>=200k tokens)
-   * - Calculate the true context window size from the last iteration
+   * - Calculate the context window size from the last `message` entry
    * - Understand token accumulation across server-side tool use loops
+   *
+   * A `compaction` entry reports the token usage of the compaction operation itself
+   * — the server-side request that summarizes the context being closed — NOT the
+   * size of the context that was compacted away, and its token counts can be much
+   * smaller than that closed context (for example, a compaction that closes a
+   * ~200k-token context can report only a few thousand tokens). Do not derive the
+   * context window size from a `compaction` entry, even when it is the last entry. A
+   * `compaction` entry's tokens are not included in the top-level `usage` fields.
+   * When an input-token trigger is in effect (the default — 150,000 tokens unless
+   * configured otherwise), each `compaction` entry closes a context that had reached
+   * at least that threshold, though the context can exceed it by the final
+   * iteration's output and tool results.
    */
   iterations: BetaIterationsUsage | null;
 
@@ -4536,7 +4564,7 @@ export interface BetaThinkingConfigAdaptive {
    * redacted but a signature is returned for multi-turn continuity. Defaults to
    * `summarized`.
    */
-  display?: 'summarized' | 'omitted' | null;
+  display?: 'summarized' | 'omitted' | 'updates' | null;
 }
 
 export interface BetaThinkingConfigDisabled {
@@ -4565,7 +4593,7 @@ export interface BetaThinkingConfigEnabled {
    * redacted but a signature is returned for multi-turn continuity. Defaults to
    * `summarized`.
    */
-  display?: 'summarized' | 'omitted' | null;
+  display?: 'summarized' | 'omitted' | 'updates' | null;
 }
 
 /**
@@ -5460,11 +5488,25 @@ export interface BetaUsage {
    * Per-iteration token usage breakdown.
    *
    * Each entry represents one sampling iteration, with its own input/output token
-   * counts and cache statistics. This allows you to:
+   * counts and cache statistics, discriminated by `type`. For `message` entries
+   * (model sampling iterations, such as the turns of a server-side tool use loop),
+   * this allows you to:
    *
    * - Determine which iterations exceeded long context thresholds (>=200k tokens)
-   * - Calculate the true context window size from the last iteration
+   * - Calculate the context window size from the last `message` entry
    * - Understand token accumulation across server-side tool use loops
+   *
+   * A `compaction` entry reports the token usage of the compaction operation itself
+   * — the server-side request that summarizes the context being closed — NOT the
+   * size of the context that was compacted away, and its token counts can be much
+   * smaller than that closed context (for example, a compaction that closes a
+   * ~200k-token context can report only a few thousand tokens). Do not derive the
+   * context window size from a `compaction` entry, even when it is the last entry. A
+   * `compaction` entry's tokens are not included in the top-level `usage` fields.
+   * When an input-token trigger is in effect (the default — 150,000 tokens unless
+   * configured otherwise), each `compaction` entry closes a context that had reached
+   * at least that threshold, though the context can exceed it by the final
+   * iteration's output and tool results.
    */
   iterations: BetaIterationsUsage | null;