langsmith 0.6.0 → 0.6.1

package/dist/utils/profiles.cjs

@@ -0,0 +1,292 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileAuth = exports.DEFAULT_API_URL = void 0;
+exports.hasValue = hasValue;
+exports.loadProfileClientConfig = loadProfileClientConfig;
+const env_js_1 = require("./env.cjs");
+const fsUtils = __importStar(require("./fs.cjs"));
+exports.DEFAULT_API_URL = "https://api.smith.langchain.com";
+const OAUTH_CLIENT_ID = "langsmith-cli";
+const TOKEN_REFRESH_LEEWAY_MS = 60_000;
+const TOKEN_REFRESH_TIMEOUT_MS = 10_000;
+function isBrowserLikeRuntime() {
+    const env = (0, env_js_1.getEnv)();
+    return env === "browser" || env === "webworker";
+}
+function getProfileConfigPath() {
+    const explicitPath = (0, env_js_1.getEnvironmentVariable)("LANGSMITH_CONFIG_FILE");
+    if (explicitPath) {
+        return explicitPath;
+    }
+    const home = (0, env_js_1.getEnvironmentVariable)("HOME") ?? (0, env_js_1.getEnvironmentVariable)("USERPROFILE");
+    if (!home) {
+        return undefined;
+    }
+    return fsUtils.path.join(home, ".langsmith", "config.json");
+}
+function resolveProfileName(config) {
+    const envProfile = (0, env_js_1.getEnvironmentVariable)("LANGSMITH_PROFILE");
+    if (envProfile) {
+        return envProfile;
+    }
+    if (config.current_profile) {
+        return config.current_profile;
+    }
+    if (config.profiles?.default) {
+        return "default";
+    }
+    return undefined;
+}
+function loadProfileState() {
+    if (isBrowserLikeRuntime()) {
+        return undefined;
+    }
+    const configPath = getProfileConfigPath();
+    if (!configPath || !fsUtils.existsSync(configPath)) {
+        return undefined;
+    }
+    try {
+        const config = JSON.parse(fsUtils.readFileSync(configPath));
+        const profileName = resolveProfileName(config);
+        const profile = profileName ? config.profiles?.[profileName] : undefined;
+        if (!profileName || !profile) {
+            return undefined;
+        }
+        return { configPath, config, profileName, profile };
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasValue(value) {
+    return value !== undefined && value !== null && value.trim() !== "";
+}
+function trimConfigValue(value) {
+    return value?.trim().replace(/^["']|["']$/g, "");
+}
+function shouldRefreshProfileToken(profile) {
+    const oauth = profile.oauth;
+    if (!oauth?.refresh_token) {
+        return false;
+    }
+    if (!oauth.access_token) {
+        return true;
+    }
+    if (!oauth.expires_at) {
+        return false;
+    }
+    const expiresAt = Date.parse(oauth.expires_at);
+    if (Number.isNaN(expiresAt)) {
+        return false;
+    }
+    return expiresAt <= Date.now() + TOKEN_REFRESH_LEEWAY_MS;
+}
+function normalizeConfigUrl(apiUrl) {
+    let normalized = apiUrl;
+    while (normalized.endsWith("/")) {
+        normalized = normalized.slice(0, -1);
+    }
+    const apiV1Suffix = "/api/v1";
+    return normalized.endsWith(apiV1Suffix)
+        ? normalized.slice(0, -apiV1Suffix.length)
+        : normalized;
+}
+function applyTokenResponse(profile, token) {
+    profile.oauth ??= {};
+    if (token.access_token) {
+        profile.oauth.access_token = token.access_token;
+    }
+    if (token.refresh_token) {
+        profile.oauth.refresh_token = token.refresh_token;
+    }
+    if (typeof token.expires_in === "number" && token.expires_in > 0) {
+        profile.oauth.expires_at = new Date(Date.now() + token.expires_in * 1000).toISOString();
+    }
+}
+function getAbortReason(signal) {
+    return (signal.reason ??
+        new Error("The operation was aborted."));
+}
+async function waitForAbortSignal(promise, signal) {
+    if (!signal) {
+        return promise;
+    }
+    if (signal.aborted) {
+        throw getAbortReason(signal);
+    }
+    let cleanup;
+    const abortPromise = new Promise((_, reject) => {
+        const onAbort = () => {
+            reject(getAbortReason(signal));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        cleanup = () => {
+            signal.removeEventListener("abort", onAbort);
+        };
+    });
+    try {
+        return await Promise.race([promise, abortPromise]);
+    }
+    finally {
+        cleanup?.();
+    }
+}
+function loadProfileClientConfig() {
+    const state = loadProfileState();
+    const profile = state?.profile;
+    if (!state || !profile) {
+        return {};
+    }
+    const apiKey = trimConfigValue(profile.api_key);
+    const oauthAccessToken = trimConfigValue(profile.oauth?.access_token);
+    const oauthRefreshToken = trimConfigValue(profile.oauth?.refresh_token);
+    return {
+        apiUrl: profile.api_url,
+        apiKey,
+        workspaceId: profile.workspace_id,
+        oauthAccessToken,
+        oauthRefreshToken,
+        profileAuth: apiKey || oauthAccessToken || oauthRefreshToken
+            ? new ProfileAuth(state)
+            : undefined,
+    };
+}
+class ProfileAuth {
+    constructor(state) {
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: state
+        });
+        Object.defineProperty(this, "refreshPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "managedAuthorizationValue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.rememberProfileAuthHeader(this.currentAuthHeader());
+    }
+    currentAuthHeader() {
+        const header = currentAuthHeaderFromProfile(this.state.profile);
+        this.rememberProfileAuthHeader(header);
+        return header;
+    }
+    async getAuthHeader(fetchImplementation, signal) {
+        if (shouldRefreshProfileToken(this.state.profile)) {
+            if (!this.refreshPromise) {
+                this.refreshPromise = this.refreshOAuthToken(fetchImplementation).finally(() => {
+                    this.refreshPromise = undefined;
+                });
+            }
+            await waitForAbortSignal(this.refreshPromise, signal);
+        }
+        const header = authHeaderFromProfile(this.state.profile);
+        this.rememberProfileAuthHeader(header);
+        return header;
+    }
+    isProfileAuthorizationHeader(value) {
+        return value === this.managedAuthorizationValue;
+    }
+    async refreshOAuthToken(fetchImplementation) {
+        const refreshToken = this.state.profile.oauth?.refresh_token;
+        if (!refreshToken) {
+            return;
+        }
+        const refreshApiUrl = trimConfigValue(this.state.profile.api_url) ?? exports.DEFAULT_API_URL;
+        try {
+            const body = new URLSearchParams({
+                grant_type: "refresh_token",
+                client_id: OAUTH_CLIENT_ID,
+                refresh_token: refreshToken,
+            });
+            const response = await fetchImplementation(`${normalizeConfigUrl(refreshApiUrl)}/oauth/token`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: body.toString(),
+                signal: AbortSignal.timeout(TOKEN_REFRESH_TIMEOUT_MS),
+            });
+            if (!response.ok) {
+                return;
+            }
+            const token = (await response.json());
+            if (!token.access_token) {
+                return;
+            }
+            applyTokenResponse(this.state.profile, token);
+            this.state.config.profiles ??= {};
+            this.state.config.profiles[this.state.profileName] = this.state.profile;
+            await fsUtils.writeFileAtomic(this.state.configPath, `${JSON.stringify(this.state.config, null, 2)}\n`);
+        }
+        catch {
+            return;
+        }
+    }
+    rememberProfileAuthHeader(header) {
+        this.managedAuthorizationValue =
+            header?.name === "Authorization" ? header.value : undefined;
+    }
+}
+exports.ProfileAuth = ProfileAuth;
+function currentAuthHeaderFromProfile(profile) {
+    const oauthAccessToken = trimConfigValue(profile.oauth?.access_token);
+    if (oauthAccessToken) {
+        return { name: "Authorization", value: `Bearer ${oauthAccessToken}` };
+    }
+    if (trimConfigValue(profile.oauth?.refresh_token)) {
+        return undefined;
+    }
+    return authHeaderFromProfile(profile);
+}
+function authHeaderFromProfile(profile) {
+    const oauthAccessToken = trimConfigValue(profile.oauth?.access_token);
+    if (oauthAccessToken) {
+        return { name: "Authorization", value: `Bearer ${oauthAccessToken}` };
+    }
+    const apiKey = trimConfigValue(profile.api_key);
+    if (apiKey) {
+        return { name: "x-api-key", value: apiKey };
+    }
+    return undefined;
+}

package/dist/utils/profiles.d.ts

@@ -0,0 +1,48 @@
+export declare const DEFAULT_API_URL = "https://api.smith.langchain.com";
+type LangSmithProfileOAuth = {
+    access_token?: string;
+    refresh_token?: string;
+    expires_at?: string;
+};
+type LangSmithProfile = {
+    api_key?: string;
+    api_url?: string;
+    workspace_id?: string;
+    oauth?: LangSmithProfileOAuth;
+};
+type LangSmithProfileConfigFile = {
+    current_profile?: string;
+    profiles?: Record<string, LangSmithProfile>;
+};
+type LangSmithProfileState = {
+    configPath: string;
+    config: LangSmithProfileConfigFile;
+    profileName: string;
+    profile: LangSmithProfile;
+};
+export type ProfileAuthHeader = {
+    name: "Authorization" | "x-api-key";
+    value: string;
+};
+export type ProfileClientConfig = {
+    apiUrl?: string;
+    apiKey?: string;
+    workspaceId?: string;
+    oauthAccessToken?: string;
+    oauthRefreshToken?: string;
+    profileAuth?: ProfileAuth;
+};
+export declare function hasValue(value?: string | null): boolean;
+export declare function loadProfileClientConfig(): ProfileClientConfig;
+export declare class ProfileAuth {
+    private state;
+    private refreshPromise?;
+    private managedAuthorizationValue?;
+    constructor(state: LangSmithProfileState);
+    currentAuthHeader(): ProfileAuthHeader | undefined;
+    getAuthHeader(fetchImplementation: typeof fetch, signal?: AbortSignal | null): Promise<ProfileAuthHeader | undefined>;
+    isProfileAuthorizationHeader(value: string): boolean;
+    private refreshOAuthToken;
+    private rememberProfileAuthHeader;
+}
+export {};

package/dist/utils/profiles.js

@@ -0,0 +1,253 @@
+import { getEnv, getEnvironmentVariable } from "./env.js";
+import * as fsUtils from "./fs.js";
+export const DEFAULT_API_URL = "https://api.smith.langchain.com";
+const OAUTH_CLIENT_ID = "langsmith-cli";
+const TOKEN_REFRESH_LEEWAY_MS = 60_000;
+const TOKEN_REFRESH_TIMEOUT_MS = 10_000;
+function isBrowserLikeRuntime() {
+    const env = getEnv();
+    return env === "browser" || env === "webworker";
+}
+function getProfileConfigPath() {
+    const explicitPath = getEnvironmentVariable("LANGSMITH_CONFIG_FILE");
+    if (explicitPath) {
+        return explicitPath;
+    }
+    const home = getEnvironmentVariable("HOME") ?? getEnvironmentVariable("USERPROFILE");
+    if (!home) {
+        return undefined;
+    }
+    return fsUtils.path.join(home, ".langsmith", "config.json");
+}
+function resolveProfileName(config) {
+    const envProfile = getEnvironmentVariable("LANGSMITH_PROFILE");
+    if (envProfile) {
+        return envProfile;
+    }
+    if (config.current_profile) {
+        return config.current_profile;
+    }
+    if (config.profiles?.default) {
+        return "default";
+    }
+    return undefined;
+}
+function loadProfileState() {
+    if (isBrowserLikeRuntime()) {
+        return undefined;
+    }
+    const configPath = getProfileConfigPath();
+    if (!configPath || !fsUtils.existsSync(configPath)) {
+        return undefined;
+    }
+    try {
+        const config = JSON.parse(fsUtils.readFileSync(configPath));
+        const profileName = resolveProfileName(config);
+        const profile = profileName ? config.profiles?.[profileName] : undefined;
+        if (!profileName || !profile) {
+            return undefined;
+        }
+        return { configPath, config, profileName, profile };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function hasValue(value) {
+    return value !== undefined && value !== null && value.trim() !== "";
+}
+function trimConfigValue(value) {
+    return value?.trim().replace(/^["']|["']$/g, "");
+}
+function shouldRefreshProfileToken(profile) {
+    const oauth = profile.oauth;
+    if (!oauth?.refresh_token) {
+        return false;
+    }
+    if (!oauth.access_token) {
+        return true;
+    }
+    if (!oauth.expires_at) {
+        return false;
+    }
+    const expiresAt = Date.parse(oauth.expires_at);
+    if (Number.isNaN(expiresAt)) {
+        return false;
+    }
+    return expiresAt <= Date.now() + TOKEN_REFRESH_LEEWAY_MS;
+}
+function normalizeConfigUrl(apiUrl) {
+    let normalized = apiUrl;
+    while (normalized.endsWith("/")) {
+        normalized = normalized.slice(0, -1);
+    }
+    const apiV1Suffix = "/api/v1";
+    return normalized.endsWith(apiV1Suffix)
+        ? normalized.slice(0, -apiV1Suffix.length)
+        : normalized;
+}
+function applyTokenResponse(profile, token) {
+    profile.oauth ??= {};
+    if (token.access_token) {
+        profile.oauth.access_token = token.access_token;
+    }
+    if (token.refresh_token) {
+        profile.oauth.refresh_token = token.refresh_token;
+    }
+    if (typeof token.expires_in === "number" && token.expires_in > 0) {
+        profile.oauth.expires_at = new Date(Date.now() + token.expires_in * 1000).toISOString();
+    }
+}
+function getAbortReason(signal) {
+    return (signal.reason ??
+        new Error("The operation was aborted."));
+}
+async function waitForAbortSignal(promise, signal) {
+    if (!signal) {
+        return promise;
+    }
+    if (signal.aborted) {
+        throw getAbortReason(signal);
+    }
+    let cleanup;
+    const abortPromise = new Promise((_, reject) => {
+        const onAbort = () => {
+            reject(getAbortReason(signal));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        cleanup = () => {
+            signal.removeEventListener("abort", onAbort);
+        };
+    });
+    try {
+        return await Promise.race([promise, abortPromise]);
+    }
+    finally {
+        cleanup?.();
+    }
+}
+export function loadProfileClientConfig() {
+    const state = loadProfileState();
+    const profile = state?.profile;
+    if (!state || !profile) {
+        return {};
+    }
+    const apiKey = trimConfigValue(profile.api_key);
+    const oauthAccessToken = trimConfigValue(profile.oauth?.access_token);
+    const oauthRefreshToken = trimConfigValue(profile.oauth?.refresh_token);
+    return {
+        apiUrl: profile.api_url,
+        apiKey,
+        workspaceId: profile.workspace_id,
+        oauthAccessToken,
+        oauthRefreshToken,
+        profileAuth: apiKey || oauthAccessToken || oauthRefreshToken
+            ? new ProfileAuth(state)
+            : undefined,
+    };
+}
+export class ProfileAuth {
+    constructor(state) {
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: state
+        });
+        Object.defineProperty(this, "refreshPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "managedAuthorizationValue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.rememberProfileAuthHeader(this.currentAuthHeader());
+    }
+    currentAuthHeader() {
+        const header = currentAuthHeaderFromProfile(this.state.profile);
+        this.rememberProfileAuthHeader(header);
+        return header;
+    }
+    async getAuthHeader(fetchImplementation, signal) {
+        if (shouldRefreshProfileToken(this.state.profile)) {
+            if (!this.refreshPromise) {
+                this.refreshPromise = this.refreshOAuthToken(fetchImplementation).finally(() => {
+                    this.refreshPromise = undefined;
+                });
+            }
+            await waitForAbortSignal(this.refreshPromise, signal);
+        }
+        const header = authHeaderFromProfile(this.state.profile);
+        this.rememberProfileAuthHeader(header);
+        return header;
+    }
+    isProfileAuthorizationHeader(value) {
+        return value === this.managedAuthorizationValue;
+    }
+    async refreshOAuthToken(fetchImplementation) {
+        const refreshToken = this.state.profile.oauth?.refresh_token;
+        if (!refreshToken) {
+            return;
+        }
+        const refreshApiUrl = trimConfigValue(this.state.profile.api_url) ?? DEFAULT_API_URL;
+        try {
+            const body = new URLSearchParams({
+                grant_type: "refresh_token",
+                client_id: OAUTH_CLIENT_ID,
+                refresh_token: refreshToken,
+            });
+            const response = await fetchImplementation(`${normalizeConfigUrl(refreshApiUrl)}/oauth/token`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: body.toString(),
+                signal: AbortSignal.timeout(TOKEN_REFRESH_TIMEOUT_MS),
+            });
+            if (!response.ok) {
+                return;
+            }
+            const token = (await response.json());
+            if (!token.access_token) {
+                return;
+            }
+            applyTokenResponse(this.state.profile, token);
+            this.state.config.profiles ??= {};
+            this.state.config.profiles[this.state.profileName] = this.state.profile;
+            await fsUtils.writeFileAtomic(this.state.configPath, `${JSON.stringify(this.state.config, null, 2)}\n`);
+        }
+        catch {
+            return;
+        }
+    }
+    rememberProfileAuthHeader(header) {
+        this.managedAuthorizationValue =
+            header?.name === "Authorization" ? header.value : undefined;
+    }
+}
+function currentAuthHeaderFromProfile(profile) {
+    const oauthAccessToken = trimConfigValue(profile.oauth?.access_token);
+    if (oauthAccessToken) {
+        return { name: "Authorization", value: `Bearer ${oauthAccessToken}` };
+    }
+    if (trimConfigValue(profile.oauth?.refresh_token)) {
+        return undefined;
+    }
+    return authHeaderFromProfile(profile);
+}
+function authHeaderFromProfile(profile) {
+    const oauthAccessToken = trimConfigValue(profile.oauth?.access_token);
+    if (oauthAccessToken) {
+        return { name: "Authorization", value: `Bearer ${oauthAccessToken}` };
+    }
+    const apiKey = trimConfigValue(profile.api_key);
+    if (apiKey) {
+        return { name: "x-api-key", value: apiKey };
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Client library to connect to the LangSmith Observability and Evaluation Platform.",
   "packageManager": "pnpm@10.33.0",
   "files": [
@@ -101,10 +101,6 @@
     "experimental/sandbox.js",
     "experimental/sandbox.d.ts",
     "experimental/sandbox.d.cts",
-    "experimental/opencode.cjs",
-    "experimental/opencode.js",
-    "experimental/opencode.d.ts",
-    "experimental/opencode.d.cts",
     "index.cjs",
     "index.js",
     "index.d.ts",
@@ -459,15 +455,6 @@
       "import": "./experimental/sandbox.js",
       "require": "./experimental/sandbox.cjs"
     },
-    "./experimental/opencode": {
-      "types": {
-        "import": "./experimental/opencode.d.ts",
-        "require": "./experimental/opencode.d.cts",
-        "default": "./experimental/opencode.d.ts"
-      },
-      "import": "./experimental/opencode.js",
-      "require": "./experimental/opencode.cjs"
-    },
     "./package.json": "./package.json"
   },
   "pnpm": {

package/dist/experimental/opencode/index.cjs

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LangSmithPlugin = void 0;
-// import type { Plugin } from "@opencode-ai/plugin";
-const tracer_js_1 = require("./tracer.cjs");
-const LangSmithPlugin = async (ctx) => {
-    const tracer = new tracer_js_1.OpenCodeSessionTracer();
-    async function getSessionHistory(sessionID) {
-        const past = await ctx.client.session.messages({
-            path: { id: sessionID },
-        });
-        if (past.error)
-            throw past.error;
-        return past.data;
-    }
-    return {
-        "experimental.chat.system.transform": async (input, output) => {
-            const sessionID = input.sessionID;
-            if (!sessionID)
-                return;
-            await tracer.handleSessionLoad(sessionID, getSessionHistory);
-            await tracer.handleSystem(input, output);
-        },
-        event: async (input) => {
-            const sessionID = "sessionID" in input.event.properties &&
-                typeof input.event.properties.sessionID === "string"
-                ? input.event.properties.sessionID
-                : undefined;
-            if (!sessionID)
-                return;
-            await tracer.handleSessionLoad(sessionID, getSessionHistory);
-            await tracer.handleEvent(input);
-        },
-    };
-};
-exports.LangSmithPlugin = LangSmithPlugin;

package/dist/experimental/opencode/index.d.ts

@@ -1,3 +0,0 @@
-type Plugin = (ctx: any) => any;
-export declare const LangSmithPlugin: Plugin;
-export {};

package/dist/experimental/opencode/index.js

@@ -1,32 +0,0 @@
-// import type { Plugin } from "@opencode-ai/plugin";
-import { OpenCodeSessionTracer } from "./tracer.js";
-export const LangSmithPlugin = async (ctx) => {
-    const tracer = new OpenCodeSessionTracer();
-    async function getSessionHistory(sessionID) {
-        const past = await ctx.client.session.messages({
-            path: { id: sessionID },
-        });
-        if (past.error)
-            throw past.error;
-        return past.data;
-    }
-    return {
-        "experimental.chat.system.transform": async (input, output) => {
-            const sessionID = input.sessionID;
-            if (!sessionID)
-                return;
-            await tracer.handleSessionLoad(sessionID, getSessionHistory);
-            await tracer.handleSystem(input, output);
-        },
-        event: async (input) => {
-            const sessionID = "sessionID" in input.event.properties &&
-                typeof input.event.properties.sessionID === "string"
-                ? input.event.properties.sessionID
-                : undefined;
-            if (!sessionID)
-                return;
-            await tracer.handleSessionLoad(sessionID, getSessionHistory);
-            await tracer.handleEvent(input);
-        },
-    };
-};