@stigmer/sdk 3.35.0 → 3.37.0

package/src/__tests__/platform.test.ts

@@ -1,74 +0,0 @@
-/**
- * Pins PlatformClient.getServerInfo's edition-to-mode mapping: the client
- * reports the server's edition through the one converter
- * (`deploymentModeOf`), so a third edition on the wire reaches consumers
- * as its own mode and never collapses into "cloud" by accident. The raw
- * edition rides beside it for callers that want the wire value.
- *
- * Also pins the authentication posture across the wire: a server's `true`
- * and `false` reach callers as they were sent, and a server that predates
- * the field answers `undefined`, never `false` — the difference between
- * "this server trusts every request" and "this server did not say", which
- * a console meeting an older server must not confuse.
- */
-import { describe, expect, it } from "vitest";
-import { createRouterTransport } from "@connectrpc/connect";
-import { create } from "@bufbuild/protobuf";
-import {
-  GetServerInfoOutputSchema,
-  PlatformQueryController,
-  ServerEdition,
-} from "@stigmer/protos/ai/stigmer/platform/v1/server_info_pb";
-
-import { PlatformClient } from "../platform";
-
-function clientAnswering(
-  edition: ServerEdition,
-  authenticationRequired?: boolean,
-): PlatformClient {
-  return new PlatformClient(
-    createRouterTransport(({ service }) => {
-      service(PlatformQueryController, {
-        getServerInfo: () =>
-          create(GetServerInfoOutputSchema, {
-            edition,
-            version: "1.2.3",
-            ...(authenticationRequired !== undefined
-              ? { authenticationRequired }
-              : {}),
-          }),
-      });
-    }),
-  );
-}
-
-describe("PlatformClient.getServerInfo", () => {
-  it.each([
-    [ServerEdition.oss, "local"],
-    [ServerEdition.enterprise, "enterprise"],
-    [ServerEdition.cloud, "cloud"],
-  ] as const)(
-    "maps edition %d to deploymentMode %s and keeps the raw edition",
-    async (edition, mode) => {
-      const info = await clientAnswering(edition).getServerInfo();
-      expect(info.deploymentMode).toBe(mode);
-      expect(info.edition).toBe(edition);
-      expect(info.version).toBe("1.2.3");
-    },
-  );
-
-  it.each([
-    [true, true],
-    [false, false],
-    [undefined, undefined],
-  ] as const)(
-    "reports a server's authentication posture of %s as %s",
-    async (sent, reported) => {
-      const info = await clientAnswering(
-        ServerEdition.cloud,
-        sent,
-      ).getServerInfo();
-      expect(info.authenticationRequired).toBe(reported);
-    },
-  );
-});

package/src/__tests__/plugin.test.ts

