@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/__tests__/gateway-threshold-reader-mock.ts

@@ -35,6 +35,8 @@ export interface ThresholdReaderMockState {
     executionContext?: string;
     cellQuery?: Record<string, unknown>;
   }>;
+  /** Resolved by `getContactAutoApproveThreshold`. */
+  contactThreshold: string | null;
   /** How many times the cell was looked up. */
   cellLookups: number;
 }
@@ -45,6 +47,7 @@ export const thresholdReaderMock: ThresholdReaderMockState = {
   cell: { ok: true, resolved: null },
   roomDefault: "low",
   thresholdReads: [],
+  contactThreshold: null,
   cellLookups: 0,
 };
 
@@ -58,6 +61,7 @@ export function resetThresholdReaderMock(): void {
   thresholdReaderMock.cell = { ok: true, resolved: null };
   thresholdReaderMock.roomDefault = "low";
   thresholdReaderMock.thresholdReads.length = 0;
+  thresholdReaderMock.contactThreshold = null;
   thresholdReaderMock.cellLookups = 0;
 }
 
@@ -81,6 +85,8 @@ export function installThresholdReaderMock(): void {
       return thresholdReaderMock.threshold;
     },
     refreshAutoApproveThreshold: async () => thresholdReaderMock.refreshed,
+    getContactAutoApproveThreshold: async () =>
+      thresholdReaderMock.contactThreshold,
     resolveChannelPermissionCell: async () => {
       thresholdReaderMock.cellLookups += 1;
       return thresholdReaderMock.cell;

package/src/__tests__/guardian-card-withdrawal.test.ts

@@ -14,6 +14,11 @@ mock.module("../messaging/providers/slack/withdraw.js", () => ({
   withdrawSlackApprovalCard,
 }));
 
+const withdrawDiscordApprovalCard = mock(async (_params: unknown) => undefined);
+mock.module("../messaging/providers/discord/withdraw.js", () => ({
+  withdrawDiscordApprovalCard,
+}));
+
 const withdrawTelegramApprovalCard = mock(
   async (_params: Record<string, unknown>) => {},
 );
@@ -68,6 +73,7 @@ describe("withdrawGuardianRequestCards", () => {
     markSurfaceCompleted.mockClear();
     withdrawSlackApprovalCard.mockClear();
     withdrawTelegramApprovalCard.mockClear();
+    withdrawDiscordApprovalCard.mockClear();
   });
 
   test("withdraws + broadcasts the in-app card when the decision came from another surface", async () => {
@@ -232,6 +238,30 @@ describe("withdrawGuardianRequestCards", () => {
     });
   });
 
+  test("withdraws the Discord card by rewriting it to the outcome", async () => {
+    const req = makeRequest({ sourceChannel: "discord" });
+    bridgeState.seedDelivery({
+      requestId: req.id,
+      destinationChannel: "discord",
+      destinationChatId: "111222333444555666",
+      destinationMessageId: "2001",
+    });
+
+    await withdrawGuardianRequestCards({
+      request: req,
+      status: "approved",
+      originChannel: "vellum",
+    });
+
+    expect(withdrawTelegramApprovalCard).not.toHaveBeenCalled();
+    expect(withdrawDiscordApprovalCard).toHaveBeenCalledTimes(1);
+    expect(withdrawDiscordApprovalCard).toHaveBeenCalledWith({
+      guardianUserId: "111222333444555666",
+      messageId: "2001",
+      status: "approved",
+    });
+  });
+
   test("suppresses the Telegram status reply only when the origin flow replies to the guardian", async () => {
     const req = makeRequest({ sourceChannel: "telegram" });
     bridgeState.seedDelivery({

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -101,8 +101,6 @@ describe("handleConfirmationResponse guardian status sync", () => {
       "req-confirm-allow",
       "allow",
       {
-        selectedPattern: undefined,
-        selectedScope: undefined,
         emissionContext: { source: "button" },
       },
     ]);

package/src/__tests__/image-conversion.test.ts

@@ -1,9 +1,8 @@
 /**
- * Tests for the shared sips-backed image converter.
+ * Tests for the shared cross-platform image converter.
  *
  * Pure logic (ftyp sniffing, filename rewriting, passthrough behavior) runs
- * everywhere; actual conversion requires macOS `sips`, so those cases are
- * gated on darwin.
+ * everywhere; macOS-specific HEIC fixture generation is gated on Darwin.
  */
 
 import { createHash } from "node:crypto";
@@ -151,6 +150,41 @@ describe("isCompleteJpeg", () => {
   });
 });
 
+describe("convertImageToJpeg", () => {
+  test("converts PNG input with the cross-platform encoder", async () => {
+    const converted = await convertImageToJpeg(PNG_1PX_BYTES, {
+      resizeToPx: { width: 2, height: 2 },
+      quality: 82,
+    });
+
+    expect(converted).not.toBeNull();
+    expect(isCompleteJpeg(converted!)).toBe(true);
+    expect(hasValidJpegStructure(converted!)).toBe(true);
+  });
+
+  test("applies EXIF orientation before encoding", async () => {
+    const { default: sharp } = await import("sharp");
+    const source = await sharp({
+      create: {
+        width: 2,
+        height: 1,
+        channels: 3,
+        background: { r: 255, g: 0, b: 0 },
+      },
+    })
+      .jpeg()
+      .withMetadata({ orientation: 6 })
+      .toBuffer();
+
+    const converted = await convertImageToJpeg(source, { quality: 83 });
+    expect(converted).not.toBeNull();
+    const metadata = await sharp(converted!).metadata();
+    expect(metadata.width).toBe(1);
+    expect(metadata.height).toBe(2);
+    expect(metadata.orientation).toBeUndefined();
+  });
+});
+
 // Mirrors the converter's cache-key derivation so the test can plant a
 // poisoned entry at the exact path a conversion will consult.
 function cacheKeyFor(bytes: Uint8Array, quality: number): string {
@@ -256,7 +290,7 @@ describe("normalizeImageBytes passthrough", () => {
   });
 
   test("HEIF header with undecodable payload passes through", async () => {
-    // sips fails (or is absent off-macOS) → the original bytes are kept.
+    // The malformed container cannot be decoded, so the bytes are kept.
     const fake = fakeHeifHeaderBytes();
     const result = await normalizeImageBytes("image/heic", fake);
     expect(result.converted).toBe(false);

package/src/__tests__/install-skill-routing.test.ts

@@ -13,6 +13,7 @@ const mockCatalogSkills = mock(
     description: string;
     source: string;
     directoryPath?: string;
+    platforms?: Array<"macos" | "windows" | "linux">;
   }> => [],
 );
 const mockClawhubInstall = mock(
@@ -110,6 +111,7 @@ mock.module("../providers/provider-send-message.js", () => ({
   userMessage: () => ({}),
 }));
 mock.module("../skills/catalog-cache.js", () => ({
+  getCachedCatalogSync: () => [],
   getCatalog: mockGetCatalog,
 }));
 mock.module("../skills/catalog-install.js", () => ({
@@ -382,6 +384,29 @@ Body.
     expect(mockClawhubInstall).not.toHaveBeenCalled();
   });
 
+  test("rejects bundled skills that do not support the host platform", async () => {
+    const incompatiblePlatform =
+      process.platform === "darwin" ? "windows" : "macos";
+    mockCatalogSkills.mockReturnValue([
+      {
+        id: "platform-skill",
+        displayName: "Platform Skill",
+        description: "A platform-specific skill",
+        source: "bundled",
+        directoryPath: "/tmp/test-bundled-skills/platform-skill",
+        platforms: [incompatiblePlatform],
+      },
+    ]);
+
+    const result = await installSkill({ slug: "platform-skill" });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("unavailable on this operating system");
+    }
+    expect(mockEnsureSkillEntry).not.toHaveBeenCalled();
+  });
+
   test("skills.sh install failure propagates error", async () => {
     mockInstallExternalSkill.mockRejectedValue(
       new Error("Skill not found in repo"),

package/src/__tests__/llm-catalog-parity.test.ts

@@ -67,6 +67,7 @@ interface ClientCatalogModel {
       cacheWritePer1mTokens?: number;
     }>;
   };
+  featureFlag?: string;
 }
 
 interface ClientCatalogEntry {
@@ -79,6 +80,7 @@ interface ClientCatalogEntry {
   apiKeyPlaceholder?: string;
   credentialsGuide?: ClientCatalogCredentialsGuide;
   supportsPlatformAuth?: boolean;
+  featureFlag?: string;
   defaultModel: string;
   models: ClientCatalogModel[];
 }
@@ -133,6 +135,7 @@ describe("LLM catalog parity: daemon vs client", () => {
       expect(clientEntry.supportsPlatformAuth).toBe(
         daemonEntry.supportsPlatformAuth,
       );
+      expect(clientEntry.featureFlag).toBe(daemonEntry.featureFlag);
       expect(clientEntry.credentialsGuide).toEqual(
         daemonEntry.credentialsGuide,
       );
@@ -199,6 +202,7 @@ describe("LLM catalog parity: daemon vs client", () => {
         expect(clientModel.supportsVision).toBe(daemonModel.supportsVision);
         expect(clientModel.supportsToolUse).toBe(daemonModel.supportsToolUse);
         expect(clientModel.pricing).toEqual(daemonModel.pricing);
+        expect(clientModel.featureFlag).toBe(daemonModel.featureFlag);
       }
     }
   });

package/src/__tests__/llm-resolver.test.ts

@@ -9,6 +9,7 @@ import {
   resolveCallSiteConfigWithProfile,
   resolveDefaultProfileKey,
   resolveEffectiveProfileKey,
+  resolveSingleRouteProfileKey,
 } from "../config/llm-resolver.js";
 import { type LLMCallSite, LLMSchema } from "../config/schemas/llm.js";
 import { resolveModelIntent } from "../providers/model-intents.js";
@@ -303,6 +304,26 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.effort).toBe("high");
   });
 
+  test("a winning profile's fallbackProfile metadata never leaks into the resolved config", () => {
+    const llm = LLMSchema.parse({
+      defaultProvider: { provider: "vellum" },
+      profiles: {
+        "quality-optimized": {
+          source: "managed",
+          fallbackProfile: "quality-optimized-backup",
+        },
+      },
+      callSites: {
+        memoryExtraction: { profile: "quality-optimized" },
+      },
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm);
+    expect(resolved.model).toBe("gpt-5.6-sol");
+    // `fallbackProfile` is ProfileEntry-only metadata, absent from
+    // `LLMConfigBase`; the resolved config must not carry the key at all.
+    expect(Object.hasOwn(resolved, "fallbackProfile")).toBe(false);
+  });
+
   test("topP defaults to null when no profile or override sets it", () => {
     const llm = LLMSchema.parse({});
     const resolved = resolveCallSiteConfig("mainAgent", llm);
@@ -869,6 +890,59 @@ describe("mix profiles", () => {
     );
   });
 
+  test("resolveSingleRouteProfileKey names standard winners and refuses mixes", () => {
+    // The mix's arm is picked per conversation and can differ from any
+    // post-hoc recomputation, so the outer mix key must never be used as a
+    // single-route attribution scope.
+    expect(resolveSingleRouteProfileKey("mainAgent", mixLlm)).toBeUndefined();
+    expect(
+      resolveSingleRouteProfileKey("mainAgent", mixLlm, {
+        overrideProfile: "a",
+      }),
+    ).toBe("a");
+    // An unusable override falls through to the active mix, which still
+    // refuses to name a route.
+    expect(
+      resolveSingleRouteProfileKey("mainAgent", mixLlm, {
+        overrideProfile: "no-such-profile",
+      }),
+    ).toBeUndefined();
+  });
+
+  test("resolveSingleRouteProfileKey honors the dispatch resolvability predicate", () => {
+    // A pin whose provider dispatch cannot resolve (e.g. a force-deleted
+    // connection) must not be claimed as a scope: selection falls through to
+    // the active mix exactly as dispatch does, which then refuses to name a
+    // route. Without the predicate the stale pin still wins the chain, which
+    // is why scope callers must pass dispatch's predicate.
+    const staleLlm = LLMSchema.parse({
+      profiles: {
+        a: { provider: "anthropic", model: "model-a" },
+        b: { provider: "anthropic", model: "model-b" },
+        stale: { provider: "openai", model: "model-s" },
+        ab: {
+          mix: [
+            { profile: "a", weight: 1 },
+            { profile: "b", weight: 1 },
+          ],
+        },
+      },
+      activeProfile: "ab",
+    });
+    const openaiForceDeleted = (provider: string) => provider !== "openai";
+    expect(
+      resolveSingleRouteProfileKey("mainAgent", staleLlm, {
+        overrideProfile: "stale",
+        isResolvableProvider: openaiForceDeleted,
+      }),
+    ).toBeUndefined();
+    expect(
+      resolveSingleRouteProfileKey("mainAgent", staleLlm, {
+        overrideProfile: "stale",
+      }),
+    ).toBe("stale");
+  });
+
   test("all dereference spots in a turn agree for the same seed", () => {
     // mainAgent (mix as activeProfile) and a non-main call site resolving the
     // same mix as its call-site profile must pick the same arm when given the

package/src/__tests__/llm-schema-fallback-profile.test.ts

@@ -0,0 +1,359 @@
+import { describe, expect, test } from "bun:test";
+
+import { z } from "zod";
+
+import {
+  BACKUP_PROFILE_KEYS,
+  DEFAULT_PROFILE_KEYS,
+  FALLBACK_PROFILE_BY_KEY,
+} from "../config/default-profile-names.js";
+import { LLMSchema } from "../config/schemas/llm.js";
+
+describe("LLMSchema fallbackProfile", () => {
+  test.each([...DEFAULT_PROFILE_KEYS])(
+    "accepts the code-owned managed pointer for %s",
+    (profileName) => {
+      const result = LLMSchema.safeParse({
+        defaultProvider: { provider: "vellum" },
+        profiles: {
+          [profileName]: {
+            source: "managed",
+            fallbackProfile: FALLBACK_PROFILE_BY_KEY[profileName],
+          },
+        },
+      });
+      expect(result.success).toBe(true);
+    },
+  );
+
+  test("rejects a user-authored fallbackProfile even when its target exists", () => {
+    const result = LLMSchema.safeParse({
+      profiles: {
+        primary: { fallbackProfile: "backup" },
+        backup: { speed: "fast" },
+      },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const issue = result.error.issues.find((i) =>
+        i.message.includes("Automatic fallbacks are code-owned"),
+      );
+      expect(issue?.path).toEqual(["profiles", "primary", "fallbackProfile"]);
+    }
+  });
+
+  test("rejects a fallbackProfile on a user-owned default-profile shadow", () => {
+    const profileName = DEFAULT_PROFILE_KEYS[0];
+    const result = LLMSchema.safeParse({
+      profiles: {
+        [profileName]: {
+          source: "user",
+          fallbackProfile: FALLBACK_PROFILE_BY_KEY[profileName],
+        },
+      },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects a managed default pointing anywhere except its code-owned backup", () => {
+    const profileName = DEFAULT_PROFILE_KEYS[0];
+    const result = LLMSchema.safeParse({
+      profiles: {
+        [profileName]: {
+          source: "managed",
+          fallbackProfile: "custom-backup",
+        },
+        "custom-backup": { speed: "fast" },
+      },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("empty-string fallbackProfile is rejected at field level", () => {
+    const result = LLMSchema.safeParse({
+      profiles: {
+        primary: { fallbackProfile: "" },
+      },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("profiles without fallbackProfile still parse (back-compat)", () => {
+    const result = LLMSchema.safeParse({
+      profiles: {
+        fast: { speed: "fast", effort: "low" },
+        thorough: { effort: "high", maxTokens: 128000 },
+      },
+      callSites: {
+        mainAgent: { profile: "thorough" },
+      },
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.profiles["fast"]?.fallbackProfile).toBeUndefined();
+    }
+  });
+
+  test("a code-owned fallback pointer is rejected on a non-managed column", () => {
+    const profileName = DEFAULT_PROFILE_KEYS[0];
+    for (const provider of ["anthropic", "chatgpt"] as const) {
+      const result = LLMSchema.safeParse({
+        defaultProvider: { provider },
+        profiles: {
+          [profileName]: {
+            source: "managed",
+            fallbackProfile: FALLBACK_PROFILE_BY_KEY[profileName],
+          },
+        },
+      });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        const issue = result.error.issues.find((i) =>
+          i.path.join(".").endsWith("fallbackProfile"),
+        );
+        expect(issue?.message).toContain("managed backup profile");
+        expect(issue?.path).toEqual([
+          "profiles",
+          profileName,
+          "fallbackProfile",
+        ]);
+      }
+    }
+  });
+
+  test("z.toJSONSchema still generates for LLMSchema (config docs/routes)", () => {
+    const json = z.toJSONSchema(LLMSchema, {
+      unrepresentable: "any",
+      io: "input",
+    });
+    expect(json).toMatchObject({
+      properties: {
+        profiles: {
+          additionalProperties: {
+            properties: { fallbackProfile: { readOnly: true } },
+          },
+        },
+      },
+    });
+  });
+});
+
+describe("LLMSchema backup profile references vs llm.defaultProvider", () => {
+  const backupKey = BACKUP_PROFILE_KEYS[0];
+  const managed = { provider: "vellum" } as const;
+  const nonManaged = [{ provider: "anthropic" }, { provider: "chatgpt" }];
+
+  test("activeProfile naming a backup parses on the managed column", () => {
+    const result = LLMSchema.safeParse({
+      defaultProvider: managed,
+      activeProfile: backupKey,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  test("activeProfile naming a backup is rejected on a non-managed column", () => {
+    for (const defaultProvider of nonManaged) {
+      const result = LLMSchema.safeParse({
+        defaultProvider,
+        activeProfile: backupKey,
+      });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        const issue = result.error.issues.find(
+          (i) => i.path.join(".") === "activeProfile",
+        );
+        expect(issue?.message).toContain("managed backup profile");
+      }
+    }
+  });
+
+  test("advisorProfile naming a backup follows the same split", () => {
+    expect(
+      LLMSchema.safeParse({
+        defaultProvider: managed,
+        advisorProfile: backupKey,
+      }).success,
+    ).toBe(true);
+    for (const defaultProvider of nonManaged) {
+      const result = LLMSchema.safeParse({
+        defaultProvider,
+        advisorProfile: backupKey,
+      });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(
+          result.error.issues.some(
+            (i) => i.path.join(".") === "advisorProfile",
+          ),
+        ).toBe(true);
+      }
+    }
+  });
+
+  test("a call-site pin on a backup follows the same split", () => {
+    expect(
+      LLMSchema.safeParse({
+        defaultProvider: managed,
+        callSites: { recall: { profile: backupKey } },
+      }).success,
+    ).toBe(true);
+    for (const defaultProvider of nonManaged) {
+      const result = LLMSchema.safeParse({
+        defaultProvider,
+        callSites: { recall: { profile: backupKey } },
+      });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        const issue = result.error.issues.find(
+          (i) => i.path.join(".") === "callSites.recall.profile",
+        );
+        expect(issue?.message).toContain("managed backup profile");
+      }
+    }
+  });
+
+  test("a mix arm naming a backup follows the same split", () => {
+    const mixConfig = (defaultProvider: { provider: string }) => ({
+      defaultProvider,
+      profiles: {
+        armA: { speed: "fast" },
+        blend: {
+          mix: [
+            { profile: backupKey, weight: 1 },
+            { profile: "armA", weight: 1 },
+          ],
+        },
+      },
+    });
+    expect(LLMSchema.safeParse(mixConfig(managed)).success).toBe(true);
+    for (const defaultProvider of nonManaged) {
+      expect(LLMSchema.safeParse(mixConfig(defaultProvider)).success).toBe(
+        false,
+      );
+    }
+  });
+
+  test("an absent or malformed defaultProvider reads as the managed column", () => {
+    // `DefaultProviderField` catches an invalid value to `undefined`, and an
+    // install predating the field is managed by definition, so both keep
+    // their backups referenceable rather than losing a valid selection.
+    for (const defaultProvider of [undefined, { provider: 42 }, "vellum"]) {
+      const result = LLMSchema.safeParse({
+        defaultProvider,
+        activeProfile: backupKey,
+      });
+      expect(result.success).toBe(true);
+    }
+  });
+
+  test("the default profile keys stay valid on every column", () => {
+    for (const defaultProvider of [managed, ...nonManaged]) {
+      for (const key of DEFAULT_PROFILE_KEYS) {
+        expect(
+          LLMSchema.safeParse({ defaultProvider, activeProfile: key }).success,
+        ).toBe(true);
+      }
+    }
+  });
+
+  // A managed install can persist a thin `{ source: "managed" }` stub for a
+  // backup key: `normalizeManagedProfileWrites` reduces a `config get` ->
+  // `config set` echo of the effective profile list to exactly that. The stub
+  // holds no body of its own, so it must not carry a reference past the
+  // provider gate once the install moves off the managed column.
+  const stub = { source: "managed" } as const;
+
+  test("a managed stub does not keep a backup reference alive off the managed column", () => {
+    for (const defaultProvider of nonManaged) {
+      const result = LLMSchema.safeParse({
+        defaultProvider,
+        profiles: { [backupKey]: stub, primary: { effort: "high" } },
+        activeProfile: backupKey,
+      });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        const issue = result.error.issues.find(
+          (i) => i.path.join(".") === "activeProfile",
+        );
+        expect(issue?.message).toContain("managed backup profile");
+      }
+    }
+  });
+
+  test("a managed stub does not keep a call-site pin or mix arm alive either", () => {
+    for (const defaultProvider of nonManaged) {
+      const callSitePin = LLMSchema.safeParse({
+        defaultProvider,
+        profiles: { [backupKey]: stub },
+        callSites: { recall: { profile: backupKey } },
+      });
+      expect(callSitePin.success).toBe(false);
+
+      const mixArm = LLMSchema.safeParse({
+        defaultProvider,
+        profiles: {
+          [backupKey]: stub,
+          armA: { speed: "fast" },
+          blend: {
+            mix: [
+              { profile: backupKey, weight: 1 },
+              { profile: "armA", weight: 1 },
+            ],
+          },
+        },
+      });
+      expect(mixArm.success).toBe(false);
+    }
+  });
+
+  test("a managed stub does not keep a fallbackProfile pointer alive either", () => {
+    for (const defaultProvider of nonManaged) {
+      const result = LLMSchema.safeParse({
+        defaultProvider,
+        profiles: {
+          [backupKey]: stub,
+          primary: { fallbackProfile: backupKey },
+        },
+      });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        const issue = result.error.issues.find(
+          (i) => i.path.join(".") === "profiles.primary.fallbackProfile",
+        );
+        expect(issue?.message).toContain("Automatic fallbacks are code-owned");
+      }
+    }
+  });
+
+  test("a managed stub keeps its references valid on the managed column", () => {
+    // The stub stands for a body that does resolve here, so nothing about it
+    // makes the reference worse than the unmaterialized case.
+    const result = LLMSchema.safeParse({
+      defaultProvider: managed,
+      profiles: {
+        [backupKey]: stub,
+      },
+      activeProfile: backupKey,
+      callSites: { recall: { profile: backupKey } },
+    });
+    expect(result.success).toBe(true);
+  });
+
+  test("a user-owned entry under a backup name cannot enable custom fallback", () => {
+    for (const defaultProvider of [managed, ...nonManaged]) {
+      const result = LLMSchema.safeParse({
+        defaultProvider,
+        profiles: {
+          [backupKey]: {
+            source: "user",
+            provider: "anthropic",
+            model: "claude-opus-4-7",
+          },
+          primary: { fallbackProfile: backupKey },
+        },
+        activeProfile: backupKey,
+      });
+      expect(result.success).toBe(false);
+    }
+  });
+});