@copilotkit/shared 1.69.3 → 1.70.0

package/src/__tests__/license-context.test.ts

@@ -1,33 +1,232 @@
-import { describe, it, expect } from "vitest";
+import { expect, test } from "vitest";
 import { createLicenseContextValue } from "../index";
 import type { RuntimeLicenseStatus } from "../utils/types";
 
-describe("createLicenseContextValue", () => {
-  it("fails open when no status is known", () => {
-    for (const status of [null, undefined] as const) {
-      const ctx = createLicenseContextValue(status);
-      expect(ctx.status).toBeNull();
-      expect(ctx.license).toBeNull();
-      expect(ctx.checkFeature("chat")).toBe(true);
-      expect(ctx.getLimit("chat")).toBeNull();
-    }
+test("license context fails open when no status is known", () => {
+  for (const status of [null, undefined] as const) {
+    const ctx = createLicenseContextValue(status);
+    expect(ctx.status).toBeNull();
+    expect(ctx.license).toBeNull();
+    expect(ctx.checkFeature("chat")).toBe(true);
+    expect(ctx.getLimit("chat")).toBeNull();
+  }
+});
+
+test.each(["valid", "none", "expiring", "unknown"] as RuntimeLicenseStatus[])(
+  "license context enables features for %s status",
+  (status) => {
+    const ctx = createLicenseContextValue(status);
+    expect(ctx.status).toBe(status);
+    expect(ctx.checkFeature("chat")).toBe(true);
+  },
+);
+
+test.each(["expired", "invalid"] as RuntimeLicenseStatus[])(
+  "license context disables features for %s status",
+  (status) => {
+    const ctx = createLicenseContextValue(status);
+    expect(ctx.status).toBe(status);
+    expect(ctx.checkFeature("chat")).toBe(false);
+  },
+);
+
+test("license context uses ready active feature grants and numeric limits", () => {
+  const ctx = createLicenseContextValue("valid", {
+    status: "ready",
+    entitlement: {
+      active: true,
+      source: "managedOrgSubscription",
+      features: {
+        chat: true,
+        threads: false,
+      },
+      limits: {
+        threads: 25,
+      },
+    },
   });
 
-  it.each(["valid", "none", "expiring", "unknown"] as RuntimeLicenseStatus[])(
-    "enables features for %s status",
-    (status) => {
-      const ctx = createLicenseContextValue(status);
-      expect(ctx.status).toBe(status);
-      expect(ctx.checkFeature("chat")).toBe(true);
+  expect(ctx.checkFeature("chat")).toBe(true);
+  expect(ctx.checkFeature("threads")).toBe(false);
+  expect(ctx.checkFeature("unknown")).toBe(false);
+  expect(ctx.getLimit("threads")).toBe(25);
+  expect(ctx.getLimit("unknown")).toBeNull();
+});
+
+test.each([0, 25])(
+  "license context treats an own threads.max_count limit of %s as a thread grant",
+  (threadLimit) => {
+    const ctx = createLicenseContextValue("valid", {
+      status: "ready",
+      entitlement: {
+        active: true,
+        source: "managedOrgSubscription",
+        features: {},
+        limits: { "threads.max_count": threadLimit },
+      },
+    });
+
+    expect(ctx.checkFeature("threads")).toBe(true);
+    expect(ctx.getLimit("threads.max_count")).toBe(threadLimit);
+  },
+);
+
+test.each([
+  {
+    source: "managedOrgSubscription" as const,
+    features: {},
+    limits: {
+      "threads.retention_hours": 72,
+      "threads.max_count": 200,
+    },
+  },
+  {
+    source: "selfHostedDeploymentLicense" as const,
+    features: {
+      deployment_via_helm_chart: true,
+      msteams: true,
+    },
+    limits: {
+      "threads.retention_hours": 336,
+      "threads.max_count": 25000,
+    },
+  },
+])(
+  "license context preserves legacy UI features for an active $source payload",
+  (entitlement) => {
+    const ctx = createLicenseContextValue("valid", {
+      status: "ready",
+      entitlement: {
+        active: true,
+        ...entitlement,
+      },
+    });
+
+    for (const feature of ["chat", "popup", "sidebar", "threads"]) {
+      expect(ctx.checkFeature(feature)).toBe(true);
+    }
+    expect(ctx.checkFeature("unknown")).toBe(false);
+  },
+);
+
+test.each(["chat", "popup", "sidebar"])(
+  "license context preserves an explicit %s denial",
+  (feature) => {
+    const ctx = createLicenseContextValue("valid", {
+      status: "ready",
+      entitlement: {
+        active: true,
+        source: "managedOrgSubscription",
+        features: { [feature]: false },
+        limits: {},
+      },
+    });
+
+    expect(ctx.checkFeature(feature)).toBe(false);
+  },
+);
+
+test.each([true, false])(
+  "license context preserves a legacy threads feature value of %s",
+  (threads) => {
+    const ctx = createLicenseContextValue("valid", {
+      status: "ready",
+      entitlement: {
+        active: true,
+        source: "selfHostedDeploymentLicense",
+        features: { threads },
+        limits: {},
+      },
+    });
+
+    expect(ctx.checkFeature("threads")).toBe(threads);
+  },
+);
+
+test("license context denies features and limits for a ready inactive entitlement", () => {
+  const ctx = createLicenseContextValue("none", {
+    status: "ready",
+    entitlement: {
+      active: false,
+      source: "managedOrgSubscription",
+      features: {
+        chat: true,
+      },
+      limits: {
+        threads: 25,
+      },
     },
-  );
-
-  it.each(["expired", "invalid"] as RuntimeLicenseStatus[])(
-    "disables features for %s status",
-    (status) => {
-      const ctx = createLicenseContextValue(status);
-      expect(ctx.status).toBe(status);
-      expect(ctx.checkFeature("chat")).toBe(false);
+  });
+
+  expect(ctx.checkFeature("chat")).toBe(false);
+  expect(ctx.getLimit("threads")).toBeNull();
+});
+
+test.each(["valid", "expiring"] as RuntimeLicenseStatus[])(
+  "license context preserves a %s legacy fallback for an inactive self-hosted entitlement",
+  (status) => {
+    const ctx = createLicenseContextValue(status, {
+      status: "ready",
+      entitlement: {
+        active: false,
+        source: "selfHostedDeploymentLicense",
+        features: {
+          threads: false,
+        },
+        limits: {
+          threads: 0,
+        },
+      },
+    });
+
+    expect(ctx.status).toBe(status);
+    expect(ctx.checkFeature("threads")).toBe(true);
+    expect(ctx.getLimit("threads")).toBeNull();
+  },
+);
+
+test.each([
+  { status: undefined, expectedStatus: "none" },
+  { status: "none", expectedStatus: "none" },
+  { status: "expired", expectedStatus: "expired" },
+  { status: "invalid", expectedStatus: "invalid" },
+  { status: "unknown", expectedStatus: "unknown" },
+] as const)(
+  "license context denies an inactive self-hosted entitlement with $status legacy status",
+  ({ status, expectedStatus }) => {
+    const ctx = createLicenseContextValue(status, {
+      status: "ready",
+      entitlement: {
+        active: false,
+        source: "selfHostedDeploymentLicense",
+        features: {
+          threads: true,
+        },
+        limits: {
+          threads: 25,
+        },
+      },
+    });
+
+    expect(ctx.status).toBe(expectedStatus);
+    expect(ctx.checkFeature("threads")).toBe(false);
+    expect(ctx.getLimit("threads")).toBeNull();
+  },
+);
+
+test("license context ignores inherited feature and limit keys", () => {
+  const ctx = createLicenseContextValue("valid", {
+    status: "ready",
+    entitlement: {
+      active: true,
+      source: "managedOrgSubscription",
+      features: {},
+      limits: {},
     },
-  );
+  });
+
+  for (const feature of ["toString", "constructor"]) {
+    expect(ctx.checkFeature(feature)).toBe(false);
+    expect(ctx.getLimit(feature)).toBeNull();
+  }
 });

package/src/index.ts

@@ -33,7 +33,10 @@ export type {
 } from "@copilotkit/license-verifier";
 
 import type { LicensePayload } from "@copilotkit/license-verifier";
-import type { RuntimeLicenseStatus } from "./utils/types";
+import type {
+  RuntimeEntitlementResponse,
+  RuntimeLicenseStatus,
+} from "./utils/types";
 
 // LicenseContextValue was dropped from license-verifier's public API in
 // 0.3.0, so it is defined here. The context shape is owned by this package
@@ -44,40 +47,93 @@ import type { RuntimeLicenseStatus } from "./utils/types";
  * Frontend providers create their own context using this shape.
  */
 export interface LicenseContextValue {
-  /** Server-reported license status from the runtime's /info endpoint. Null until known. */
+  /** Effective license status after structured entitlement precedence. Null until known. */
   status: RuntimeLicenseStatus | null;
   /** The license payload if available. Always null on the client; the payload stays server-side. */
   license: LicensePayload | null;
-  /** Whether a specific feature is licensed. Returns true if no licensing is active (no token). */
+  /** Whether a feature is licensed. Ready entitlements override legacy status behavior. */
   checkFeature: (feature: string) => boolean;
-  /** Get a numeric feature limit. Returns null if not applicable. */
+  /** Get a numeric feature limit. Zero means unlimited; null means not applicable. */
   getLimit: (feature: string) => number | null;
 }
 
+/** Read a record value without traversing its prototype chain. */
+function getOwnRecordValue<Value>(
+  record: Readonly<Record<string, Value>>,
+  key: string,
+): Value | undefined {
+  return Object.prototype.hasOwnProperty.call(record, key)
+    ? record[key]
+    : undefined;
+}
+
+/** Legacy UI surfaces that remain available for every active entitlement. */
+function isLegacyUiFeature(feature: string): boolean {
+  return feature === "chat" || feature === "popup" || feature === "sidebar";
+}
+
 /**
- * Client-safe license context factory, driven by the license status the
+ * Client-safe license context factory, driven by the license authority the
  * runtime reports via /info.
  *
- * Features are enabled unless the runtime definitively reports the license
- * as "expired" or "invalid". A null/"none"/"unknown" status fails open
- * (unlicensed = unrestricted, with branding), and "expiring" keeps features
- * on while the provider surfaces a warning banner. Per-feature data is not
- * in /info yet, so checkFeature is uniform across features and getLimit has
- * no limits to report. This is inlined here to avoid importing the full
- * license-verifier bundle (which depends on Node's `crypto`) into browser
- * bundles.
+ * A ready managed entitlement is authoritative in both directions. A ready
+ * active self-hosted entitlement is also authoritative, while an inactive
+ * self-hosted response preserves the legacy signed-license fallback. Active
+ * entitlements supply feature grants and limits; authoritative inactive
+ * entitlements deny every feature and limit. Older runtimes that report only a
+ * status retain the legacy behavior: features are enabled unless the status is
+ * "expired" or "invalid", and no limits are reported. This is inlined here to
+ * avoid importing the full license-verifier bundle (which depends on Node's
+ * `crypto`) into browser bundles.
  */
 export function createLicenseContextValue(
   status: RuntimeLicenseStatus | null | undefined,
+  runtimeEntitlements?: RuntimeEntitlementResponse,
 ): LicenseContextValue {
-  const resolvedStatus = status ?? null;
+  const readyEntitlement =
+    runtimeEntitlements?.status === "ready"
+      ? runtimeEntitlements.entitlement
+      : null;
+  const hasUsableSelfHostedLegacyFallback =
+    readyEntitlement &&
+    !readyEntitlement.active &&
+    readyEntitlement.source === "selfHostedDeploymentLicense" &&
+    (status === "valid" || status === "expiring");
+  const featureAuthority =
+    readyEntitlement && !hasUsableSelfHostedLegacyFallback
+      ? readyEntitlement
+      : null;
+  const activeEntitlement = featureAuthority?.active ? featureAuthority : null;
+  const resolvedStatus = activeEntitlement
+    ? "valid"
+    : readyEntitlement?.source === "managedOrgSubscription"
+      ? "none"
+      : featureAuthority
+        ? (status ?? "none")
+        : (status ?? null);
   const featuresEnabled =
     resolvedStatus !== "expired" && resolvedStatus !== "invalid";
+
   return {
     status: resolvedStatus,
     license: null,
-    checkFeature: () => featuresEnabled,
-    getLimit: () => null,
+    checkFeature: (feature) =>
+      featureAuthority
+        ? activeEntitlement
+          ? feature === "threads" &&
+            Object.prototype.hasOwnProperty.call(
+              activeEntitlement.limits,
+              "threads.max_count",
+            )
+            ? true
+            : (getOwnRecordValue(activeEntitlement.features, feature) ??
+              isLegacyUiFeature(feature))
+          : false
+        : featuresEnabled,
+    getLimit: (feature) =>
+      activeEntitlement
+        ? (getOwnRecordValue(activeEntitlement.limits, feature) ?? null)
+        : null,
   };
 }
 

package/src/telemetry/index.ts

@@ -1,5 +1,7 @@
 export * from "./telemetry-client";
+export * from "./sampling";
 export {
+  firstNonBlankTelemetryId,
   lambdaClient,
   parseTelemetryIdFromLicense,
   parseAndWarnTelemetryId,