@@ -1,92 +0,0 @@
-// Wire-shape tests for RoutedPluginClient's size-routed push: the plugin
-// binding of the shared artifact routing. The routing mechanism itself is
-// pinned by skill.test.ts; these arms pin that the plugin binding reads
-// and rewrites ITS request shape (org, artifact, artifactUploadRef,
-// visibility, message) and mints through ITS createArtifactUploadUrl.
-import { describe, expect, it, vi } from "vitest";
-import { createRouterTransport, type Transport } from "@connectrpc/connect";
-import { create } from "@bufbuild/protobuf";
-import { PluginCommandController } from "@stigmer/protos/ai/stigmer/agentic/plugin/v1/command_pb";
-import { PluginSchema } from "@stigmer/protos/ai/stigmer/agentic/plugin/v1/api_pb";
-import {
-  PluginArtifactUploadUrlSchema,
-  PushPluginRequestSchema,
-  type PushPluginRequest,
-} from "@stigmer/protos/ai/stigmer/agentic/plugin/v1/io_pb";
-import { ApiResourceVisibility } from "@stigmer/protos/ai/stigmer/commons/apiresource/enum_pb";
-import { RoutedPluginClient } from "../plugin.js";
-import { MAX_INLINE_ARTIFACT_BYTES } from "../skill.js";
-
-const STAGING_URL = "http://stage.example/v1/skill-artifacts/uploads/sau_p";
-
-interface Captured {
-  pushes: PushPluginRequest[];
-  mints: number;
-}
-
-function fakeTransport(captured: Captured): Transport {
-  return createRouterTransport(({ service }) => {
-    service(PluginCommandController, {
-      push: (req) => {
-        captured.pushes.push(req);
-        return create(PluginSchema, {});
-      },
-      createArtifactUploadUrl: (req) => {
-        captured.mints++;
-        expect(req.org).toBe("acme");
-        expect(req.sizeBytes).toBeGreaterThan(0n);
-        return create(PluginArtifactUploadUrlSchema, {
-          url: STAGING_URL,
-          artifactUploadRef: "sau_p",
-          ttlSeconds: 900,
-        });
-      },
-    });
-  });
-}
-
-describe("RoutedPluginClient.push size routing", () => {
-  it("keeps a small archive inline", async () => {
-    const captured: Captured = { pushes: [], mints: 0 };
-    const client = new RoutedPluginClient(fakeTransport(captured));
-    await client.push(
-      create(PushPluginRequestSchema, {
-        org: "acme",
-        artifact: new Uint8Array(2048),
-      }),
-    );
-    expect(captured.mints).toBe(0);
-    expect(captured.pushes[0]?.artifact.length).toBe(2048);
-  });
-
-  it("stages a large archive through the plugin's own mint and pushes by reference, keeping the envelope", async () => {
-    const captured: Captured = { pushes: [], mints: 0 };
-    const record: { url?: string; bytes?: number } = {};
-    const fetchImpl = vi.fn(async (url: unknown, init: RequestInit) => {
-      record.url = String(url);
-      record.bytes =
-        init.body instanceof Uint8Array ? init.body.byteLength : -1;
-      return new Response(null, { status: 200 });
-    }) as unknown as typeof globalThis.fetch;
-    const client = new RoutedPluginClient(fakeTransport(captured), fetchImpl);
-    const artifact = new Uint8Array(MAX_INLINE_ARTIFACT_BYTES + 1);
-
-    await client.push(
-      create(PushPluginRequestSchema, {
-        org: "acme",
-        artifact,
-        visibility: ApiResourceVisibility.visibility_org,
-        message: "big",
-      }),
-    );
-
-    expect(captured.mints).toBe(1);
-    expect(record.url).toBe(STAGING_URL);
-    expect(record.bytes).toBe(artifact.length);
-    const pushed = captured.pushes[0]!;
-    expect(pushed.artifact.length).toBe(0);
-    expect(pushed.artifactUploadRef).toBe("sau_p");
-    expect(pushed.visibility).toBe(ApiResourceVisibility.visibility_org);
-    expect(pushed.message).toBe("big");
-  });
-});

package/src/__tests__/resource-availability.test.ts

