@stigmer/sdk 3.35.0 → 3.37.0

package/src/__tests__/manifest.test.ts

@@ -1,362 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { clone, create, equals } from "@bufbuild/protobuf";
-import { AgentSchema, type Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
-import { EnvironmentSchema, type Environment } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
-import { ScheduleSchema, type Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
-import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
-import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
-import { parse as parseYaml } from "yaml";
-import { parseManifest } from "../manifest/parse";
-import { serializeManifest } from "../manifest/serialize";
-import { manifestDocumentForResource } from "../manifest/document";
-import { manifestKinds, manifestHandlerForYamlKind } from "../manifest/registry";
-
-/**
- * Manifest engine contract tests.
- *
- * The engine's core promise is *round-trip fidelity against the generated
- * proto schemas*: any resource the server returns serializes to YAML that
- * parses back to the same proto (minus system-managed state), and any
- * repo-authored manifest (snake_case fields, `apiVersion` spelling) parses
- * to a proto the `apply` RPC accepts. Fixtures mirror the real manifests
- * in the whatsapp-doctor-assistant dogfooding repo.
- */
-
-// ---------------------------------------------------------------------------
-// Fixtures — shaped like the whatsapp-doctor-assistant repo manifests
-// ---------------------------------------------------------------------------
-
-const AGENT_YAML = `
-apiVersion: agentic.stigmer.ai/v1
-kind: Agent
-metadata:
-  name: clinic-patient-assistant
-  org: rakeshreddi098
-spec:
-  description: Patient-facing WhatsApp assistant for the clinic.
-  instructions: |
-    You are the appointment assistant for the clinic.
-    Short messages. One question at a time.
-`;
-
-const ENVIRONMENT_YAML = `
-apiVersion: agentic.stigmer.ai/v1
-kind: Environment
-metadata:
-  name: clinic-patient-db
-  org: rakeshreddi098
-spec:
-  description: "Clinic records access for the patient assistant"
-  data:
-    POSTGRES_CONNECTION_URL:
-      value: "postgresql://patient_role:secret@host:5432/postgres"
-      is_secret: true
-      description: "Supabase Postgres connection URL for patient_role"
-`;
-
-const AGENT_CHANNEL_YAML = `
-apiVersion: agentic.stigmer.ai/v1
-kind: AgentChannel
-metadata:
-  name: clinic-patient-whatsapp
-  org: rakeshreddi098
-spec:
-  agent_ref:
-    kind: agent
-    org: rakeshreddi098
-    slug: clinic-patient-assistant
-  enabled: true
-  whatsapp:
-    phone_number_id: "1234567890"
-  app_ref:
-    kind: channel_app
-    org: rakeshreddi098
-    slug: hosipital
-  environment_refs:
-    - kind: environment
-      org: rakeshreddi098
-      slug: clinic-patient-db
-`;
-
-// ---------------------------------------------------------------------------
-// parseManifest
-// ---------------------------------------------------------------------------
-
-describe("parseManifest", () => {
-  it("parses a snake_case Agent manifest into a full Agent proto", () => {
-    const docs = parseManifest(AGENT_YAML);
-    expect(docs).toHaveLength(1);
-
-    const doc = docs[0];
-    expect(doc.handler.yamlKind).toBe("Agent");
-    expect(doc.name).toBe("clinic-patient-assistant");
-    expect(doc.org).toBe("rakeshreddi098");
-
-    const agent = doc.message as Agent;
-    expect(agent.spec?.description).toBe(
-      "Patient-facing WhatsApp assistant for the clinic.",
-    );
-    expect(agent.spec?.instructions).toContain("appointment assistant");
-  });
-
-  it("parses an AgentChannel manifest with enum-valued resource refs", () => {
-    const docs = parseManifest(AGENT_CHANNEL_YAML);
-    expect(docs).toHaveLength(1);
-    expect(docs[0].handler.yamlKind).toBe("AgentChannel");
-    expect(docs[0].slug).toBe("clinic-patient-whatsapp");
-  });
-
-  it("sorts multi-document manifests into dependency apply order", () => {
-    // Authored channel-first; the Environment must still apply first.
-    const docs = parseManifest(`${AGENT_CHANNEL_YAML}\n---\n${ENVIRONMENT_YAML}`);
-    expect(docs.map((d) => d.handler.yamlKind)).toEqual([
-      "Environment",
-      "AgentChannel",
-    ]);
-  });
-
-  it("injects the target org when the document omits it", () => {
-    const yaml = AGENT_YAML.replace("  org: rakeshreddi098\n", "");
-    const docs = parseManifest(yaml, { org: "acme" });
-    expect(docs[0].org).toBe("acme");
-    expect(docs[0].warning).toBeUndefined();
-  });
-
-  it("honors the document org and warns when it differs from the target", () => {
-    const docs = parseManifest(AGENT_YAML, { org: "acme" });
-    expect(docs[0].org).toBe("rakeshreddi098");
-    expect(docs[0].warning).toContain('"rakeshreddi098"');
-    expect(docs[0].warning).toContain('"acme"');
-  });
-
-  it("rejects unknown fields loudly (strict schema contract)", () => {
-    const yaml = AGENT_YAML.replace("spec:", "spec:\n  instrctions: typo");
-    expect(() => parseManifest(yaml)).toThrow(/Invalid Agent/);
-  });
-
-  it("rejects a document without a kind", () => {
-    expect(() => parseManifest("metadata:\n  name: x\n")).toThrow(/'kind'/);
-  });
-
-  it("rejects unsupported kinds with the supported list", () => {
-    expect(() => parseManifest("kind: Skill\nmetadata:\n  name: x\n")).toThrow(
-      /Unsupported resource kind "Skill".*Agent/s,
-    );
-  });
-
-  it("rejects empty input with actionable guidance", () => {
-    expect(() => parseManifest("   \n")).toThrow(/empty/i);
-  });
-
-  it("rejects malformed YAML", () => {
-    expect(() => parseManifest("kind: Agent\n  bad indent: [")).toThrow(
-      /Invalid YAML/,
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// serializeManifest
-// ---------------------------------------------------------------------------
-
-describe("serializeManifest", () => {
-  const agent = create(AgentSchema, {
-    apiVersion: "agentic.stigmer.ai/v1",
-    kind: "Agent",
-    metadata: {
-      id: "agt_01example",
-      name: "clinic-patient-assistant",
-      slug: "clinic-patient-assistant",
-      org: "rakeshreddi098",
-      version: { id: "ver_01", message: "server-managed" },
-    },
-    spec: {
-      description: "Patient-facing WhatsApp assistant.",
-      instructions: "Short messages.\nOne question at a time.\n",
-    },
-    status: { defaultInstanceId: "agi_01example" },
-  });
-
-  it("emits the canonical envelope: apiVersion spelling, no status", () => {
-    const yaml = serializeManifest(agent);
-    const doc = parseYaml(yaml) as Record<string, unknown>;
-
-    expect(Object.keys(doc)[0]).toBe("apiVersion");
-    expect(doc.apiVersion).toBe("agentic.stigmer.ai/v1");
-    expect(doc.kind).toBe("Agent");
-    expect(doc.status).toBeUndefined();
-    expect(yaml).not.toContain("api_version:");
-  });
-
-  it("keeps metadata.id but strips server-managed metadata.version", () => {
-    const doc = parseYaml(serializeManifest(agent)) as {
-      metadata: Record<string, unknown>;
-    };
-    expect(doc.metadata.id).toBe("agt_01example");
-    expect(doc.metadata.version).toBeUndefined();
-  });
-
-  it("fills apiVersion and kind from the registry when the proto omits them", () => {
-    const bare = create(AgentSchema, {
-      metadata: { name: "x", org: "acme" },
-    });
-    const doc = parseYaml(serializeManifest(bare)) as Record<string, unknown>;
-    expect(doc.apiVersion).toBe("agentic.stigmer.ai/v1");
-    expect(doc.kind).toBe("Agent");
-  });
-
-  it("round-trips through parseManifest to an equal proto", () => {
-    const docs = parseManifest(serializeManifest(agent));
-    expect(docs).toHaveLength(1);
-
-    // The round-tripped proto matches the original minus system-managed
-    // state (status, metadata.version) — exactly what apply consumes.
-    const expected = create(AgentSchema, {
-      ...agent,
-      status: undefined,
-      metadata: { ...agent.metadata!, version: undefined },
-    });
-    expect(equals(AgentSchema, docs[0].message as Agent, expected)).toBe(true);
-  });
-
-  it("round-trips Environment secret values byte-identically", () => {
-    const env = create(EnvironmentSchema, {
-      metadata: { name: "clinic-patient-db", org: "rakeshreddi098" },
-      spec: {
-        data: {
-          POSTGRES_CONNECTION_URL: {
-            value: "***REDACTED***",
-            isSecret: true,
-            description: "Supabase Postgres connection URL",
-          },
-        },
-      },
-    });
-
-    const docs = parseManifest(serializeManifest(env));
-    const roundTripped = docs[0].message as Environment;
-    expect(roundTripped.spec?.data.POSTGRES_CONNECTION_URL?.value).toBe(
-      "***REDACTED***",
-    );
-    expect(roundTripped.spec?.data.POSTGRES_CONNECTION_URL?.isSecret).toBe(true);
-  });
-
-  it("rejects messages of kinds outside the registry", () => {
-    // ApiResourceMetadata is a real proto message but not a manifest kind.
-    const notAResource = create(ApiResourceMetadataSchema, { name: "x" });
-    expect(() => serializeManifest(notAResource)).toThrow(/not.*registry/i);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// manifestDocumentForResource
-// ---------------------------------------------------------------------------
-
-describe("manifestDocumentForResource", () => {
-  // Shaped like a server-returned schedule: full metadata (including
-  // fields the curated ScheduleInput cannot express, like tags) and a
-  // populated status — the exact input of a lossless partial edit.
-  const schedule = create(ScheduleSchema, {
-    apiVersion: "agentic.stigmer.ai/v1",
-    kind: "Schedule",
-    metadata: {
-      id: "sch_01example",
-      name: "daily-fee-reminders",
-      slug: "daily-fee-reminders",
-      org: "isc",
-      tags: ["billing"],
-      labels: { team: "ops" },
-    },
-    spec: {
-      cron: "0 9 * * *",
-      timeZone: "Asia/Kolkata",
-      enabled: true,
-      target: {
-        case: "agent",
-        value: {
-          agentRef: { kind: ApiResourceKind.agent, org: "isc", slug: "fee-reminder" },
-          message: "Send today's fee reminders.",
-        },
-      },
-    },
-    status: { consecutiveFailures: 2, pausedReason: "" },
-  });
-
-  it("wraps a fetched proto untouched — the lossless edit contract", () => {
-    const flipped = clone(ScheduleSchema, schedule);
-    flipped.spec!.enabled = false;
-
-    const doc = manifestDocumentForResource(flipped);
-
-    expect(doc.handler.yamlKind).toBe("Schedule");
-    expect(doc.name).toBe("daily-fee-reminders");
-    expect(doc.slug).toBe("daily-fee-reminders");
-    expect(doc.org).toBe("isc");
-    // Identity, not a copy: nothing is re-serialized or down-converted,
-    // so every field survives (the ScheduleInput path would drop tags).
-    expect(doc.message).toBe(flipped);
-
-    const expected = clone(ScheduleSchema, schedule);
-    expected.spec!.enabled = false;
-    expect(equals(ScheduleSchema, doc.message as Schedule, expected)).toBe(true);
-  });
-
-  it("falls back to name when the proto has no slug", () => {
-    const bare = create(AgentSchema, { metadata: { name: "x", org: "acme" } });
-    const doc = manifestDocumentForResource(bare);
-    expect(doc.slug).toBe("x");
-  });
-
-  it("rejects messages of kinds outside the registry", () => {
-    const notAResource = create(ApiResourceMetadataSchema, { name: "x" });
-    expect(() => manifestDocumentForResource(notAResource)).toThrow(
-      /not.*registry/i,
-    );
-  });
-
-  it("rejects a resource without metadata.name", () => {
-    const nameless = create(ScheduleSchema, { metadata: { org: "acme" } });
-    expect(() => manifestDocumentForResource(nameless)).toThrow(
-      /metadata\.name/,
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Registry invariants
-// ---------------------------------------------------------------------------
-
-describe("manifest registry", () => {
-  it("every handler resolves by its own YAML kind", () => {
-    for (const handler of manifestKinds()) {
-      expect(manifestHandlerForYamlKind(handler.yamlKind)).toBe(handler);
-    }
-  });
-
-  it("apply order is strictly increasing (no accidental ties)", () => {
-    const orders = manifestKinds().map((h) => h.applyOrder);
-    for (let i = 1; i < orders.length; i++) {
-      expect(orders[i]).toBeGreaterThan(orders[i - 1]);
-    }
-  });
-
-  it("covers the kinds the console flows depend on", () => {
-    for (const kind of ["Agent", "McpServer", "Workflow", "Environment", "AgentChannel", "ChannelApp"]) {
-      expect(manifestHandlerForYamlKind(kind), `missing handler for ${kind}`).toBeDefined();
-    }
-  });
-
-  it("declares the updateVisibility binding on exactly the guarded-RPC kinds (oss#573)", () => {
-    // Visibility changes go through the updateVisibility RPC only (plain
-    // updates preserve stored visibility on both editions). The binding set
-    // mirrors the kinds whose proto VisibilityConfig grants non-private
-    // levels, minus Skill (push flow, not a manifest kind) — a kind added
-    // here without the RPC fails at compile time, one dropped from here
-    // silently strands manifest-declared visibility, which this pins.
-    const withBinding = manifestKinds()
-      .filter((h) => h.updateVisibility !== undefined)
-      .map((h) => h.yamlKind)
-      .sort();
-    expect(withBinding).toEqual(["Agent", "AgentInstance", "Environment", "McpServer", "Workflow"]);
-  });
-});

package/src/__tests__/mcpserver-connect.test.ts

@@ -1,181 +0,0 @@
-// Pins the shared async-connect protocol (stigmer/stigmer#425): start + poll,
-// terminal-failure rehydration, the UNIMPLEMENTED blocking fallback, and the
-// still-running bound. Every SDK surface (CLI, React hooks, host apps) rides
-// this one implementation, so its contract is pinned here rather than
-// re-tested per consumer.
-
-import { describe, expect, it } from "vitest";
-import { create } from "@bufbuild/protobuf";
-import { Code, ConnectError } from "@connectrpc/connect";
-import { McpServerSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
-import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
-import { ConnectInputSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/io_pb";
-import { ConnectPhase } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/status_pb";
-import { StigmerError, wrapError } from "../gen/errors.js";
-import {
-  connectAndWait,
-  ConnectStillRunningError,
-  type McpServerConnectLane,
-} from "../mcpserver-connect.js";
-
-const INPUT = create(ConnectInputSchema, { mcpServerId: "mcp-1", org: "test-org" });
-
-function server(overrides?: {
-  phase?: ConnectPhase;
-  failureCode?: string;
-  failureMessage?: string;
-  warning?: string;
-  toolName?: string;
-}): McpServer {
-  return create(McpServerSchema, {
-    metadata: { id: "mcp-1", name: "Test Server" },
-    status: {
-      ...(overrides?.toolName !== undefined
-        ? { discoveredCapabilities: { tools: [{ name: overrides.toolName }] } }
-        : {}),
-      connectStatus: {
-        phase: overrides?.phase ?? ConnectPhase.connecting,
-        workflowId: "stigmer/mcp-server/connect/mcp-1",
-        failureCode: overrides?.failureCode ?? "",
-        failureMessage: overrides?.failureMessage ?? "",
-        warning: overrides?.warning ?? "",
-      },
-    },
-  });
-}
-
-function unimplemented(): StigmerError {
-  return wrapError(new ConnectError("startConnect is not implemented", Code.Unimplemented));
-}
-
-const NEVER = () => new Promise<McpServer>(() => {});
-
-describe("connectAndWait", () => {
-  it("resolves with the settled resource once connect_status reports success", async () => {
-    const polled = [
-      server({ phase: ConnectPhase.connecting }),
-      server({ phase: ConnectPhase.succeeded, toolName: "search_code" }),
-    ];
-    const lane: McpServerConnectLane = {
-      startConnect: async () => server(),
-      connect: NEVER,
-      get: async () => polled.shift() ?? server({ phase: ConnectPhase.succeeded }),
-    };
-
-    const settled = await connectAndWait(lane, INPUT, { pollIntervalMs: 1 });
-    expect(settled.status?.connectStatus?.phase).toBe(ConnectPhase.succeeded);
-    expect(settled.status?.discoveredCapabilities?.tools[0]?.name).toBe("search_code");
-  });
-
-  it("surfaces the CONNECTING snapshot (dead-runner warning) via onStarted", async () => {
-    const lane: McpServerConnectLane = {
-      startConnect: async () => server({ warning: "no runner appears to be polling the task queue" }),
-      connect: NEVER,
-      get: async () => server({ phase: ConnectPhase.succeeded }),
-    };
-
-    let warning = "";
-    await connectAndWait(lane, INPUT, {
-      pollIntervalMs: 1,
-      onStarted: (started) => {
-        warning = started.status?.connectStatus?.warning ?? "";
-      },
-    });
-    expect(warning).toContain("no runner");
-  });
-
-  it("rehydrates a failed operation into the classification the blocking RPC would have thrown", async () => {
-    const lane: McpServerConnectLane = {
-      startConnect: async () => server(),
-      connect: NEVER,
-      get: async () =>
-        server({
-          phase: ConnectPhase.failed,
-          failureCode: "FailedPrecondition",
-          failureMessage: "connect failed for MCP server 'Test Server': missing credentials",
-        }),
-    };
-
-    const err = await connectAndWait(lane, INPUT, { pollIntervalMs: 1 }).catch((e: unknown) => e);
-    expect(err).toBeInstanceOf(StigmerError);
-    const stigmerErr = err as StigmerError;
-    // Byte-parity with the blocking lane: same code mapping, same raw message.
-    expect(stigmerErr.code).toBe("failed-precondition");
-    expect(stigmerErr.message).toBe("connect failed for MCP server 'Test Server': missing credentials");
-  });
-
-  it("maps an unknown failure_code to the unknown classification instead of crashing", async () => {
-    const lane: McpServerConnectLane = {
-      startConnect: async () => server(),
-      connect: NEVER,
-      get: async () =>
-        server({
-          phase: ConnectPhase.failed,
-          failureCode: "SomeFutureCode",
-          failureMessage: "boom",
-        }),
-    };
-
-    const err = await connectAndWait(lane, INPUT, { pollIntervalMs: 1 }).catch((e: unknown) => e);
-    expect((err as StigmerError).code).toBe("unknown");
-    expect((err as StigmerError).message).toBe("boom");
-  });
-
-  it("falls back to the blocking connect when the backend answers UNIMPLEMENTED", async () => {
-    let blockingCalled = false;
-    const lane: McpServerConnectLane = {
-      startConnect: async () => {
-        throw unimplemented();
-      },
-      connect: async () => {
-        blockingCalled = true;
-        return server({ phase: ConnectPhase.succeeded, toolName: "search_code" });
-      },
-      get: NEVER,
-    };
-
-    const settled = await connectAndWait(lane, INPUT);
-    expect(blockingCalled).toBe(true);
-    expect(settled.status?.discoveredCapabilities?.tools[0]?.name).toBe("search_code");
-  });
-
-  it("propagates non-UNIMPLEMENTED start failures untouched", async () => {
-    const startFailure = wrapError(new ConnectError("no such server", Code.NotFound));
-    const lane: McpServerConnectLane = {
-      startConnect: async () => {
-        throw startFailure;
-      },
-      connect: NEVER,
-      get: NEVER,
-    };
-
-    await expect(connectAndWait(lane, INPUT)).rejects.toBe(startFailure);
-  });
-
-  it("throws ConnectStillRunningError when the deadline elapses while CONNECTING", async () => {
-    const lane: McpServerConnectLane = {
-      startConnect: async () => server(),
-      connect: NEVER,
-      get: async () => server({ phase: ConnectPhase.connecting }),
-    };
-
-    const err = await connectAndWait(lane, INPUT, { pollIntervalMs: 1, deadlineMs: 20 }).catch(
-      (e: unknown) => e,
-    );
-    expect(err).toBeInstanceOf(ConnectStillRunningError);
-    expect((err as ConnectStillRunningError).mcpServerId).toBe("mcp-1");
-  });
-
-  it("bounds the blocking fallback with the same still-running semantics (soft, non-cancelling)", async () => {
-    const lane: McpServerConnectLane = {
-      startConnect: async () => {
-        throw unimplemented();
-      },
-      connect: NEVER,
-      get: NEVER,
-    };
-
-    const err = await connectAndWait(lane, INPUT, { deadlineMs: 20 }).catch((e: unknown) => e);
-    expect(err).toBeInstanceOf(ConnectStillRunningError);
-  });
-});

package/src/__tests__/node.test.ts

@@ -1,74 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createNodeClient, createNodeTransport } from "../node";
-
-describe("createNodeTransport", () => {
-  it("creates a transport with an API key", () => {
-    const transport = createNodeTransport({
-      baseUrl: "https://api.stigmer.ai",
-      apiKey: "sk_test_123",
-    });
-    expect(transport).toBeDefined();
-  });
-
-  it("creates a transport with a token provider", () => {
-    const transport = createNodeTransport({
-      baseUrl: "https://api.stigmer.ai",
-      getAccessToken: () => "token_abc",
-    });
-    expect(transport).toBeDefined();
-  });
-
-  it("creates a transport without auth", () => {
-    const transport = createNodeTransport({
-      baseUrl: "https://api.stigmer.ai",
-    });
-    expect(transport).toBeDefined();
-  });
-
-  it("creates a native gRPC transport when protocol is grpc", () => {
-    const transport = createNodeTransport({
-      baseUrl: "https://api.stigmer.ai",
-      apiKey: "sk_test_123",
-      protocol: "grpc",
-    });
-    expect(transport).toBeDefined();
-  });
-
-  it("defaults to gRPC-web when protocol is omitted", () => {
-    const transport = createNodeTransport({
-      baseUrl: "https://api.stigmer.ai",
-      protocol: "grpc-web",
-    });
-    expect(transport).toBeDefined();
-  });
-});
-
-describe("createNodeClient", () => {
-  it("creates a Stigmer client with API key", () => {
-    const client = createNodeClient({
-      baseUrl: "https://api.stigmer.ai",
-      apiKey: "sk_test_123",
-    });
-    expect(client).toBeDefined();
-    expect(client.baseUrl).toBe("https://api.stigmer.ai");
-  });
-
-  it("creates a Stigmer client with token provider", () => {
-    const client = createNodeClient({
-      baseUrl: "https://api.stigmer.ai",
-      getAccessToken: () => "token_abc",
-    });
-    expect(client).toBeDefined();
-    expect(client.baseUrl).toBe("https://api.stigmer.ai");
-  });
-
-  it("exposes resource sub-clients", () => {
-    const client = createNodeClient({
-      baseUrl: "https://api.stigmer.ai",
-      apiKey: "sk_test_123",
-    });
-    expect(client.agent).toBeDefined();
-    expect(client.session).toBeDefined();
-    expect(client.agentExecution).toBeDefined();
-  });
-});

package/src/__tests__/platform-client-auth.test.ts

@@ -1,76 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  createPlatformClientAuth,
-  PlatformClientAuth,
-} from "../platform-client-auth";
-
-describe("createPlatformClientAuth", () => {
-  it("throws when baseUrl is missing", () => {
-    expect(() =>
-      createPlatformClientAuth({
-        baseUrl: "",
-        clientId: "stgm_cid_abc",
-        clientSecret: "stgm_cs_xyz",
-      }),
-    ).toThrow("baseUrl is required");
-  });
-
-  it("throws when clientId is missing", () => {
-    expect(() =>
-      createPlatformClientAuth({
-        baseUrl: "https://api.stigmer.ai",
-        clientId: "",
-        clientSecret: "stgm_cs_xyz",
-      }),
-    ).toThrow("clientId is required");
-  });
-
-  it("throws when clientSecret is missing", () => {
-    expect(() =>
-      createPlatformClientAuth({
-        baseUrl: "https://api.stigmer.ai",
-        clientId: "stgm_cid_abc",
-        clientSecret: "",
-      }),
-    ).toThrow("clientSecret is required");
-  });
-
-  it("returns a PlatformClientAuth instance with valid config", () => {
-    const auth = createPlatformClientAuth({
-      baseUrl: "https://api.stigmer.ai",
-      clientId: "stgm_cid_abc",
-      clientSecret: "stgm_cs_xyz",
-    });
-    expect(auth).toBeInstanceOf(PlatformClientAuth);
-  });
-});
-
-describe("PlatformClientAuth.mintUserToken", () => {
-  it("throws StigmerError when userId is empty", async () => {
-    const auth = createPlatformClientAuth({
-      baseUrl: "https://api.stigmer.ai",
-      clientId: "stgm_cid_abc",
-      clientSecret: "stgm_cs_xyz",
-    });
-
-    await expect(
-      auth.mintUserToken({ userId: "" }),
-    ).rejects.toThrow("userId is required");
-  });
-
-  it("throws StigmerError with invalid-argument code when userId is empty", async () => {
-    const auth = createPlatformClientAuth({
-      baseUrl: "https://api.stigmer.ai",
-      clientId: "stgm_cid_abc",
-      clientSecret: "stgm_cs_xyz",
-    });
-
-    try {
-      await auth.mintUserToken({ userId: "" });
-      expect.fail("should have thrown");
-    } catch (e: unknown) {
-      expect(e).toHaveProperty("code", "invalid-argument");
-      expect(e).toHaveProperty("name", "StigmerError");
-    }
-  });
-});