langsmith 0.10.11 → 0.10.12

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/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;
 

package/src/resources/sandboxes/sandboxes.ts

@@ -260,6 +260,8 @@ export namespace SandboxResponse {
 
       contexthub?: SandboxapiS3BucketMountSpec.Contexthub;
 
+      encryption?: SandboxapiS3BucketMountSpec.Encryption;
+
       gcs?: SandboxapiS3BucketMountSpec.Gcs;
 
       git?: SandboxapiS3BucketMountSpec.Git;
@@ -301,6 +303,14 @@ export namespace SandboxResponse {
         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;
 
@@ -337,6 +347,8 @@ export namespace SandboxResponse {
 
       contexthub?: SandboxapiGcsBucketMountSpec.Contexthub;
 
+      encryption?: SandboxapiGcsBucketMountSpec.Encryption;
+
       git?: SandboxapiGcsBucketMountSpec.Git;
 
       read_only?: boolean;
@@ -372,6 +384,14 @@ export namespace SandboxResponse {
         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;
 
@@ -414,6 +434,8 @@ export namespace SandboxResponse {
 
       contexthub?: SandboxapiGitRepoMountSpec.Contexthub;
 
+      encryption?: SandboxapiGitRepoMountSpec.Encryption;
+
       gcs?: SandboxapiGitRepoMountSpec.Gcs;
 
       read_only?: boolean;
@@ -459,6 +481,14 @@ export namespace SandboxResponse {
         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;
 
@@ -489,6 +519,8 @@ export namespace SandboxResponse {
 
       cache?: SandboxapiContextHubRepoMountSpec.Cache;
 
+      encryption?: SandboxapiContextHubRepoMountSpec.Encryption;
+
       gcs?: SandboxapiContextHubRepoMountSpec.Gcs;
 
       git?: SandboxapiContextHubRepoMountSpec.Git;
@@ -520,6 +552,14 @@ export namespace SandboxResponse {
         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;
 

package/src/resources/threads/threads.ts

@@ -85,6 +85,10 @@ export class Threads extends APIResource {
    * Query threads within a project (session), with cursor-based pagination. Returns
    * threads matching the given time range and optional filters.
    *
+   * 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
@@ -1087,6 +1091,14 @@ export interface ThreadListTracesParams extends ItemsCursorGetPaginationParams {
 }
 
 export interface ThreadQueryParams extends ItemsCursorPostPaginationParams {
+  /**
+   * Body param: `ai_search` is a plain-language criterion evaluated against the
+   * messages from the agent trajectory scoped to the thread. AND-ed with the
+   * ordinary filters. Requires semantic filtering enabled for the deployment. Must
+   * contain nonempty text of at most 2000 UTF-8 bytes.
+   */
+  ai_search?: string;
+
   /**
    * Body param: `filter` narrows which threads are returned, using a LangSmith
    * filter expression evaluated against each thread's root run. For example:
@@ -1143,7 +1155,8 @@ export interface ThreadQueryParams 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;
 }