@@ -1,118 +0,0 @@
-/**
- * Pins the edition vocabulary (`resource-availability.ts`): the one
- * edition-to-mode converter, the rank comparison behind
- * `isResourceAvailable`, and the two properties the DDs assumed and this
- * module has to make true —
- *
- *   - ranks, never wire numbers: `enterprise = 3` sits ABOVE `cloud = 2`
- *     and `cloud_only = 2` on the wire, so a comparison on enum values
- *     would say an Enterprise-tier kind is not served by a Cloud server;
- *   - forward compatibility: an edition value this SDK does not know
- *     (a newer server) maps to `"cloud"` instead of throwing, so an older
- *     console never breaks against a newer server.
- *
- * The kinds named here are chosen one per tier; re-tiering any of them is
- * a contract change and must touch this file (editions program, DD-001).
- */
-import { describe, expect, it } from "vitest";
-import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
-import { ServerEdition } from "@stigmer/protos/ai/stigmer/platform/v1/server_info_pb";
-
-import {
-  deploymentModeOf,
-  isResourceAvailable,
-  type DeploymentMode,
-} from "../resource-availability";
-
-const MODES: readonly DeploymentMode[] = ["local", "enterprise", "cloud"];
-
-describe("deploymentModeOf — the one edition-to-mode converter", () => {
-  it("maps each known edition to its mode", () => {
-    expect(deploymentModeOf(ServerEdition.oss)).toBe("local");
-    expect(deploymentModeOf(ServerEdition.enterprise)).toBe("enterprise");
-    expect(deploymentModeOf(ServerEdition.cloud)).toBe("cloud");
-  });
-
-  it("maps unspecified to cloud — the documented safe default (nothing hidden on a broken server)", () => {
-    expect(deploymentModeOf(ServerEdition.server_edition_unspecified)).toBe(
-      "cloud",
-    );
-  });
-
-  it("maps an edition this SDK does not know to cloud instead of throwing — older client, newer server", () => {
-    // A future fourth edition arrives off the wire as a number the enum
-    // type does not name. The cast is the test's point.
-    expect(deploymentModeOf(99 as ServerEdition)).toBe("cloud");
-  });
-});
-
-describe("isResourceAvailable — a tier is a minimum edition", () => {
-  it("open_source-tier kinds are available in every mode", () => {
-    for (const mode of MODES) {
-      expect(isResourceAvailable(ApiResourceKind.agent, mode), mode).toBe(true);
-    }
-  });
-
-  it("enterprise-tier kinds are available in enterprise and cloud, not local", () => {
-    // `invitation` is the example since `iam_policy` moved to open_source
-    // (20260913.01: the row half is served by every edition).
-    expect(isResourceAvailable(ApiResourceKind.invitation, "local")).toBe(
-      false,
-    );
-    expect(isResourceAvailable(ApiResourceKind.invitation, "enterprise")).toBe(
-      true,
-    );
-    // The inversion case: enterprise = 3 > cloud = 2 on the wire. A
-    // wire-number comparison fails exactly here.
-    expect(isResourceAvailable(ApiResourceKind.invitation, "cloud")).toBe(true);
-  });
-
-  it("iam_policy is open_source since the row half moved into open source — served everywhere", () => {
-    for (const mode of MODES) {
-      expect(isResourceAvailable(ApiResourceKind.iam_policy, mode), mode).toBe(
-        true,
-      );
-    }
-  });
-
-  it("cloud_only-tier kinds are available in cloud only", () => {
-    expect(
-      isResourceAvailable(ApiResourceKind.api_resource_version, "local"),
-    ).toBe(false);
-    expect(
-      isResourceAvailable(ApiResourceKind.api_resource_version, "enterprise"),
-    ).toBe(false);
-    expect(
-      isResourceAvailable(ApiResourceKind.api_resource_version, "cloud"),
-    ).toBe(true);
-  });
-
-  it("the kinds this entry re-tiers read as their new tier", () => {
-    // oauth_app: served by the OSS server; the cloud_only tier was drift.
-    expect(isResourceAvailable(ApiResourceKind.oauth_app, "local")).toBe(true);
-    // platform: the operator seat a self-hosting Enterprise company owns.
-    expect(isResourceAvailable(ApiResourceKind.platform, "local")).toBe(false);
-    expect(isResourceAvailable(ApiResourceKind.platform, "enterprise")).toBe(
-      true,
-    );
-    // identity_account: open_source since the open-source server serves the
-    // domain (20260911.11 slice 5); the tier moved in the same change as
-    // the serving code, never ahead of it.
-    expect(isResourceAvailable(ApiResourceKind.identity_account, "local")).toBe(
-      true,
-    );
-    // agent_share and channel_app: served by OSS; they never moved.
-    expect(isResourceAvailable(ApiResourceKind.agent_share, "local")).toBe(
-      true,
-    );
-    expect(isResourceAvailable(ApiResourceKind.channel_app, "local")).toBe(
-      true,
-    );
-  });
-
-  it("refuses a kind with no tier — a programming error, never silently available", () => {
-    expect(() =>
-      isResourceAvailable(ApiResourceKind.api_resource_kind_unknown, "cloud"),
-    ).toThrow(/no tier/);
-  });
-});

