@stigmer/react 3.1.16 → 3.2.0

package/src/channel/__tests__/useAgentChannel.test.tsx

@@ -0,0 +1,116 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { StigmerError } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { useAgentChannel } from "../useAgentChannel";
+
+function createMockStigmer(overrides: {
+  get?: (id: string) => Promise<unknown>;
+} = {}) {
+  return {
+    agentChannel: {
+      get: overrides.get ?? vi.fn().mockResolvedValue(null),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <FetchCacheContext.Provider value={null}>
+        <StigmerContext.Provider value={client as never}>
+          {children}
+        </StigmerContext.Provider>
+      </FetchCacheContext.Provider>
+    );
+  };
+}
+
+describe("useAgentChannel", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("loads a channel by id", async () => {
+    const channel = {
+      metadata: { id: "ach_1", org: "acme", slug: "support-slack" },
+      spec: { enabled: true },
+    };
+    const get = vi.fn().mockResolvedValue(channel);
+    const client = createMockStigmer({ get });
+
+    const { result } = renderHook(() => useAgentChannel("ach_1"), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.isLoading).toBe(true);
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.channel).toEqual(channel);
+    expect(result.current.error).toBeNull();
+    expect(get).toHaveBeenCalledWith("ach_1");
+  });
+
+  it("maps not-found to null data, not an error", async () => {
+    const get = vi
+      .fn()
+      .mockRejectedValue(new StigmerError("not-found", "AgentChannel not found: ach_1", 5));
+    const client = createMockStigmer({ get });
+
+    const { result } = renderHook(() => useAgentChannel("ach_1"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    // A deleted channel is a renderable state (e.g. removed in another
+    // tab), not an error condition.
+    expect(result.current.channel).toBeNull();
+    expect(result.current.error).toBeNull();
+  });
+
+  it("exposes non-not-found failures as errors", async () => {
+    const get = vi
+      .fn()
+      .mockRejectedValue(new StigmerError("internal", "boom", 13));
+    const client = createMockStigmer({ get });
+
+    const { result } = renderHook(() => useAgentChannel("ach_1"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeTruthy();
+    expect(result.current.channel).toBeNull();
+  });
+
+  it("skips fetching while the id is empty (stable no-op)", () => {
+    const get = vi.fn();
+    const client = createMockStigmer({ get });
+
+    const { result } = renderHook(() => useAgentChannel(""), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.channel).toBeNull();
+    expect(get).not.toHaveBeenCalled();
+  });
+
+  it("refetches on demand", async () => {
+    const get = vi.fn().mockResolvedValue({ metadata: { id: "ach_1" } });
+    const client = createMockStigmer({ get });
+
+    const { result } = renderHook(() => useAgentChannel("ach_1"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(get).toHaveBeenCalledTimes(1);
+
+    result.current.refetch();
+    await waitFor(() => expect(get).toHaveBeenCalledTimes(2));
+  });
+});

package/src/channel/__tests__/useAgentChannelList.test.tsx

@@ -0,0 +1,166 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import type { GetAgentChannelsByAgentRequest } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/io_pb";
+import { StigmerContext } from "../../context";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { useAgentChannelList } from "../useAgentChannelList";
+
+function createMockStigmer(overrides: {
+  getByAgent?: (input: GetAgentChannelsByAgentRequest) => Promise<unknown>;
+} = {}) {
+  return {
+    agentChannel: {
+      getByAgent:
+        overrides.getByAgent ??
+        vi.fn().mockResolvedValue({ totalCount: 0, items: [] }),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <FetchCacheContext.Provider value={null}>
+        <StigmerContext.Provider value={client as never}>
+          {children}
+        </StigmerContext.Provider>
+      </FetchCacheContext.Provider>
+    );
+  };
+}
+
+function makeChannel(org: string, slug: string, id = `ach_${org}_${slug}`) {
+  return {
+    metadata: { id, org, slug },
+    spec: { enabled: true },
+    status: { installState: 2 },
+  };
+}
+
+describe("useAgentChannelList", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("loads the agent's channels by agent id", async () => {
+    const channel = makeChannel("acme", "support-agent-slack");
+    const getByAgent = vi
+      .fn()
+      .mockResolvedValue({ totalCount: 1, items: [channel] });
+    const client = createMockStigmer({ getByAgent });
+
+    const { result } = renderHook(() => useAgentChannelList("agt_1"), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.isLoading).toBe(true);
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.channels).toEqual([channel]);
+    expect(result.current.error).toBeNull();
+    expect(getByAgent).toHaveBeenCalledWith(
+      expect.objectContaining({ agentId: "agt_1", org: "" }),
+    );
+  });
+
+  it("threads the org scope into the request", async () => {
+    // The org scope belongs in the RPC, never client-side filtering: the
+    // server narrows a multi-org member's view to one org's channels.
+    const getByAgent = vi
+      .fn()
+      .mockResolvedValue({ totalCount: 0, items: [] });
+    const client = createMockStigmer({ getByAgent });
+
+    const { result } = renderHook(
+      () => useAgentChannelList("agt_1", "acme"),
+      { wrapper: wrapper(client) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(getByAgent).toHaveBeenCalledWith(
+      expect.objectContaining({ agentId: "agt_1", org: "acme" }),
+    );
+  });
+
+  it("refetches when the org scope changes", async () => {
+    const getByAgent = vi
+      .fn()
+      .mockResolvedValue({ totalCount: 0, items: [] });
+    const client = createMockStigmer({ getByAgent });
+
+    const { result, rerender } = renderHook(
+      ({ org }: { org: string }) => useAgentChannelList("agt_1", org),
+      { wrapper: wrapper(client), initialProps: { org: "acme" } },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(getByAgent).toHaveBeenCalledTimes(1);
+
+    rerender({ org: "consumer-org" });
+    await waitFor(() => expect(getByAgent).toHaveBeenCalledTimes(2));
+    expect(getByAgent).toHaveBeenLastCalledWith(
+      expect.objectContaining({ agentId: "agt_1", org: "consumer-org" }),
+    );
+  });
+
+  it("resolves empty (no channels yet) when the agent has no channels", async () => {
+    const client = createMockStigmer();
+
+    const { result } = renderHook(() => useAgentChannelList("agt_1"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    // The no-channel state is not an error: connecting the first channel
+    // is the empty state's call to action.
+    expect(result.current.channels).toEqual([]);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("skips fetching while the agent id is empty (stable no-op)", () => {
+    const getByAgent = vi.fn();
+    const client = createMockStigmer({ getByAgent });
+
+    const { result } = renderHook(() => useAgentChannelList(""), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.channels).toEqual([]);
+    expect(getByAgent).not.toHaveBeenCalled();
+  });
+
+  it("exposes fetch failures as errors", async () => {
+    const getByAgent = vi
+      .fn()
+      .mockRejectedValue(new Error("backend unavailable"));
+    const client = createMockStigmer({ getByAgent });
+
+    const { result } = renderHook(() => useAgentChannelList("agt_1"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeTruthy();
+    expect(result.current.channels).toEqual([]);
+  });
+
+  it("refetches on demand", async () => {
+    const getByAgent = vi
+      .fn()
+      .mockResolvedValue({ totalCount: 0, items: [] });
+    const client = createMockStigmer({ getByAgent });
+
+    const { result } = renderHook(() => useAgentChannelList("agt_1"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(getByAgent).toHaveBeenCalledTimes(1);
+
+    result.current.refetch();
+    await waitFor(() => expect(getByAgent).toHaveBeenCalledTimes(2));
+  });
+});

package/src/channel/__tests__/useChannelSessions.test.tsx

@@ -0,0 +1,95 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import type { ListSessionsByChannelRequest } from "@stigmer/protos/ai/stigmer/agentic/session/v1/io_pb";
+import { StigmerContext } from "../../context";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { useChannelSessions } from "../useChannelSessions";
+
+function createMockStigmer(overrides: {
+  listByChannel?: (input: ListSessionsByChannelRequest) => Promise<unknown>;
+} = {}) {
+  return {
+    session: {
+      listByChannel:
+        overrides.listByChannel ?? vi.fn().mockResolvedValue({ entries: [] }),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <FetchCacheContext.Provider value={null}>
+        <StigmerContext.Provider value={client as never}>
+          {children}
+        </StigmerContext.Provider>
+      </FetchCacheContext.Provider>
+    );
+  };
+}
+
+function makeChannelSession(id: string, externalUser: string) {
+  return {
+    metadata: {
+      id,
+      org: "acme",
+      labels: {
+        "stigmer.ai/channel-id": "ach_1",
+        "stigmer.ai/channel-external-user-key": externalUser,
+      },
+    },
+    spec: { subject: `Conversation ${id}` },
+  };
+}
+
+describe("useChannelSessions", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("loads the channel's conversations by channel id", async () => {
+    const session = makeChannelSession("ses_1", "U0AB12CD3");
+    const listByChannel = vi.fn().mockResolvedValue({ entries: [session] });
+    const client = createMockStigmer({ listByChannel });
+
+    const { result } = renderHook(() => useChannelSessions("ach_1"), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.isLoading).toBe(true);
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.sessions).toEqual([session]);
+    expect(result.current.error).toBeNull();
+    expect(listByChannel).toHaveBeenCalledWith(
+      expect.objectContaining({ channelId: "ach_1" }),
+    );
+  });
+
+  it("skips fetching for an empty channel id (stable no-op)", async () => {
+    const listByChannel = vi.fn();
+    const client = createMockStigmer({ listByChannel });
+
+    const { result } = renderHook(() => useChannelSessions(""), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.sessions).toEqual([]);
+    expect(listByChannel).not.toHaveBeenCalled();
+  });
+
+  it("surfaces a denial as the error state (caller cannot view the channel)", async () => {
+    const denied = new Error("unauthorized to list channel conversations");
+    const listByChannel = vi.fn().mockRejectedValue(denied);
+    const client = createMockStigmer({ listByChannel });
+
+    const { result } = renderHook(() => useChannelSessions("ach_1"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.error).not.toBeNull());
+    expect(result.current.sessions).toEqual([]);
+  });
+});

package/src/channel/__tests__/useChannelToolReadiness.test.tsx

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { create } from "@bufbuild/protobuf";
+import { AgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
+import type { Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
+import { ApiResourceVisibility } from "@stigmer/protos/ai/stigmer/commons/apiresource/enum_pb";
+import { StigmerContext } from "../../context";
+import { DeploymentModeContext } from "../../deployment-mode";
+import { useChannelToolReadiness } from "../useChannelToolReadiness";
+
+function toolAgent(overrides?: { mcpUsages?: boolean }): Agent {
+  return create(AgentSchema, {
+    metadata: { id: "agt_1", org: "acme", slug: "helper" },
+    spec: {
+      instructions: "help",
+      mcpServerUsages:
+        (overrides?.mcpUsages ?? true)
+          ? [{ mcpServerRef: { org: "acme", slug: "github" } }]
+          : [],
+    },
+  });
+}
+
+function mockStigmer(overrides: {
+  envVisibility?: Record<string, ApiResourceVisibility>;
+  envError?: boolean;
+}) {
+  return {
+    environment: {
+      getByReference: vi.fn().mockImplementation(
+        ({ slug }: { org: string; slug: string }) => {
+          if (overrides.envError) {
+            return Promise.reject(new Error("not found"));
+          }
+          return Promise.resolve({
+            metadata: {
+              visibility:
+                overrides.envVisibility?.[slug] ??
+                ApiResourceVisibility.visibility_private,
+            },
+          });
+        },
+      ),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown, mode: "cloud" | "local" = "cloud") {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <StigmerContext.Provider value={client as never}>
+        <DeploymentModeContext.Provider value={mode}>
+          {children}
+        </DeploymentModeContext.Provider>
+      </StigmerContext.Provider>
+    );
+  };
+}
+
+function envLookup(client: unknown) {
+  return (
+    client as { environment: { getByReference: ReturnType<typeof vi.fn> } }
+  ).environment.getByReference;
+}
+
+describe("useChannelToolReadiness", () => {
+  it("reports needs-credentials when a tool-using channel has no bindings — no lookups fire", async () => {
+    const client = mockStigmer({});
+    const { result } = renderHook(
+      () => useChannelToolReadiness(toolAgent(), true, []),
+      { wrapper: wrapper(client) },
+    );
+
+    // A tool-using agent with zero bound environments is broken over the
+    // channel BY CONSTRUCTION (channel executions receive credentials
+    // only from the channel's bindings) — the hook says so instead of
+    // staying silent, and needs no server round-trip to know it.
+    expect(result.current).toEqual({ status: "needs-credentials" });
+    await waitFor(() => expect(envLookup(client)).not.toHaveBeenCalled());
+  });
+
+  it("reports blocked with the private environment refs listed", async () => {
+    const client = mockStigmer({
+      envVisibility: {
+        "shared-creds": ApiResourceVisibility.visibility_org,
+      },
+    });
+
+    const { result } = renderHook(
+      () =>
+        useChannelToolReadiness(toolAgent(), true, [
+          { org: "acme", slug: "private-creds" },
+          { org: "acme", slug: "shared-creds" },
+        ]),
+      { wrapper: wrapper(client) },
+    );
+
+    await waitFor(() =>
+      expect(result.current).toEqual({
+        status: "blocked",
+        privateEnvironments: ["acme/private-creds"],
+      }),
+    );
+  });
+
+  it("reports ready when every bound environment is org-shared", async () => {
+    const client = mockStigmer({
+      envVisibility: {
+        "shared-creds": ApiResourceVisibility.visibility_org,
+      },
+    });
+
+    const { result } = renderHook(
+      () =>
+        useChannelToolReadiness(toolAgent(), true, [
+          { org: "acme", slug: "shared-creds" },
+        ]),
+      { wrapper: wrapper(client) },
+    );
+
+    await waitFor(() => expect(result.current).toEqual({ status: "ready" }));
+  });
+
+  it("is n/a for agents without MCP tools — no lookups fire", async () => {
+    const client = mockStigmer({});
+    const { result } = renderHook(
+      () =>
+        useChannelToolReadiness(toolAgent({ mcpUsages: false }), true, [
+          { org: "acme", slug: "shared-creds" },
+        ]),
+      { wrapper: wrapper(client) },
+    );
+
+    expect(result.current).toEqual({ status: "na" });
+    await waitFor(() => expect(envLookup(client)).not.toHaveBeenCalled());
+  });
+
+  it("is n/a when the channel is disabled — a paused channel serves no traffic", () => {
+    const client = mockStigmer({});
+    const { result } = renderHook(
+      () => useChannelToolReadiness(toolAgent(), false, []),
+      { wrapper: wrapper(client) },
+    );
+
+    expect(result.current).toEqual({ status: "na" });
+  });
+
+  it("is n/a in local mode — the channel runtime is cloud-only", () => {
+    const client = mockStigmer({});
+    const { result } = renderHook(
+      () => useChannelToolReadiness(toolAgent(), true, []),
+      { wrapper: wrapper(client, "local") },
+    );
+
+    expect(result.current).toEqual({ status: "na" });
+  });
+});