@copilotkit/vue 1.69.2 → 1.70.0

package/src/v2/providers/CopilotKitProvider.vue

@@ -15,8 +15,11 @@ import type {
   CopilotKitCoreSubscriber,
   FrontendTool,
 } from "@copilotkit/core";
-import { schemaToJsonSchema } from "@copilotkit/shared";
-import type { RuntimeLicenseStatus } from "@copilotkit/shared";
+import { schemaToJsonSchema, shouldEnableInspector } from "@copilotkit/shared";
+import type {
+  RuntimeEntitlementResponse,
+  RuntimeLicenseStatus,
+} from "@copilotkit/shared";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { CopilotKitCoreVue } from "../lib/vue-core";
 import { createA2UIMessageRenderer } from "../components/A2UIMessageRenderer";
@@ -34,7 +37,8 @@ import {
   MCPAppsActivityRenderer,
   MCPAppsActivityType,
 } from "../components/MCPAppsActivityRenderer";
-import { CopilotKitKey, SandboxFunctionsKey } from "./keys";
+import { CopilotKitKey, InspectorKey, SandboxFunctionsKey } from "./keys";
+import type { VueInspectorOpenRequest } from "./keys";
 import {
   LicenseContextKey,
   createLicenseContextValue,
@@ -47,13 +51,11 @@ import type {
   SandboxFunction,
   VueActivityMessageRenderer,
   VueFrontendTool,
-  VueHumanInTheLoop,
   VueToolCallRenderer,
 } from "../types";
 
 const HEADER_NAME = "X-CopilotCloud-Public-Api-Key";
 const COPILOT_CLOUD_CHAT_URL = "https://api.cloud.copilotkit.ai/copilotkit/v1";
-
 // Canonical A2UI viewer theme default (matches @copilotkit/a2ui-renderer).
 // Defined locally to avoid pulling React dependencies from a2ui-renderer.
 const viewerTheme: Record<string, unknown> = {};
@@ -103,32 +105,34 @@ const props = withDefaults(defineProps<CopilotKitProviderProps>(), {
   renderCustomMessages: () => [],
   renderActivityMessages: () => [],
   openGenerativeUI: undefined,
-  showDevConsole: false,
   useSingleEndpoint: undefined,
   a2ui: undefined,
+  enableInspector: undefined,
 });
 
 const shouldRenderInspector = ref(false);
 
-const updateInspectorVisibility = () => {
-  if (props.showDevConsole === true) {
-    shouldRenderInspector.value = true;
-    return;
-  }
-  if (props.showDevConsole === "auto") {
-    if (typeof window === "undefined") {
-      shouldRenderInspector.value = false;
-      return;
-    }
-    const localhostHosts = new Set(["localhost", "127.0.0.1"]);
-    shouldRenderInspector.value = localhostHosts.has(window.location.hostname);
-    return;
-  }
-  shouldRenderInspector.value = false;
-};
+function updateInspectorVisibility(): void {
+  shouldRenderInspector.value = shouldEnableInspector({
+    enableInspector: props.enableInspector,
+    isBrowser: true,
+    isDevelopment: process.env.NODE_ENV === "development",
+  });
+}
+
+onMounted(updateInspectorVisibility);
+watch(() => props.enableInspector, updateInspectorVisibility);
 
-watch(() => props.showDevConsole, updateInspectorVisibility, {
-  immediate: true,
+const inspectorOpenRequest = ref<VueInspectorOpenRequest | null>(null);
+const isInspectorEnabled = computed(() => shouldRenderInspector.value);
+
+function openInspector(request: VueInspectorOpenRequest) {
+  inspectorOpenRequest.value = { ...request };
+}
+
+provide(InspectorKey, {
+  isInspectorEnabled,
+  openInspector,
 });
 
 const initialFrontendTools = props.frontendTools;
@@ -292,6 +296,10 @@ const allRenderCustomMessages = computed(
 const runtimeA2UIEnabled = ref(false);
 const runtimeOpenGenerativeUIEnabled = ref(false);
 const runtimeLicenseStatus = ref<RuntimeLicenseStatus | undefined>(undefined);
+const runtimeEntitlements = ref<RuntimeEntitlementResponse | undefined>(
+  undefined,
+);
+const runtimeEntitlementRetryPending = ref(false);
 const openGenerativeUIActive = computed(
   () => runtimeOpenGenerativeUIEnabled.value || !!props.openGenerativeUI,
 );
@@ -458,15 +466,14 @@ watch(
         runtimeA2UIEnabled.value = core.a2uiEnabled;
         runtimeOpenGenerativeUIEnabled.value = core.openGenerativeUIEnabled;
         runtimeLicenseStatus.value = core.licenseStatus;
+        runtimeEntitlements.value = core.runtimeEntitlements;
+        runtimeEntitlementRetryPending.value =
+          core.runtimeEntitlementRetryPending;
         triggerRef(copilotkit);
       },
     });
     const sub5 = core.subscribe({
-      onError: (event: {
-        error: Error;
-        code: CopilotKitCoreErrorCode;
-        context: Record<string, any>;
-      }) => {
+      onError: (event) => {
         void props.onError?.({
           error: event.error,
           code: event.code,
@@ -555,6 +562,9 @@ onMounted(() => {
   runtimeOpenGenerativeUIEnabled.value =
     copilotkit.value.openGenerativeUIEnabled;
   runtimeLicenseStatus.value = copilotkit.value.licenseStatus;
+  runtimeEntitlements.value = copilotkit.value.runtimeEntitlements;
+  runtimeEntitlementRetryPending.value =
+    copilotkit.value.runtimeEntitlementRetryPending;
   didMountRef.value = true;
 });
 
@@ -631,23 +641,70 @@ provide(CopilotKitKey, {
 });
 provide(SandboxFunctionsKey, sandboxFunctions);
 
-// License context — driven by server-reported `/info` license status.
-const licenseContextValue = computed<LicenseContextValue>(() =>
-  createLicenseContextValue(runtimeLicenseStatus.value),
+// License context — driven by structured and legacy Runtime authority.
+const retryableRuntimeEntitlementFailure = computed(
+  () =>
+    runtimeEntitlements.value?.status !== "ready" &&
+    runtimeEntitlements.value?.error.retryable === true,
 );
+const hasNonReadyRuntimeEntitlement = computed(
+  () =>
+    runtimeEntitlements.value !== undefined &&
+    runtimeEntitlements.value.status !== "ready",
+);
+const hasLegacyRuntimeEntitlementFallback = computed(
+  () =>
+    runtimeLicenseStatus.value === "valid" ||
+    runtimeLicenseStatus.value === "expiring",
+);
+const runtimeEntitlementRetryInProgress = computed(
+  () =>
+    retryableRuntimeEntitlementFailure.value &&
+    runtimeEntitlementRetryPending.value &&
+    !hasLegacyRuntimeEntitlementFallback.value,
+);
+const runtimeEntitlementFailureSettled = computed(
+  () =>
+    hasNonReadyRuntimeEntitlement.value &&
+    !runtimeEntitlementRetryInProgress.value &&
+    !hasLegacyRuntimeEntitlementFallback.value,
+);
+const licenseContextValue = computed<LicenseContextValue>(() => {
+  const runtimeLicenseContext = createLicenseContextValue(
+    runtimeEntitlementRetryInProgress.value
+      ? undefined
+      : runtimeLicenseStatus.value,
+    runtimeEntitlements.value,
+  );
+  if (!runtimeEntitlementFailureSettled.value) {
+    return runtimeLicenseContext;
+  }
+
+  return {
+    ...runtimeLicenseContext,
+    checkFeature: () => false,
+    getLimit: () => null,
+  };
+});
 provide(LicenseContextKey, licenseContextValue);
 
+const runtimeLicenseWarningStatus = computed(() =>
+  runtimeEntitlementRetryInProgress.value
+    ? undefined
+    : (licenseContextValue.value.status ?? undefined),
+);
 const showNoLicenseBanner = computed(
-  () => runtimeLicenseStatus.value === "none" && !resolvedPublicKey.value,
+  () =>
+    runtimeLicenseWarningStatus.value === "none" && !resolvedPublicKey.value,
 );
 const showExpiredBanner = computed(
-  () => runtimeLicenseStatus.value === "expired",
+  () => runtimeLicenseWarningStatus.value === "expired",
 );
 const showInvalidBanner = computed(
-  () => runtimeLicenseStatus.value === "invalid",
+  () => runtimeLicenseWarningStatus.value === "invalid",
 );
 const showExpiringBanner = computed(
-  () => runtimeLicenseStatus.value === "expiring",
+  () => runtimeLicenseWarningStatus.value === "expiring",
 );
 </script>
 
@@ -656,7 +713,7 @@ const showExpiringBanner = computed(
   <CopilotKitInspector
     v-if="shouldRenderInspector"
     :core="copilotkit"
-    :default-anchor="props.inspectorDefaultAnchor"
+    :open-request="inspectorOpenRequest"
   />
   <!-- License warnings — driven by server-reported status -->
   <LicenseWarningBanner v-if="showNoLicenseBanner" type="no_license" />

package/src/v2/providers/__tests__/CopilotKitProvider.managedEntitlement.test.ts

@@ -0,0 +1,290 @@
+import { cleanup, render, waitFor } from "@testing-library/vue";
+import type {
+  RuntimeEntitlementResponse,
+  RuntimeInfo,
+} from "@copilotkit/shared";
+import { defineComponent, h, nextTick } from "vue";
+import { expect, test, vi } from "vitest";
+import CopilotKitProvider from "../CopilotKitProvider.vue";
+import { useLicenseContext } from "../useLicenseContext";
+
+const AuthorityProbe = defineComponent({
+  setup() {
+    const license = useLicenseContext();
+    return () =>
+      h(
+        "output",
+        { "data-testid": "runtime-license-authority" },
+        [
+          `status:${license.value.status ?? "null"}`,
+          `chat:${license.value.checkFeature("chat")}`,
+          `sidebar:${license.value.checkFeature("sidebar")}`,
+          `popup:${license.value.checkFeature("popup")}`,
+          `threads:${license.value.checkFeature("threads")}`,
+        ].join(" "),
+      );
+  },
+});
+
+function managedRuntimeInfo(
+  active: boolean,
+  licenseStatus: RuntimeInfo["licenseStatus"],
+): RuntimeInfo {
+  return {
+    version: "1.0.0",
+    agents: {},
+    audioFileTranscriptionEnabled: false,
+    mode: "intelligence",
+    licenseStatus,
+    runtimeEntitlements: {
+      status: "ready",
+      entitlement: {
+        active,
+        source: "managedOrgSubscription",
+        // Mirrors the active/inactive free-plan payload emitted by Intelligence.
+        ...(active
+          ? {
+              planCode: "free",
+              entitlementSource: "clerk_free_default",
+              features: {
+                "sdk.angular": false,
+                deployment_via_helm_chart: false,
+                analytics: true,
+                self_learning: true,
+                msteams: false,
+                memory: false,
+                managed_channels: true,
+                "managed_channels.slack": true,
+                "managed_channels.teams": true,
+              },
+              limits: {
+                "threads.retention_hours": 72,
+                "threads.max_count": 200,
+              },
+            }
+          : { features: {}, limits: {} }),
+      },
+    },
+  };
+}
+
+/** Build Runtime info mirroring the active self-hosted producer payload. */
+function selfHostedRuntimeInfo(
+  licenseStatus: RuntimeInfo["licenseStatus"],
+): RuntimeInfo {
+  return {
+    ...managedRuntimeInfo(true, licenseStatus),
+    runtimeEntitlements: {
+      status: "ready",
+      entitlement: {
+        active: true,
+        source: "selfHostedDeploymentLicense",
+        features: { deployment_via_helm_chart: true, msteams: true },
+        limits: {
+          "threads.retention_hours": 336,
+          "threads.max_count": 25_000,
+        },
+        planCode: "team_self_hosted",
+        entitlementSource: "enterprise_override",
+      },
+    },
+  };
+}
+
+function retryableRuntimeInfo(
+  licenseStatus: RuntimeInfo["licenseStatus"] = "unknown",
+): RuntimeInfo {
+  const runtimeEntitlements: RuntimeEntitlementResponse = {
+    status: "unavailable",
+    error: {
+      code: "runtime_entitlements_unavailable",
+      message: "Runtime entitlement lookup failed",
+      retryable: true,
+    },
+  };
+  return {
+    ...managedRuntimeInfo(true, licenseStatus),
+    runtimeEntitlements,
+  };
+}
+
+interface RuntimeAuthoritySetup {
+  dispose: () => void;
+  fetchMock: ReturnType<typeof vi.fn<typeof globalThis.fetch>>;
+  readAuthority: () => string;
+  view: ReturnType<typeof render>;
+}
+
+/**
+ * Render the provider against ordered `/info` responses.
+ */
+function setupRuntimeAuthority(
+  ...runtimeInfoResponses: [RuntimeInfo, ...RuntimeInfo[]]
+): RuntimeAuthoritySetup {
+  const fetchMock = vi.fn<typeof globalThis.fetch>();
+  for (const runtimeInfo of runtimeInfoResponses) {
+    fetchMock.mockResolvedValueOnce(
+      new Response(JSON.stringify(runtimeInfo), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }),
+    );
+  }
+  vi.stubGlobal("fetch", fetchMock);
+
+  const view = render(CopilotKitProvider, {
+    props: { runtimeUrl: "/api" },
+    slots: { default: () => h(AuthorityProbe) },
+  });
+
+  return {
+    dispose() {
+      view.unmount();
+      cleanup();
+      vi.unstubAllGlobals();
+    },
+    fetchMock,
+    readAuthority: () =>
+      view.getByTestId("runtime-license-authority").textContent ?? "",
+    view,
+  };
+}
+
+async function flushPromiseUpdates(): Promise<void> {
+  await vi.advanceTimersByTimeAsync(0);
+  await nextTick();
+}
+
+test("a ready managed grant drives every Vue feature gate and overrides a stale invalid token", async () => {
+  const { dispose, readAuthority, view } = setupRuntimeAuthority(
+    managedRuntimeInfo(true, "invalid"),
+  );
+
+  try {
+    await waitFor(() => {
+      expect(readAuthority()).toBe(
+        "status:valid chat:true sidebar:true popup:true threads:true",
+      );
+    });
+    expect(view.queryByText(/Invalid CopilotKit license token/i)).toBeNull();
+  } finally {
+    dispose();
+  }
+});
+
+test("a ready managed denial drives every Vue feature gate", async () => {
+  const { dispose, readAuthority } = setupRuntimeAuthority(
+    managedRuntimeInfo(false, "none"),
+  );
+
+  try {
+    await waitFor(() => {
+      expect(readAuthority()).toBe(
+        "status:none chat:false sidebar:false popup:false threads:false",
+      );
+    });
+  } finally {
+    dispose();
+  }
+});
+
+test("an active self-hosted producer entitlement drives every Vue feature gate", async () => {
+  const { dispose, readAuthority } = setupRuntimeAuthority(
+    selfHostedRuntimeInfo("invalid"),
+  );
+
+  try {
+    await waitFor(() => {
+      expect(readAuthority()).toBe(
+        "status:valid chat:true sidebar:true popup:true threads:true",
+      );
+    });
+  } finally {
+    dispose();
+  }
+});
+
+test("a retryable managed lookup keeps every Vue gate pending and hides stale warnings until recovery", async () => {
+  vi.useFakeTimers();
+  const { dispose, fetchMock, readAuthority, view } = setupRuntimeAuthority(
+    retryableRuntimeInfo("invalid"),
+    managedRuntimeInfo(true, "invalid"),
+  );
+
+  try {
+    await flushPromiseUpdates();
+
+    expect(fetchMock).toHaveBeenCalledOnce();
+    expect(readAuthority()).toBe(
+      "status:null chat:true sidebar:true popup:true threads:true",
+    );
+    expect(view.queryByText(/Invalid CopilotKit license token/i)).toBeNull();
+
+    await vi.advanceTimersByTimeAsync(5_000);
+    await nextTick();
+
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(readAuthority()).toBe(
+      "status:valid chat:true sidebar:true popup:true threads:true",
+    );
+  } finally {
+    dispose();
+    vi.useRealTimers();
+  }
+});
+
+test("a persistent retryable lookup denies every Vue gate after Core's bounded retry settles", async () => {
+  vi.useFakeTimers();
+  const { dispose, fetchMock, readAuthority } = setupRuntimeAuthority(
+    retryableRuntimeInfo(),
+    retryableRuntimeInfo(),
+  );
+
+  try {
+    await flushPromiseUpdates();
+
+    expect(readAuthority()).toBe(
+      "status:null chat:true sidebar:true popup:true threads:true",
+    );
+
+    await vi.advanceTimersByTimeAsync(5_000);
+    await nextTick();
+
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(readAuthority()).toBe(
+      "status:unknown chat:false sidebar:false popup:false threads:false",
+    );
+
+    await vi.advanceTimersByTimeAsync(30_000);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  } finally {
+    dispose();
+    vi.useRealTimers();
+  }
+});
+
+test("an inactive self-hosted entitlement keeps Vue's valid legacy fallback", async () => {
+  const runtimeInfo: RuntimeInfo = {
+    ...managedRuntimeInfo(false, "valid"),
+    runtimeEntitlements: {
+      status: "ready",
+      entitlement: {
+        active: false,
+        source: "selfHostedDeploymentLicense",
+        features: {},
+        limits: {},
+      },
+    },
+  };
+  const { dispose, readAuthority } = setupRuntimeAuthority(runtimeInfo);
+
+  try {
+    await waitFor(() => {
+      expect(readAuthority()).toBe(
+        "status:valid chat:true sidebar:true popup:true threads:true",
+      );
+    });
+  } finally {
+    dispose();
+  }
+});