package/src/__tests__/runner-adapter.test.ts

@@ -1,122 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import {
-  createRunnerAdapter,
-  type RunnerWorkerHost,
-} from "../runner-adapter";
-
-function createMockHost(): RunnerWorkerHost & {
-  addSession: ReturnType<typeof vi.fn>;
-  removeSession: ReturnType<typeof vi.fn>;
-  addWorkflowExecution: ReturnType<typeof vi.fn>;
-  removeWorkflowExecution: ReturnType<typeof vi.fn>;
-} {
-  return {
-    addSession: vi.fn().mockResolvedValue(undefined),
-    removeSession: vi.fn().mockResolvedValue(undefined),
-    addWorkflowExecution: vi.fn().mockResolvedValue(undefined),
-    removeWorkflowExecution: vi.fn().mockResolvedValue(undefined),
-  };
-}
-
-describe("createRunnerAdapter", () => {
-  it("returns an adapter with all four lifecycle methods", () => {
-    const adapter = createRunnerAdapter(createMockHost());
-
-    expect(adapter.onSessionOpened).toBeInstanceOf(Function);
-    expect(adapter.onSessionClosed).toBeInstanceOf(Function);
-    expect(adapter.onWorkflowExecutionCreated).toBeInstanceOf(Function);
-    expect(adapter.onWorkflowExecutionTerminated).toBeInstanceOf(Function);
-  });
-
-  it("maps onSessionOpened to host.addSession with the session id", async () => {
-    const host = createMockHost();
-    const adapter = createRunnerAdapter(host);
-
-    await adapter.onSessionOpened("ses-123");
-
-    expect(host.addSession).toHaveBeenCalledTimes(1);
-    expect(host.addSession).toHaveBeenCalledWith("ses-123");
-    // The asymmetric mapping is the footgun this factory exists to prevent:
-    // closing/removing must not fire on open.
-    expect(host.removeSession).not.toHaveBeenCalled();
-  });
-
-  it("maps onSessionClosed to host.removeSession with the session id", async () => {
-    const host = createMockHost();
-    const adapter = createRunnerAdapter(host);
-
-    await adapter.onSessionClosed("ses-123");
-
-    expect(host.removeSession).toHaveBeenCalledTimes(1);
-    expect(host.removeSession).toHaveBeenCalledWith("ses-123");
-    expect(host.addSession).not.toHaveBeenCalled();
-  });
-
-  it("maps onWorkflowExecutionCreated to host.addWorkflowExecution with the execution id", async () => {
-    const host = createMockHost();
-    const adapter = createRunnerAdapter(host);
-
-    await adapter.onWorkflowExecutionCreated("wfexec-456");
-
-    expect(host.addWorkflowExecution).toHaveBeenCalledTimes(1);
-    expect(host.addWorkflowExecution).toHaveBeenCalledWith("wfexec-456");
-    expect(host.removeWorkflowExecution).not.toHaveBeenCalled();
-  });
-
-  it("maps onWorkflowExecutionTerminated to host.removeWorkflowExecution with the execution id", async () => {
-    const host = createMockHost();
-    const adapter = createRunnerAdapter(host);
-
-    await adapter.onWorkflowExecutionTerminated("wfexec-456");
-
-    expect(host.removeWorkflowExecution).toHaveBeenCalledTimes(1);
-    expect(host.removeWorkflowExecution).toHaveBeenCalledWith("wfexec-456");
-    expect(host.addWorkflowExecution).not.toHaveBeenCalled();
-  });
-
-  it("resolves to undefined regardless of the host's return value", async () => {
-    // The host's add methods return a task queue string; the adapter contract
-    // is Promise<void>, so the value must be swallowed.
-    const host = createMockHost();
-    host.addSession.mockResolvedValue("session:ses-123");
-    host.addWorkflowExecution.mockResolvedValue("wfexec:wfexec-456");
-    const adapter = createRunnerAdapter(host);
-
-    await expect(adapter.onSessionOpened("ses-123")).resolves.toBeUndefined();
-    await expect(
-      adapter.onWorkflowExecutionCreated("wfexec-456"),
-    ).resolves.toBeUndefined();
-  });
-
-  it("awaits the host: it does not resolve before the host settles", async () => {
-    let release!: () => void;
-    const gate = new Promise<void>((resolve) => {
-      release = resolve;
-    });
-    const host = createMockHost();
-    host.addSession.mockReturnValue(gate);
-    const adapter = createRunnerAdapter(host);
-
-    let settled = false;
-    const pending = adapter.onSessionOpened("ses-123").then(() => {
-      settled = true;
-    });
-
-    await Promise.resolve();
-    expect(settled).toBe(false);
-
-    release();
-    await pending;
-    expect(settled).toBe(true);
-  });
-
-  it("propagates a host rejection", async () => {
-    const host = createMockHost();
-    host.removeSession.mockRejectedValue(new Error("worker teardown failed"));
-    const adapter = createRunnerAdapter(host);
-
-    await expect(adapter.onSessionClosed("ses-123")).rejects.toThrow(
-      "worker teardown failed",
-    );
-  });
-});

