langsmith 0.7.10 → 0.7.12

package/dist/sandbox/mounts.js

@@ -1,10 +1,67 @@
-import { proxyConfig } from "./proxy_config.js";
 function requireNonEmptyString(value, field) {
     if (typeof value !== "string" || value.trim() === "") {
         throw new Error(`${field} must be a non-empty string`);
     }
     return value.trim();
 }
+function copyMountSecret(secret, field) {
+    if (secret === null || typeof secret !== "object" || Array.isArray(secret)) {
+        throw new Error(`${field} must be a sandbox secret`);
+    }
+    const candidate = secret;
+    if (candidate.type !== "workspace_secret" && candidate.type !== "opaque") {
+        throw new Error(`${field} must use workspace_secret or opaque`);
+    }
+    if (typeof candidate.value !== "string" || candidate.value.trim() === "") {
+        throw new Error(`${field}.value must be a non-empty string`);
+    }
+    return {
+        type: candidate.type,
+        value: candidate.value,
+    };
+}
+function requireGitRemoteUrl(remoteUrl) {
+    if (typeof remoteUrl !== "string" || remoteUrl === "") {
+        throw new Error("remoteUrl must be a non-empty string");
+    }
+    if (remoteUrl.trim() !== remoteUrl ||
+        /\s/u.test(remoteUrl) ||
+        remoteUrl.includes(String.fromCharCode(0))) {
+        throw new Error("remoteUrl must not contain whitespace or NUL bytes");
+    }
+    let parsed;
+    try {
+        parsed = new URL(remoteUrl);
+    }
+    catch {
+        throw new Error("remoteUrl must be an absolute HTTPS URL");
+    }
+    if (parsed.protocol !== "https:" || parsed.host === "") {
+        throw new Error("remoteUrl must be an absolute HTTPS URL");
+    }
+    if (parsed.username !== "" || parsed.password !== "") {
+        throw new Error("remoteUrl must not include embedded credentials");
+    }
+    if (parsed.pathname === "" || parsed.pathname === "/") {
+        throw new Error("remoteUrl must include a repository path");
+    }
+    if (parsed.search !== "" || parsed.hash !== "") {
+        throw new Error("remoteUrl must not include query or fragment");
+    }
+    return remoteUrl;
+}
+function copyGitRef(ref) {
+    if (ref === null || typeof ref !== "object" || Array.isArray(ref)) {
+        throw new Error("ref must be an object");
+    }
+    if (ref.type !== "branch" && ref.type !== "tag") {
+        throw new Error("ref.type must be branch or tag");
+    }
+    return {
+        type: ref.type,
+        name: requireNonEmptyString(ref.name, "ref.name"),
+    };
+}
 export function s3Mount({ id, mountPath, bucket, region = "us-east-1", prefix, endpointUrl = "https://s3.amazonaws.com", pathStyle = false, readOnly, cache, }) {
     const mount = {
         id: requireNonEmptyString(id, "id"),
@@ -28,6 +85,26 @@ export function s3Mount({ id, mountPath, bucket, region = "us-east-1", prefix, e
     }
     return mount;
 }
+export function gitMount({ id, mountPath, remoteUrl, ref, refreshIntervalSeconds, }) {
+    const mount = {
+        id: requireNonEmptyString(id, "id"),
+        type: "git",
+        mount_path: requireNonEmptyString(mountPath, "mountPath"),
+        git: {
+            remote_url: requireGitRemoteUrl(remoteUrl),
+        },
+    };
+    if (ref !== undefined) {
+        mount.git.ref = copyGitRef(ref);
+    }
+    if (refreshIntervalSeconds !== undefined) {
+        if (refreshIntervalSeconds < 1) {
+            throw new Error("refreshIntervalSeconds must be at least 1");
+        }
+        mount.git.refresh_interval_seconds = refreshIntervalSeconds;
+    }
+    return mount;
+}
 export function gcsMount({ id, mountPath, bucket, prefix, readOnly, cache, }) {
     const mount = {
         id: requireNonEmptyString(id, "id"),
@@ -56,35 +133,80 @@ function normalizeMounts(mounts) {
         if (mount === null || typeof mount !== "object" || Array.isArray(mount)) {
             throw new Error("mounts must be a non-empty array of mount objects");
         }
-        if (mount.type !== "s3" && mount.type !== "gcs") {
-            throw new Error("mountConfig only supports s3 and gcs mounts");
+        if (mount.type !== "s3" && mount.type !== "gcs" && mount.type !== "git") {
+            throw new Error("mountConfig only supports s3, gcs, and git mounts");
         }
+        rejectProviderCredentialsInMount(mount);
         return mount;
     });
 }
-function normalizeAuthRules(auth) {
+const FORBIDDEN_MOUNT_CREDENTIAL_FIELDS = new Set([
+    "access_key_id",
+    "secret_access_key",
+    "session_token",
+    "service_account_json",
+    "access_token",
+    "refresh_token",
+    "credentials",
+    "credential",
+]);
+function rejectProviderCredentialsInMount(value) {
+    if (Array.isArray(value)) {
+        for (const child of value) {
+            rejectProviderCredentialsInMount(child);
+        }
+        return;
+    }
+    if (value !== null && typeof value === "object") {
+        for (const [key, child] of Object.entries(value)) {
+            if (FORBIDDEN_MOUNT_CREDENTIAL_FIELDS.has(key)) {
+                throw new Error("provider credentials must be supplied in mountConfig.auth, not individual mount specs");
+            }
+            rejectProviderCredentialsInMount(child);
+        }
+    }
+}
+function normalizeMountAuth(auth) {
     if (!Array.isArray(auth)) {
-        throw new Error("auth must be an array of provider auth rules");
+        throw new Error("auth must be an array of provider auth blocks");
     }
     const byProvider = {};
-    for (const rule of auth) {
-        if (rule === null || typeof rule !== "object" || Array.isArray(rule)) {
-            throw new Error("auth must be an array of provider auth rules");
+    for (const block of auth) {
+        if (block === null || typeof block !== "object" || Array.isArray(block)) {
+            throw new Error("auth must be an array of provider auth blocks");
         }
-        const provider = rule.type;
+        const provider = block.type;
         if (provider !== "aws" && provider !== "gcp") {
-            throw new Error("mountConfig auth only supports aws and gcp rules");
+            throw new Error("mountConfig auth only supports aws and gcp blocks");
         }
         if (byProvider[provider] !== undefined) {
             throw new Error(`duplicate ${provider} auth rule in mountConfig`);
         }
-        byProvider[provider] = rule;
+        if (provider === "aws") {
+            const aws = block.aws;
+            if (aws === undefined) {
+                throw new Error("aws mount auth must include an aws block");
+            }
+            byProvider.aws = {
+                access_key_id: copyMountSecret(aws.access_key_id, "accessKeyId"),
+                secret_access_key: copyMountSecret(aws.secret_access_key, "secretAccessKey"),
+            };
+        }
+        else {
+            const gcp = block.gcp;
+            if (gcp === undefined) {
+                throw new Error("gcp mount auth must include a gcp block");
+            }
+            byProvider.gcp = {
+                service_account_json: copyMountSecret(gcp.service_account_json, "serviceAccountJson"),
+            };
+        }
     }
     return byProvider;
 }
-export function mountConfig({ auth, mounts, }) {
+export function mountConfig({ auth = [], mounts, }) {
     const normalizedMounts = normalizeMounts(mounts);
-    const authByProvider = normalizeAuthRules(auth);
+    const authByProvider = normalizeMountAuth(auth);
     const mountProviders = new Set(normalizedMounts.map((mount) => mount.type));
     if (mountProviders.has("s3") && authByProvider.aws === undefined) {
         throw new Error("s3 mounts require aws auth in mountConfig");
@@ -99,11 +221,26 @@ export function mountConfig({ auth, mounts, }) {
         throw new Error("gcp auth requires at least one gcs mount in mountConfig");
     }
     return {
+        auth: authByProvider,
         mounts: normalizedMounts,
-        proxyConfig: proxyConfig({
-            rules: ["aws", "gcp"]
-                .map((provider) => authByProvider[provider])
-                .filter((rule) => rule !== undefined),
-        }),
     };
 }
+export function validateMountConfigProxyConfig(mountConfig, proxyConfig) {
+    if (proxyConfig === undefined) {
+        return;
+    }
+    const rules = proxyConfig.rules ?? [];
+    if (!Array.isArray(rules)) {
+        throw new Error("proxyConfig rules must be an array");
+    }
+    for (const rule of rules) {
+        if (rule === null || typeof rule !== "object" || Array.isArray(rule)) {
+            continue;
+        }
+        const ruleType = rule.type;
+        if ((ruleType === "aws" || ruleType === "gcp") &&
+            mountConfig.auth[ruleType] !== undefined) {
+            throw new Error(`${ruleType} auth cannot be provided in both mountConfig and proxyConfig`);
+        }
+    }
+}

package/dist/sandbox/proxy_config.cjs

@@ -3,14 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.workspaceSecret = workspaceSecret;
 exports.opaqueSecret = opaqueSecret;
 exports.proxyConfig = proxyConfig;
-exports.mergeProxyConfigs = mergeProxyConfigs;
 exports.awsAuth = awsAuth;
 exports.gcpAuth = gcpAuth;
-const DEFAULT_GCP_AUTH_MATCH_HOSTS = [
-    "storage.googleapis.com",
-    "www.googleapis.com",
-];
-const PROVIDER_RULE_TYPES = new Set(["aws", "gcp"]);
 function requireNonEmptyString(value, field) {
     if (typeof value !== "string" || value.trim() === "") {
         throw new Error(`${field} must be a non-empty string`);
@@ -34,9 +28,20 @@ function requireProxyRules(rules) {
         if (rule === null || typeof rule !== "object" || Array.isArray(rule)) {
             throw new Error("rules must be an array of proxy rule objects");
         }
+        validateProxyProviderRule(rule);
         return rule;
     });
 }
+function validateProxyProviderRule(rule) {
+    if (rule.type !== "gcp") {
+        return;
+    }
+    const gcp = rule.gcp;
+    if (gcp === undefined || gcp.scopes === undefined) {
+        throw new Error("gcp proxy auth rules require scopes");
+    }
+    requireNonEmptyStringArray(gcp.scopes, "scopes");
+}
 /** Reference a LangSmith workspace secret in a sandbox proxy configuration. */
 function workspaceSecret(name) {
     const normalized = requireNonEmptyString(name, "name");
@@ -73,38 +78,6 @@ function proxyConfig({ rules, noProxy, accessControl, } = {}) {
     }
     return config;
 }
-function providerRuleTypes(config) {
-    const providers = new Set();
-    for (const rule of config.rules ?? []) {
-        if (rule === null || typeof rule !== "object" || Array.isArray(rule)) {
-            continue;
-        }
-        const ruleType = rule.type;
-        if (typeof ruleType === "string" && PROVIDER_RULE_TYPES.has(ruleType)) {
-            providers.add(ruleType);
-        }
-    }
-    return providers;
-}
-function mergeProxyConfigs(generatedConfig, explicitConfig) {
-    if (generatedConfig === undefined) {
-        return explicitConfig;
-    }
-    if (explicitConfig === undefined) {
-        return generatedConfig;
-    }
-    const generatedProviders = providerRuleTypes(generatedConfig);
-    for (const provider of providerRuleTypes(explicitConfig)) {
-        if (generatedProviders.has(provider)) {
-            throw new Error(`${provider} auth cannot be provided in both mountConfig and proxyConfig`);
-        }
-    }
-    return {
-        ...generatedConfig,
-        ...explicitConfig,
-        rules: [...(generatedConfig.rules ?? []), ...(explicitConfig.rules ?? [])],
-    };
-}
 /** Build a sandbox proxy rule that signs AWS HTTPS requests with SigV4. */
 function awsAuth({ accessKeyId, secretAccessKey, name = "aws", enabled = true, }) {
     return {
@@ -118,15 +91,17 @@ function awsAuth({ accessKeyId, secretAccessKey, name = "aws", enabled = true, }
     };
 }
 /** Build a sandbox proxy rule that injects GCP OAuth bearer auth. */
-function gcpAuth({ serviceAccountJson, scopes, matchHosts = DEFAULT_GCP_AUTH_MATCH_HOSTS, name = "gcp", enabled = true, }) {
+function gcpAuth({ serviceAccountJson, scopes, name = "gcp", enabled = true, }) {
+    const gcp = {
+        service_account_json: serviceAccountJson,
+    };
+    if (scopes !== undefined) {
+        gcp.scopes = requireNonEmptyStringArray(scopes, "scopes");
+    }
     return {
         name: requireNonEmptyString(name, "name"),
         type: "gcp",
         enabled,
-        match_hosts: requireNonEmptyStringArray(matchHosts, "matchHosts"),
-        gcp: {
-            service_account_json: serviceAccountJson,
-            scopes: requireNonEmptyStringArray(scopes, "scopes"),
-        },
+        gcp,
     };
 }

package/dist/sandbox/proxy_config.d.ts

@@ -9,7 +9,6 @@ export declare function proxyConfig({ rules, noProxy, accessControl, }?: {
     noProxy?: string[];
     accessControl?: SandboxAccessControl;
 }): SandboxProxyConfig;
-export declare function mergeProxyConfigs(generatedConfig: SandboxProxyConfig | undefined, explicitConfig: SandboxProxyConfig | undefined): SandboxProxyConfig | undefined;
 /** Build a sandbox proxy rule that signs AWS HTTPS requests with SigV4. */
 export declare function awsAuth({ accessKeyId, secretAccessKey, name, enabled, }: {
     accessKeyId: SandboxProxySecret;
@@ -18,10 +17,9 @@ export declare function awsAuth({ accessKeyId, secretAccessKey, name, enabled, }
     enabled?: boolean;
 }): SandboxAwsAuthRule;
 /** Build a sandbox proxy rule that injects GCP OAuth bearer auth. */
-export declare function gcpAuth({ serviceAccountJson, scopes, matchHosts, name, enabled, }: {
+export declare function gcpAuth({ serviceAccountJson, scopes, name, enabled, }: {
     serviceAccountJson: SandboxProxySecret;
-    scopes: string[];
-    matchHosts?: string[];
+    scopes?: string[];
     name?: string;
     enabled?: boolean;
 }): SandboxGcpAuthRule;

package/dist/sandbox/proxy_config.js

@@ -1,8 +1,3 @@
-const DEFAULT_GCP_AUTH_MATCH_HOSTS = [
-    "storage.googleapis.com",
-    "www.googleapis.com",
-];
-const PROVIDER_RULE_TYPES = new Set(["aws", "gcp"]);
 function requireNonEmptyString(value, field) {
     if (typeof value !== "string" || value.trim() === "") {
         throw new Error(`${field} must be a non-empty string`);
@@ -26,9 +21,20 @@ function requireProxyRules(rules) {
         if (rule === null || typeof rule !== "object" || Array.isArray(rule)) {
             throw new Error("rules must be an array of proxy rule objects");
         }
+        validateProxyProviderRule(rule);
         return rule;
     });
 }
+function validateProxyProviderRule(rule) {
+    if (rule.type !== "gcp") {
+        return;
+    }
+    const gcp = rule.gcp;
+    if (gcp === undefined || gcp.scopes === undefined) {
+        throw new Error("gcp proxy auth rules require scopes");
+    }
+    requireNonEmptyStringArray(gcp.scopes, "scopes");
+}
 /** Reference a LangSmith workspace secret in a sandbox proxy configuration. */
 export function workspaceSecret(name) {
     const normalized = requireNonEmptyString(name, "name");
@@ -65,38 +71,6 @@ export function proxyConfig({ rules, noProxy, accessControl, } = {}) {
     }
     return config;
 }
-function providerRuleTypes(config) {
-    const providers = new Set();
-    for (const rule of config.rules ?? []) {
-        if (rule === null || typeof rule !== "object" || Array.isArray(rule)) {
-            continue;
-        }
-        const ruleType = rule.type;
-        if (typeof ruleType === "string" && PROVIDER_RULE_TYPES.has(ruleType)) {
-            providers.add(ruleType);
-        }
-    }
-    return providers;
-}
-export function mergeProxyConfigs(generatedConfig, explicitConfig) {
-    if (generatedConfig === undefined) {
-        return explicitConfig;
-    }
-    if (explicitConfig === undefined) {
-        return generatedConfig;
-    }
-    const generatedProviders = providerRuleTypes(generatedConfig);
-    for (const provider of providerRuleTypes(explicitConfig)) {
-        if (generatedProviders.has(provider)) {
-            throw new Error(`${provider} auth cannot be provided in both mountConfig and proxyConfig`);
-        }
-    }
-    return {
-        ...generatedConfig,
-        ...explicitConfig,
-        rules: [...(generatedConfig.rules ?? []), ...(explicitConfig.rules ?? [])],
-    };
-}
 /** Build a sandbox proxy rule that signs AWS HTTPS requests with SigV4. */
 export function awsAuth({ accessKeyId, secretAccessKey, name = "aws", enabled = true, }) {
     return {
@@ -110,15 +84,17 @@ export function awsAuth({ accessKeyId, secretAccessKey, name = "aws", enabled =
     };
 }
 /** Build a sandbox proxy rule that injects GCP OAuth bearer auth. */
-export function gcpAuth({ serviceAccountJson, scopes, matchHosts = DEFAULT_GCP_AUTH_MATCH_HOSTS, name = "gcp", enabled = true, }) {
+export function gcpAuth({ serviceAccountJson, scopes, name = "gcp", enabled = true, }) {
+    const gcp = {
+        service_account_json: serviceAccountJson,
+    };
+    if (scopes !== undefined) {
+        gcp.scopes = requireNonEmptyStringArray(scopes, "scopes");
+    }
     return {
         name: requireNonEmptyString(name, "name"),
         type: "gcp",
         enabled,
-        match_hosts: requireNonEmptyStringArray(matchHosts, "matchHosts"),
-        gcp: {
-            service_account_json: serviceAccountJson,
-            scopes: requireNonEmptyStringArray(scopes, "scopes"),
-        },
+        gcp,
     };
 }

package/dist/sandbox/types.d.ts

@@ -280,16 +280,14 @@ export interface SandboxAwsAuthRule {
 export interface SandboxGcpAuthRule {
     /** Rule name. */
     name: string;
-    /** GCP auth rules match explicit Google API host patterns. */
+    /** GCP auth rules use the sandbox proxy's built-in Google API host matcher. */
     type: "gcp";
     /** Whether the rule is enabled. */
     enabled?: boolean;
-    /** Google API hosts covered by this rule, such as storage.googleapis.com. */
-    match_hosts: string[];
     /** GCP service-account credential and OAuth scopes. */
     gcp: {
         service_account_json: SandboxProxySecret;
-        scopes: string[];
+        scopes?: string[];
     };
 }
 /** Proxy rule accepted by the sandbox proxy config. */
@@ -307,14 +305,14 @@ export interface SandboxProxyConfig {
     /** Allow/deny list enforced at the proxy sidecar. */
     access_control?: SandboxAccessControl;
 }
-/** Optional per-mount cache configuration supported by all mount providers. */
+/** Optional per-mount cache configuration supported by bucket mounts. */
 export interface MountCacheConfig {
     /** Maximum VFS cache size in bytes. */
     max_size_bytes?: number;
     /** Seconds rclone waits before writing cached changes back. */
     writeback_seconds?: number;
 }
-interface SandboxMountBase {
+interface SandboxBucketMountBase {
     /** Stable mount identifier. */
     id: string;
     /** Absolute path inside the sandbox where the mount appears. */
@@ -341,7 +339,7 @@ export interface S3MountConfig {
     path_style?: boolean;
 }
 /** S3-backed sandbox mount specification. */
-export interface S3MountSpec extends SandboxMountBase {
+export interface S3MountSpec extends SandboxBucketMountBase {
     /** Mount type. */
     type: "s3";
     /** S3 mount configuration. */
@@ -355,20 +353,63 @@ export interface GCSMountConfig {
     prefix?: string;
 }
 /** GCS-backed sandbox mount specification. */
-export interface GCSMountSpec extends SandboxMountBase {
+export interface GCSMountSpec extends SandboxBucketMountBase {
     /** Mount type. */
     type: "gcs";
     /** GCS mount configuration. */
     gcs: GCSMountConfig;
 }
+/** Git ref selected for a sandbox mount. */
+export interface GitMountRefSpec {
+    /** Git ref type. */
+    type: "branch" | "tag";
+    /** Branch or tag name. */
+    name: string;
+}
+/** Git configuration for a sandbox mount. */
+export interface GitMountConfig {
+    /** Public HTTPS Git remote URL. */
+    remote_url: string;
+    /** Optional branch or tag to mount. */
+    ref?: GitMountRefSpec;
+    /** Optional refresh interval for polling the remote. */
+    refresh_interval_seconds?: number;
+}
+/** Git-backed sandbox mount specification. */
+export interface GitMountSpec {
+    /** Stable mount identifier. */
+    id: string;
+    /** Mount type. */
+    type: "git";
+    /** Absolute path inside the sandbox where the mount appears. */
+    mount_path: string;
+    /** Git mount configuration. */
+    git: GitMountConfig;
+}
 /** Sandbox mount specification. */
-export type SandboxMount = S3MountSpec | GCSMountSpec;
-/** SDK-level mount config expanded into backend mounts and proxyConfig. */
+export type SandboxMount = S3MountSpec | GCSMountSpec | GitMountSpec;
+/** AWS credentials used by the backend to authenticate S3 mounts. */
+export interface SandboxAwsMountAuthConfig {
+    access_key_id: SandboxProxySecret;
+    secret_access_key: SandboxProxySecret;
+}
+/** GCP credentials used by the backend to authenticate GCS mounts. */
+export interface SandboxGcpMountAuthConfig {
+    service_account_json: SandboxProxySecret;
+}
+/** Provider auth blocks for sandbox mounts. */
+export interface SandboxMountAuthConfig {
+    aws?: SandboxAwsMountAuthConfig;
+    gcp?: SandboxGcpMountAuthConfig;
+}
+/** Provider auth helper output accepted by mountConfig. */
+export type SandboxMountAuth = SandboxAwsAuthRule | SandboxGcpAuthRule;
+/** Public mount config sent to the sandbox API. */
 export interface SandboxMountConfig {
+    /** Provider auth blocks for bucket-backed mounts. */
+    auth: SandboxMountAuthConfig;
     /** Mounts attached to the sandbox. */
     mounts: SandboxMount[];
-    /** Proxy auth config required by the mounts. */
-    proxyConfig: SandboxProxyConfig;
 }
 /**
  * Options for creating a sandbox.
@@ -417,9 +458,9 @@ export interface CreateSandboxOptions {
     /** Root filesystem capacity in bytes. */
     fsCapacityBytes?: number;
     /**
-     * High-level mount configuration. The SDK expands it into backend `mounts`
-     * and `proxy_config` fields. If `proxyConfig` is also provided, its rules are
-     * merged with the mount-generated proxy auth rules.
+     * Mount configuration forwarded to the server as `mount_config`. The backend
+     * expands mount auth into runtime proxy rules. Explicit AWS/GCP proxy rules
+     * in `proxyConfig` conflict with mount auth for the same provider.
      */
     mountConfig?: SandboxMountConfig;
     /**

package/dist/utils/constants.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._MIN_BACKEND_VERSION = void 0;
+exports._MIN_BACKEND_VERSION = "0.16.6rc1";

package/dist/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const _MIN_BACKEND_VERSION = "0.16.6rc1";

package/dist/utils/constants.js

@@ -0,0 +1 @@
+export const _MIN_BACKEND_VERSION = "0.16.6rc1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.7.10",
+  "version": "0.7.12",
   "description": "Client library to connect to the LangSmith Observability and Evaluation Platform.",
   "packageManager": "pnpm@10.33.0",
   "files": [
@@ -156,9 +156,9 @@
     "p-queue": "6.6.2"
   },
   "devDependencies": {
-    "@ai-sdk/openai": "4.0.0-canary.59",
-    "@ai-sdk/provider": "4.0.0-canary.16",
-    "@ai-sdk/anthropic": "4.0.0-canary.55",
+    "@ai-sdk/openai": "4.0.0-beta.74",
+    "@ai-sdk/provider": "4.0.0-beta.19",
+    "@ai-sdk/anthropic": "4.0.0-beta.67",
     "@anthropic-ai/claude-agent-sdk": "^0.3.150",
     "@anthropic-ai/sdk": "^0.98.0",
     "@babel/preset-env": "^7.22.4",
@@ -184,7 +184,7 @@
     "@types/ws": "^8.18.1",
     "@typescript-eslint/eslint-plugin": "^5.59.8",
     "@typescript-eslint/parser": "^5.59.8",
-    "ai": "7.0.0-canary.142",
+    "ai": "7.0.0-beta.178",
     "babel-jest": "^30.2.0",
     "cross-env": "^10.1.0",
     "dotenv": "^17.3.1",