langsmith 0.10.11 → 0.10.13

package/src/lib/client.ts

@@ -1,3 +1,4 @@
+import { addressToLrn } from "./address.js";
 import * as uuid from "./utils/uuid/src/index.js";
 import { getOpenAPIBaseUrl } from "./utils/api_url.js";
 import type { OTELContext } from "./experimental/otel/types.js";
@@ -1861,7 +1862,7 @@ export class Client implements LangSmithTracingClientInterface {
 
   /**
    * (beta) Access the sessions resource, which resolves an address to the
-   * project its traces go to: `client.sessions.resolve(address.toApiAddress())`.
+   * project its traces go to: `client.sessions.resolve(address)`.
    */
   public get sessions(): Sessions {
     this._checkStainlessVersion("0.18.0");
@@ -3359,9 +3360,7 @@ export class Client implements LangSmithTracingClientInterface {
 
   /** The ID of the project an address names, with one request. */
   private async _resolveAddress(address: Address): Promise<string> {
-    const { session_id: sessionId } = await this.sessions.resolve(
-      address.toApiAddress(),
-    );
+    const { session_id: sessionId } = await this.sessions.resolve(address);
     assertUuid(sessionId);
     return sessionId;
   }
@@ -5672,7 +5671,7 @@ export class Client implements LangSmithTracingClientInterface {
       return feedback as Feedback;
     }
     const body = JSON.stringify(
-      address ? { ...feedback, address: address._toLrn() } : feedback,
+      address ? { ...feedback, address: addressToLrn(address) } : feedback,
     );
     const url = `${this.apiUrl}/feedback`;
     await this.caller.call(async () => {

package/src/lib/run_trees.ts

@@ -1,3 +1,4 @@
+import { addressToLrn, addressFromLrn } from "./address.js";
 import { Client } from "./client.js";
 import { isEnvTracingEnabled } from "./env.js";
 import {
@@ -33,7 +34,7 @@ import {
   rejectConflicting,
   resolveFromEnv,
 } from "./utils/addressing.js";
-import { AgentAddress, EnvAddressError, ensureAgent } from "./address.js";
+import { type AgentAddress, EnvAddressError, ensureAgent } from "./address.js";
 
 const TIMESTAMP_LENGTH = 36;
 // DNS namespace for UUID v5 (same as Python's uuid.NAMESPACE_DNS)
@@ -197,7 +198,7 @@ const HEADER_SAFE_REPLICA_FIELDS = new Set([
 /** Rebuilds an untrusted header address; `undefined` if unusable. */
 function addressFromHeader(value: unknown): AgentAddress | undefined {
   try {
-    return AgentAddress._fromLrn(value);
+    return addressFromLrn(value);
   } catch {
     // Values are untrusted, so not logged.
     console.warn("Ignoring an unusable address in a `baggage` header.");
@@ -301,7 +302,7 @@ class Baggage {
     }
     if (this.address) {
       items.push(
-        `langsmith-address=${encodeURIComponent(this.address._toLrn())}`,
+        `langsmith-address=${encodeURIComponent(addressToLrn(this.address))}`,
       );
     }
 
@@ -752,7 +753,8 @@ export class RunTree implements BaseRun {
       primary === undefined &&
       !this.replicas?.some((r) => r.primary === true) &&
       projectName === this.project_name &&
-      address?._toLrn() === this.address?._toLrn()
+      (address ? addressToLrn(address) : undefined) ===
+        (this.address ? addressToLrn(this.address) : undefined)
     ) {
       return {
         ...baseRun,
@@ -760,7 +762,8 @@ export class RunTree implements BaseRun {
         address,
       };
     }
-    const seed = projectName ?? address?._toLrn() ?? "agent//";
+    const seed =
+      projectName ?? (address ? addressToLrn(address) : undefined) ?? "agent//";
 
     // Apply reroot logic before ID remapping
     if (reroot) {

package/src/lib/sandbox/README.md

@@ -679,8 +679,9 @@ try {
 
 ## Verifying Requests from LangSmith
 
-`SandboxTokenVerifier` checks EdDSA signatures against LangSmith's JWKS
-(derived from `LANGSMITH_ENDPOINT`, cached) using Web Crypto, so it needs a
+`SandboxTokenVerifier` checks signatures against LangSmith's JWKS (derived from
+`LANGSMITH_ENDPOINT`, cached); user tokens may use any JOSE asymmetric algorithm
+(RS*, PS*, ES\*, EdDSA), chosen by the JWKS key. It uses Web Crypto, so it needs a
 runtime with Ed25519 support (Node.js 20+, Deno, Bun, Cloudflare Workers). The
 JWKS must be served over HTTPS (localhost is exempt); for a plain-HTTP
 self-hosted deployment on a trusted network, pass `allowInsecureJwks: true`.

package/src/lib/sandbox/index.ts

@@ -108,6 +108,7 @@ export type {
   SandboxProxySecret,
   SandboxMount,
   MountCacheConfig,
+  MountEncryptionConfig,
   ContextHubMountConfig,
   ContextHubMountSpec,
   GCSMountConfig,

package/src/lib/sandbox/mounts.ts

@@ -4,6 +4,7 @@ import type {
   GitMountRefSpec,
   GitMountSpec,
   MountCacheConfig,
+  MountEncryptionConfig,
   SandboxAwsAuthRule,
   SandboxGcpAuthRule,
   S3MountSpec,
@@ -98,6 +99,7 @@ export function s3Mount({
   pathStyle = false,
   readOnly,
   cache,
+  encryption,
 }: {
   id: string;
   mountPath: string;
@@ -108,6 +110,7 @@ export function s3Mount({
   pathStyle?: boolean;
   readOnly?: boolean;
   cache?: MountCacheConfig;
+  encryption?: MountEncryptionConfig;
 }): S3MountSpec {
   const mount: S3MountSpec = {
     id: requireNonEmptyString(id, "id"),
@@ -129,6 +132,11 @@ export function s3Mount({
   if (cache !== undefined) {
     mount.cache = { ...cache };
   }
+  if (encryption !== undefined) {
+    mount.encryption = {
+      kms_key: requireNonEmptyString(encryption.kms_key, "encryption.kms_key"),
+    };
+  }
   return mount;
 }
 

package/src/lib/sandbox/types.ts

@@ -603,10 +603,18 @@ export interface S3MountConfig {
   path_style?: boolean;
 }
 
+/** Customer-managed key that uploads through a mount are encrypted with. */
+export interface MountEncryptionConfig {
+  /** KMS key ARN in the mount's region; uploads use SSE-KMS with this key. */
+  kms_key: string;
+}
+
 /** S3-backed sandbox mount specification. */
 export interface S3MountSpec extends SandboxBucketMountBase {
   /** Mount type. */
   type: "s3";
+  /** Optional customer-managed key for uploads. */
+  encryption?: MountEncryptionConfig;
   /** S3 mount configuration. */
   s3: S3MountConfig;
 }

package/src/lib/sandbox/verify.ts

@@ -99,7 +99,72 @@ interface Jwk {
   kty?: string;
   crv?: string;
   kid?: string;
+  alg?: string;
   x?: string;
+  y?: string;
+  n?: string;
+  e?: string;
+}
+
+interface VerificationKey {
+  alg: string;
+  key: CryptoKey;
+}
+
+interface AlgorithmSpec {
+  kty: string;
+  crv?: string;
+  importParams: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams;
+  verifyParams: AlgorithmIdentifier | RsaPssParams | EcdsaParams;
+}
+
+// Every JOSE asymmetric algorithm; the JWKS key picks which one a token may use.
+const ALGORITHMS: Record<string, AlgorithmSpec> = {
+  EdDSA: {
+    kty: "OKP",
+    crv: "Ed25519",
+    importParams: { name: "Ed25519" },
+    verifyParams: { name: "Ed25519" },
+  },
+};
+for (const [bits, curve] of [
+  [256, "P-256"],
+  [384, "P-384"],
+  [512, "P-521"],
+] as const) {
+  const hash = `SHA-${bits}`;
+  ALGORITHMS[`RS${bits}`] = {
+    kty: "RSA",
+    importParams: { name: "RSASSA-PKCS1-v1_5", hash },
+    verifyParams: { name: "RSASSA-PKCS1-v1_5" },
+  };
+  // JWS RSA-PSS uses a salt as long as the hash.
+  ALGORITHMS[`PS${bits}`] = {
+    kty: "RSA",
+    importParams: { name: "RSA-PSS", hash },
+    verifyParams: { name: "RSA-PSS", saltLength: bits / 8 },
+  };
+  // The JWS ECDSA signature is raw r||s, which Web Crypto verifies directly.
+  ALGORITHMS[`ES${bits}`] = {
+    kty: "EC",
+    crv: curve,
+    importParams: { name: "ECDSA", namedCurve: curve },
+    verifyParams: { name: "ECDSA", hash },
+  };
+}
+
+const USER_TOKEN_ALGORITHMS = Object.keys(ALGORITHMS);
+const CALLBACK_ALGORITHMS = ["EdDSA"];
+
+/** A JWK's algorithm: its `alg` member if supported, else derived from its key type. */
+function jwkAlgorithm(jwk: Jwk): string | undefined {
+  if (jwk.alg !== undefined) {
+    return USER_TOKEN_ALGORITHMS.includes(jwk.alg) ? jwk.alg : undefined;
+  }
+  if (jwk.kty === "RSA") return "RS256";
+  return USER_TOKEN_ALGORITHMS.find(
+    (alg) => ALGORITHMS[alg].kty === jwk.kty && ALGORITHMS[alg].crv === jwk.crv,
+  );
 }
 
 function fail(message: string): never {
@@ -202,7 +267,7 @@ function timingSafeEqual(a: string, b: string): boolean {
 export class SandboxTokenVerifier {
   private readonly jwksUrl: string;
   private readonly timeoutMs: number;
-  private keys = new Map<string, Promise<CryptoKey>>();
+  private keys = new Map<string, VerificationKey>();
   private fetchedAt = 0;
   private inflight?: Promise<void>;
 
@@ -233,6 +298,7 @@ export class SandboxTokenVerifier {
   ): Promise<SandboxUser> {
     const claims = await this.verify(
       token,
+      USER_TOKEN_ALGORITHMS,
       serviceHost(options.audience),
       options.issuer,
     );
@@ -260,6 +326,7 @@ export class SandboxTokenVerifier {
   ): Promise<SandboxCallback> {
     const claims = await this.verify(
       options.signature,
+      CALLBACK_ALGORITHMS,
       options.aud,
       options.issuer,
     );
@@ -293,6 +360,7 @@ export class SandboxTokenVerifier {
 
   private async verify(
     token: string,
+    algorithms: string[],
     audience: AudienceMatcher | undefined,
     issuer: string | undefined,
   ): Promise<Claims> {
@@ -308,14 +376,19 @@ export class SandboxTokenVerifier {
     } catch (e) {
       fail(`malformed token: ${(e as Error).message}`);
     }
-    if (header.alg !== "EdDSA") {
+    if (!algorithms.includes(header.alg as string)) {
       fail(`unexpected signing algorithm: ${JSON.stringify(header.alg)}`);
     }
     if (typeof header.kid !== "string" || !header.kid) fail("token has no kid");
 
-    const key = await this.key(header.kid);
+    const { alg, key } = await this.key(header.kid);
+    // The key belongs to one algorithm; the token must claim that one.
+    if (header.alg !== alg) {
+      fail(`unexpected signing algorithm: ${JSON.stringify(header.alg)}`);
+    }
     const signed = new TextEncoder().encode(`${parts[0]}.${parts[1]}`);
-    if (!(await subtle().verify({ name: "Ed25519" }, key, signature, signed))) {
+    const { verifyParams } = ALGORITHMS[alg];
+    if (!(await subtle().verify(verifyParams, key, signature, signed))) {
       fail("invalid signature");
     }
 
@@ -347,7 +420,7 @@ export class SandboxTokenVerifier {
     return claims;
   }
 
-  private async key(kid: string): Promise<CryptoKey> {
+  private async key(kid: string): Promise<VerificationKey> {
     const age = Date.now() - this.fetchedAt;
     const fresh = this.keys.has(kid) && age < JWKS_TTL_MS;
     if (!fresh && (this.fetchedAt === 0 || age >= JWKS_MIN_REFRESH_MS)) {
@@ -356,17 +429,9 @@ export class SandboxTokenVerifier {
       });
       await this.inflight;
     }
-    const key = this.keys.get(kid);
-    if (!key) fail(`unknown signing key: ${kid}`);
-    try {
-      return await key;
-    } catch (e) {
-      fail(
-        `signing key ${kid} is not a usable Ed25519 key: ${
-          (e as Error).message
-        }`,
-      );
-    }
+    const entry = this.keys.get(kid);
+    if (!entry) fail(`unknown signing key: ${kid}`);
+    return entry;
   }
 
   private async refresh(): Promise<void> {
@@ -386,20 +451,34 @@ export class SandboxTokenVerifier {
     if (!Array.isArray(entries)) {
       fail("invalid JWKS: expected an object with a keys array");
     }
-    const keys = new Map<string, Promise<CryptoKey>>();
+    const keys = new Map<string, VerificationKey>();
+    const webCrypto = subtle();
     for (const jwk of entries as (Jwk | null)[]) {
-      if (typeof jwk !== "object" || jwk === null) continue;
-      if (jwk.kty !== "OKP" || jwk.crv !== "Ed25519" || !jwk.kid || !jwk.x)
+      if (typeof jwk !== "object" || jwk === null || !jwk.kid) continue;
+      const alg = jwkAlgorithm(jwk);
+      if (!alg) continue;
+      const { kty, crv, importParams } = ALGORITHMS[alg];
+      if (jwk.kty !== kty || jwk.crv !== crv) continue;
+      try {
+        // Import with the key's own algorithm: Web Crypto fixes the RSA hash here.
+        const key = await webCrypto.importKey(
+          "jwk",
+          {
+            kty: jwk.kty,
+            crv: jwk.crv,
+            x: jwk.x,
+            y: jwk.y,
+            n: jwk.n,
+            e: jwk.e,
+          },
+          importParams,
+          false,
+          ["verify"],
+        );
+        keys.set(jwk.kid, { alg, key });
+      } catch {
         continue;
-      const imported = subtle().importKey(
-        "jwk",
-        { kty: "OKP", crv: "Ed25519", x: jwk.x },
-        { name: "Ed25519" },
-        false,
-        ["verify"],
-      );
-      imported.catch(() => undefined);
-      keys.set(jwk.kid, imported);
+      }
     }
     this.keys = keys;
     this.fetchedAt = Date.now();

package/src/lib/utils/addressing.ts

@@ -1,5 +1,8 @@
 import {
-  AgentAddress,
+  type AgentAddress,
+  addressFromEnv,
+  addressFromLrn,
+  addressToLrn,
   EnvAddressError,
   ensureAgent,
   envNames,
@@ -47,7 +50,7 @@ function getEnvProject(): string | undefined {
  */
 export function resolveFromEnv(): Tier {
   const project = getEnvProject();
-  const address = AgentAddress.fromEnv();
+  const address = addressFromEnv();
   if (project && address) {
     throw new EnvAddressError(
       "LANGSMITH_AGENT_* and a project are both set in the environment.",
@@ -92,7 +95,7 @@ export function applyToPayload(
     // is sent. It is parsed again, so a malformed one cannot fail the whole
     // batch in the backend.
     try {
-      address = AgentAddress._fromLrn(payload.address);
+      address = addressFromLrn(payload.address);
     } catch {
       throw new Error("The run's `address` is not a valid agent address.");
     }
@@ -103,7 +106,7 @@ export function applyToPayload(
   const namedProject =
     payload.session_id != null || payload.session_name != null;
   if (!address && !update && !namedProject) {
-    address = AgentAddress.fromEnv();
+    address = addressFromEnv();
   }
   if (!address) {
     return;
@@ -112,7 +115,7 @@ export function applyToPayload(
     "Sending runs to an `address` is in beta and enabled per workspace; a " +
       "workspace without it rejects the runs.",
   );
-  payload.address = address._toLrn();
+  payload.address = addressToLrn(address);
   if (!namedProject) {
     delete payload.session_name;
     delete payload.session_id;

package/src/resources/annotation-queues/annotation-queues.ts

@@ -194,6 +194,8 @@ export interface AnnotationQueueRubricItemSchema {
 
   description?: string | null;
 
+  feedback_config?: AnnotationQueueRubricItemSchema.FeedbackConfig | null;
+
   feedback_config_id?: string | null;
 
   is_assertion?: boolean | null;
@@ -207,6 +209,48 @@ export interface AnnotationQueueRubricItemSchema {
   value_descriptions?: { [key: string]: string } | null;
 }
 
+export namespace AnnotationQueueRubricItemSchema {
+  export interface FeedbackConfig {
+    id: string;
+
+    feedback_config: FeedbackConfig.FeedbackConfig;
+
+    feedback_key: string;
+
+    modified_at: string;
+
+    tenant_id: string;
+
+    is_lower_score_better?: boolean | null;
+  }
+
+  export namespace FeedbackConfig {
+    export interface FeedbackConfig {
+      /**
+       * Enum for feedback types.
+       */
+      type: 'continuous' | 'categorical' | 'freeform';
+
+      categories?: Array<FeedbackConfig.Category> | null;
+
+      max?: number | null;
+
+      min?: number | null;
+    }
+
+    export namespace FeedbackConfig {
+      /**
+       * Specific value and label pair for feedback
+       */
+      export interface Category {
+        value: number;
+
+        label?: string | null;
+      }
+    }
+  }
+}
+
 /**
  * AnnotationQueue schema.
  */
@@ -519,7 +563,7 @@ export interface AnnotationQueueUpdateParams {
 
   description?: string | null;
 
-  enable_reservations?: boolean;
+  enable_reservations?: boolean | DatasetsAPI.Missing;
 
   metadata?: { [key: string]: unknown } | DatasetsAPI.Missing | null;
 
@@ -527,7 +571,7 @@ export interface AnnotationQueueUpdateParams {
 
   num_reviewers_per_item?: number | DatasetsAPI.Missing | null;
 
-  reservation_minutes?: number | null;
+  reservation_minutes?: number | DatasetsAPI.Missing | null;
 
   reviewer_access_mode?: 'any' | 'assigned' | null;
 

package/src/resources/runs/runs.ts

@@ -41,6 +41,10 @@ export class Runs extends APIResource {
    * start_time. Supports filters, cursor pagination, and `selects` to select fields
    * to return.
    *
+   * When `ai_search` is set, `Accept: text/event-stream` is required; requests
+   * without it return 406. AI search is unavailable on deployments that route
+   * queries to the v1 backend and returns 501 there.
+   *
    * Self-hosted deployments require LangSmith `v0.16` or later.
    *
    * @example
@@ -872,6 +876,15 @@ export interface RunGetURLParams {
 }
 
 export interface RunQueryV2Params extends ItemsCursorPostPaginationParams {
+  /**
+   * Body param: `ai_search` is a plain-language criterion evaluated against the
+   * messages from the agent trajectory scoped to the run. AND-ed with the ordinary
+   * filters. Requires semantic filtering enabled for the deployment. Must contain
+   * nonempty text of at most 2000 UTF-8 bytes. Not supported on public dataset
+   * queries.
+   */
+  ai_search?: string;
+
   /**
    * Body param: `filter` narrows results to runs matching this LangSmith filter
    * expression, evaluated against each individual run. For example: and(eq(run_type,
@@ -972,7 +985,8 @@ export interface RunQueryV2Params extends ItemsCursorPostPaginationParams {
   tree_filter?: string;
 
   /**
-   * Header param: application/json or text/event-stream
+   * Header param: application/json, or text/event-stream (required when ai_search is
+   * set)
    */
   Accept?: string;
 }

package/src/resources/sandboxes/boxes.ts

@@ -404,6 +404,8 @@ export namespace BoxCreateParams {
 
       contexthub?: SandboxapiS3BucketMountSpec.Contexthub;
 
+      encryption?: SandboxapiS3BucketMountSpec.Encryption;
+
       gcs?: SandboxapiS3BucketMountSpec.Gcs;
 
       git?: SandboxapiS3BucketMountSpec.Git;
@@ -445,6 +447,14 @@ export namespace BoxCreateParams {
         initial_pull_only?: boolean;
       }
 
+      export interface Encryption {
+        /**
+         * KMSKey is the key to encrypt uploads with. S3 mounts take a KMS key ARN in the
+         * mount's region.
+         */
+        kms_key: string;
+      }
+
       export interface Gcs {
         bucket: string;
 
@@ -481,6 +491,8 @@ export namespace BoxCreateParams {
 
       contexthub?: SandboxapiGcsBucketMountSpec.Contexthub;
 
+      encryption?: SandboxapiGcsBucketMountSpec.Encryption;
+
       git?: SandboxapiGcsBucketMountSpec.Git;
 
       read_only?: boolean;
@@ -516,6 +528,14 @@ export namespace BoxCreateParams {
         initial_pull_only?: boolean;
       }
 
+      export interface Encryption {
+        /**
+         * KMSKey is the key to encrypt uploads with. S3 mounts take a KMS key ARN in the
+         * mount's region.
+         */
+        kms_key: string;
+      }
+
       export interface Git {
         remote_url: string;
 
@@ -558,6 +578,8 @@ export namespace BoxCreateParams {
 
       contexthub?: SandboxapiGitRepoMountSpec.Contexthub;
 
+      encryption?: SandboxapiGitRepoMountSpec.Encryption;
+
       gcs?: SandboxapiGitRepoMountSpec.Gcs;
 
       read_only?: boolean;
@@ -603,6 +625,14 @@ export namespace BoxCreateParams {
         initial_pull_only?: boolean;
       }
 
+      export interface Encryption {
+        /**
+         * KMSKey is the key to encrypt uploads with. S3 mounts take a KMS key ARN in the
+         * mount's region.
+         */
+        kms_key: string;
+      }
+
       export interface Gcs {
         bucket: string;
 
@@ -633,6 +663,8 @@ export namespace BoxCreateParams {
 
       cache?: SandboxapiContextHubRepoMountSpec.Cache;
 
+      encryption?: SandboxapiContextHubRepoMountSpec.Encryption;
+
       gcs?: SandboxapiContextHubRepoMountSpec.Gcs;
 
       git?: SandboxapiContextHubRepoMountSpec.Git;
@@ -664,6 +696,14 @@ export namespace BoxCreateParams {
         writeback_seconds?: number;
       }
 
+      export interface Encryption {
+        /**
+         * KMSKey is the key to encrypt uploads with. S3 mounts take a KMS key ARN in the
+         * mount's region.
+         */
+        kms_key: string;
+      }
+
       export interface Gcs {
         bucket: string;