package/src/__tests__/session.test.ts

@@ -1,66 +0,0 @@
-/**
- * Unit tests for the hand-written session utilities: the pinned
- * session-context metadata key and the typed-context merge semantics.
- */
-
-import { describe, it, expect } from "vitest";
-import {
-  SESSION_CONTEXT_METADATA_KEY,
-  mergeSessionContext,
-} from "../session.js";
-
-describe("SESSION_CONTEXT_METADATA_KEY", () => {
-  it("is pinned verbatim to the runner's constant (mirror guard)", () => {
-    // Pinned to SESSION_CONTEXT_METADATA_KEY in
-    // backend/services/runner/src/shared/session-context.ts. Changing
-    // either side alone silently blinds the agent to the embedder's
-    // context; change BOTH together.
-    expect(SESSION_CONTEXT_METADATA_KEY).toBe("stigmer.ai/session-context");
-  });
-});
-
-describe("mergeSessionContext", () => {
-  it("folds the context into the metadata map under the reserved key", () => {
-    expect(mergeSessionContext({ "acme/tenant": "t-1" }, "Role: admin")).toEqual({
-      "acme/tenant": "t-1",
-      [SESSION_CONTEXT_METADATA_KEY]: "Role: admin",
-    });
-  });
-
-  it("creates the map when metadata is undefined", () => {
-    expect(mergeSessionContext(undefined, "Role: admin")).toEqual({
-      [SESSION_CONTEXT_METADATA_KEY]: "Role: admin",
-    });
-  });
-
-  it("lets the typed field win over a raw entry under the reserved key", () => {
-    expect(
-      mergeSessionContext(
-        { [SESSION_CONTEXT_METADATA_KEY]: "stale raw value" },
-        "typed value",
-      ),
-    ).toEqual({ [SESSION_CONTEXT_METADATA_KEY]: "typed value" });
-  });
-
-  it("returns metadata untouched when the context is undefined", () => {
-    const metadata = { "acme/tenant": "t-1" };
-    expect(mergeSessionContext(metadata, undefined)).toBe(metadata);
-  });
-
-  it("returns undefined when both inputs are absent — callers never send an empty map", () => {
-    expect(mergeSessionContext(undefined, undefined)).toBeUndefined();
-    expect(mergeSessionContext(undefined, "   ")).toBeUndefined();
-  });
-
-  it("trims the context before storing (blank means absent)", () => {
-    expect(mergeSessionContext(undefined, "  Role: admin  ")).toEqual({
-      [SESSION_CONTEXT_METADATA_KEY]: "Role: admin",
-    });
-  });
-
-  it("does not mutate the caller's metadata map", () => {
-    const metadata = { "acme/tenant": "t-1" };
-    mergeSessionContext(metadata, "Role: admin");
-    expect(metadata).toEqual({ "acme/tenant": "t-1" });
-  });
-});

package/src/__tests__/sharing.test.ts

@@ -1,159 +0,0 @@
-// Unit tests for the framework-free agent-sharing helpers: origin
-// validation (mirror of the proto CEL rule) and the hosted-link / embed
-// snippet builders shared by the web console, desktop app, and CLI.
-
-import { describe, expect, it } from "vitest";
-import {
-  LINK_TOKEN_PARAM,
-  MAX_ALLOWED_ORIGINS,
-  appendLinkToken,
-  buildChatUrl,
-  buildEmbedLoaderUrl,
-  buildEmbedSnippet,
-  chatPath,
-  validateOrigin,
-} from "../sharing";
-
-describe("validateOrigin", () => {
-  it("accepts exact web origins", () => {
-    expect(validateOrigin("https://example.com")).toBeNull();
-    expect(validateOrigin("http://example.com")).toBeNull();
-    expect(validateOrigin("https://sub.example.com")).toBeNull();
-    expect(validateOrigin("https://example.com:8443")).toBeNull();
-    expect(validateOrigin("http://localhost:3000")).toBeNull();
-  });
-
-  it("trims surrounding whitespace before validating", () => {
-    expect(validateOrigin("  https://example.com  ")).toBeNull();
-  });
-
-  it("rejects empty input with guidance", () => {
-    expect(validateOrigin("")).toMatch(/Enter an origin/);
-    expect(validateOrigin("   ")).toMatch(/Enter an origin/);
-  });
-
-  it("rejects trailing slashes, paths, queries, and fragments", () => {
-    for (const bad of [
-      "https://example.com/",
-      "https://example.com/path",
-      "https://example.com?q=1",
-      "https://example.com#top",
-    ]) {
-      expect(validateOrigin(bad)).toMatch(/exact web origin/);
-    }
-  });
-
-  it("rejects non-http(s) schemes and bare hosts", () => {
-    expect(validateOrigin("ftp://example.com")).toMatch(/exact web origin/);
-    expect(validateOrigin("example.com")).toMatch(/exact web origin/);
-  });
-
-  it("rejects hostname labels with leading/trailing hyphens", () => {
-    expect(validateOrigin("https://-bad.example.com")).toMatch(/exact web origin/);
-    expect(validateOrigin("https://bad-.example.com")).toMatch(/exact web origin/);
-  });
-
-  it("exposes the proto max_items bound", () => {
-    expect(MAX_ALLOWED_ORIGINS).toBe(32);
-  });
-});
-
-describe("chatPath / buildChatUrl", () => {
-  it("builds the canonical /chat/<org>/<slug> path", () => {
-    expect(chatPath("acme", "support-agent")).toBe("/chat/acme/support-agent");
-  });
-
-  it("builds the absolute hosted chat URL", () => {
-    expect(buildChatUrl("https://app.stigmer.ai", "acme", "support-agent")).toBe(
-      "https://app.stigmer.ai/chat/acme/support-agent",
-    );
-  });
-
-  it("tolerates a trailing slash on the origin", () => {
-    expect(buildChatUrl("https://app.stigmer.ai/", "acme", "support-agent")).toBe(
-      "https://app.stigmer.ai/chat/acme/support-agent",
-    );
-  });
-
-  it("works with localhost origins (local backend)", () => {
-    expect(buildChatUrl("http://localhost:8234", "stigmer", "helper")).toBe(
-      "http://localhost:8234/chat/stigmer/helper",
-    );
-  });
-
-  it("appends ?k= when the share link is locked with a token", () => {
-    expect(chatPath("acme", "support-agent", "tok123")).toBe(
-      "/chat/acme/support-agent?k=tok123",
-    );
-    expect(
-      buildChatUrl("https://app.stigmer.ai", "acme", "support-agent", "tok123"),
-    ).toBe("https://app.stigmer.ai/chat/acme/support-agent?k=tok123");
-  });
-
-  it("url-encodes the token (defense in depth; generated tokens are url-safe)", () => {
-    expect(chatPath("acme", "bot", "a+b/c")).toBe("/chat/acme/bot?k=a%2Bb%2Fc");
-  });
-
-  it("omits ?k= for an empty/undefined token (plain link)", () => {
-    expect(chatPath("acme", "bot", "")).toBe("/chat/acme/bot");
-    expect(chatPath("acme", "bot", undefined)).toBe("/chat/acme/bot");
-  });
-});
-
-describe("appendLinkToken", () => {
-  it("appends the identical ?k= shape chatPath emits", () => {
-    expect(appendLinkToken("https://app.stigmer.ai/chat/acme/bot", "tok123")).toBe(
-      buildChatUrl("https://app.stigmer.ai", "acme", "bot", "tok123"),
-    );
-  });
-
-  it("uses & when the URL already carries a query", () => {
-    expect(appendLinkToken("/chat/acme/bot?theme=dark", "tok123")).toBe(
-      `/chat/acme/bot?theme=dark&${LINK_TOKEN_PARAM}=tok123`,
-    );
-  });
-
-  it("returns the URL unchanged for a null/empty token", () => {
-    expect(appendLinkToken("/chat/acme/bot", null)).toBe("/chat/acme/bot");
-    expect(appendLinkToken("/chat/acme/bot", undefined)).toBe("/chat/acme/bot");
-    expect(appendLinkToken("/chat/acme/bot", "")).toBe("/chat/acme/bot");
-  });
-});
-
-describe("buildEmbedLoaderUrl", () => {
-  it("points at embed.js on the app origin root", () => {
-    expect(buildEmbedLoaderUrl("https://app.stigmer.ai")).toBe("https://app.stigmer.ai/embed.js");
-  });
-
-  it("tolerates a trailing slash on the origin", () => {
-    expect(buildEmbedLoaderUrl("https://app.stigmer.ai/")).toBe("https://app.stigmer.ai/embed.js");
-  });
-});
-
-describe("buildEmbedSnippet", () => {
-  it("emits exactly the two-line loader + element snippet", () => {
-    expect(buildEmbedSnippet("https://app.stigmer.ai", "acme", "support-agent")).toBe(
-      [
-        `<script src="https://app.stigmer.ai/embed.js" async></script>`,
-        `<stigmer-agent org="acme" agent="support-agent"></stigmer-agent>`,
-      ].join("\n"),
-    );
-  });
-
-  it("adds the token attribute when the share link is locked", () => {
-    expect(
-      buildEmbedSnippet("https://app.stigmer.ai", "acme", "support-agent", "tok123"),
-    ).toBe(
-      [
-        `<script src="https://app.stigmer.ai/embed.js" async></script>`,
-        `<stigmer-agent org="acme" agent="support-agent" token="tok123"></stigmer-agent>`,
-      ].join("\n"),
-    );
-  });
-
-  it("omits the token attribute for an empty token (plain link)", () => {
-    expect(buildEmbedSnippet("https://app.stigmer.ai", "acme", "bot", "")).toBe(
-      buildEmbedSnippet("https://app.stigmer.ai", "acme", "bot"),
-    );
-  });
-});