sailfork / t3code-github / apps/ server/ src/ mcpApps/ McpAppRequests.test.ts

import {
  ProviderDriverKind,
  ProviderSessionId,
  ProviderThreadId,
  ThreadId,
  TurnItemId,
  type McpAppRequestError,
  type OrchestrationV2ProviderThread,
  type OrchestrationV2TurnItem,
} from "@t3tools/contracts";
import { assert, describe, it } from "@effect/vitest";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";

import * as Orchestrator from "../orchestration-v2/Orchestrator.ts";
import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
import * as ProviderSessionManager from "../orchestration-v2/ProviderSessionManager.ts";
import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
import * as McpAppModelContext from "./McpAppModelContext.ts";
import * as McpAppRequests from "./McpAppRequests.ts";

const threadId = ThreadId.make("thread-app");
const itemId = TurnItemId.make("item-app");
const providerThreadId = ProviderThreadId.make("provider-thread-app");
const providerSessionId = ProviderSessionId.make("provider-session-app");
const forkId = ThreadId.make("thread-fork");
const unrelatedId = ThreadId.make("thread-unrelated");
const deepForkId = (depth: number) => ThreadId.make(`thread-deep-${depth}`);
const deepParent = (id: ThreadId): ThreadId | null => {
  const match = /^thread-deep-(\d+)$/.exec(id);
  if (match === null) return null;
  const depth = Number(match[1]);
  return depth === 1 ? threadId : deepForkId(depth - 1);
};

const appItem = (output: unknown): OrchestrationV2TurnItem => ({
  id: itemId,
  threadId,
  runId: null,
  nodeId: null,
  providerThreadId,
  providerTurnId: null,
  nativeItemRef: null,
  parentItemId: null,
  ordinal: 0,
  status: "completed",
  title: null,
  startedAt: null,
  completedAt: null,
  updatedAt: DateTime.makeUnsafe(0),
  type: "dynamic_tool",
  toolName: "weather.get_weather",
  input: {},
  output,
});

const app = {
  attachmentId: "thread-app-00000000-0000-0000-0000-000000000000-html",
  server: "weather",
  tool: "get_weather",
  resourceUri: "ui://weather/dashboard",
};

const storedContext = new Map<string, string>();

function makeLayer(input: {
  readonly item: OrchestrationV2TurnItem | null;
  readonly mcpApps?: ProviderAdapter.ProviderAdapterV2McpApps;
  readonly live?: boolean;
}) {
  return McpAppRequests.layer.pipe(
    Layer.provide(
      Layer.mergeAll(
        Layer.mock(McpAppModelContext.McpAppModelContext)({
          set: (entry) =>
            Effect.sync(() => {
              const key = `${entry.threadId}/${entry.itemId}`;
              if (entry.text.trim() === "") storedContext.delete(key);
              else storedContext.set(key, entry.text);
            }),
        }),
        Layer.mock(Orchestrator.OrchestratorV2)({
          getTurnItem: () => Effect.succeed(input.item),
        }),
        Layer.mock(ThreadManagementService.ThreadManagementService)({
          getThreadRecords: (id: ThreadId) =>
            Effect.succeed({
              thread: {
                lineage:
                  deepParent(id) !== null
                    ? {
                        parentThreadId: deepParent(id),
                        relationshipToParent: "fork",
                        rootThreadId: threadId,
                      }
                    : id === forkId
                      ? {
                          parentThreadId: threadId,
                          relationshipToParent: "fork",
                          rootThreadId: threadId,
                        }
                      : { parentThreadId: null, relationshipToParent: null, rootThreadId: id },
              },
              providerThreads: [
                { id: providerThreadId, providerSessionId } as OrchestrationV2ProviderThread,
              ],
            } as never),
        }),
        Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({
          get: () =>
            Effect.succeed(
              input.live === false
                ? Option.none()
                : Option.some(
                    (input.mcpApps === undefined
                      ? {}
                      : {
                          mcpApps: input.mcpApps,
                        }) as ProviderAdapter.ProviderAdapterV2SessionRuntime,
                  ),
            ),
        }),
      ),
    ),
  );
}

const reason = <A, R>(effect: Effect.Effect<A, McpAppRequestError, R>) =>
  effect.pipe(
    Effect.flip,
    Effect.map((error) => error.reason),
  );

describe("McpAppRequests", () => {
  const calls: Array<{ server: string; tool: string }> = [];
  const mcpApps: ProviderAdapter.ProviderAdapterV2McpApps = {
    listTools: () =>
      Effect.succeed([
        { name: "refresh", inputSchema: { type: "object" }, annotations: { readOnlyHint: true } },
        {
          name: "model_only",
          inputSchema: { type: "object" },
          _meta: { ui: { visibility: ["model"] } },
        },
      ]),
    callTool: (input) =>
      Effect.sync(() => {
        calls.push({ server: input.server, tool: input.tool });
        return { content: [{ type: "text", text: "ok" }] };
      }),
    readResource: () => Effect.succeed({ contents: [] }),
  };

  it.effect("calls tools on the app's own server and reports their read-only hint", () =>
    Effect.gen(function* () {
      const requests = yield* McpAppRequests.McpAppRequests;
      const result = yield* requests.callTool({
        threadId,
        itemId,
        name: "refresh",
        arguments: {},
      });
      assert.deepEqual(result, { content: [{ type: "text", text: "ok" }] });
      assert.deepEqual(calls.at(-1), { server: "weather", tool: "refresh" });
      assert.deepEqual(yield* requests.toolInfo({ threadId, itemId, name: "refresh" }), {
        callable: true,
        readOnly: true,
        tool: {
          name: "refresh",
          inputSchema: { type: "object" },
          annotations: { readOnlyHint: true },
        },
      });
    }).pipe(Effect.provide(makeLayer({ item: appItem({ t3McpApp: app }), mcpApps }))),
  );

  it.effect("refuses tools hidden from apps or missing from the server", () =>
    Effect.gen(function* () {
      const requests = yield* McpAppRequests.McpAppRequests;
      const before = calls.length;
      for (const name of ["model_only", "unknown"]) {
        assert.equal(
          yield* reason(requests.callTool({ threadId, itemId, name, arguments: {} })),
          "tool-not-callable",
        );
      }
      assert.equal(calls.length, before);
    }).pipe(Effect.provide(makeLayer({ item: appItem({ t3McpApp: app }), mcpApps }))),
  );

  it.effect("reports a provider whose process has stopped as a stopped session", () =>
    Effect.gen(function* () {
      const requests = yield* McpAppRequests.McpAppRequests;
      assert.equal(
        yield* reason(requests.readResource({ threadId, itemId, uri: "ui://weather/app.html" })),
        "session-stopped",
      );
    }).pipe(
      Effect.provide(
        makeLayer({
          item: appItem({ t3McpApp: app }),
          mcpApps: {
            ...mcpApps,
            readResource: () =>
              Effect.fail(
                new ProviderAdapter.ProviderAdapterSessionStoppedError({
                  driver: ProviderDriverKind.make("claudeAgent"),
                }),
              ),
          },
        }),
      ),
    ),
  );

  it.effect("keeps each app's latest model context, without a live session", () =>
    Effect.gen(function* () {
      const requests = yield* McpAppRequests.McpAppRequests;
      const own = { threadId, itemId, conversationThreadId: threadId };
      yield* requests.updateModelContext({
        ...own,
        content: [{ type: "text", text: "  indented value  " }],
      });
      assert.equal(storedContext.get(`${threadId}/${itemId}`), "  indented value  ");
      yield* requests.updateModelContext({
        ...own,
        content: [{ type: "text", text: "Filtered to overdue" }],
        structuredContent: { filter: "overdue" },
      });
      assert.equal(
        storedContext.get(`${threadId}/${itemId}`),
        'Filtered to overdue\n{"filter":"overdue"}',
      );
      assert.equal(
        yield* reason(
          requests.updateModelContext({ ...own, content: [{ type: "image", data: "x" }] }),
        ),
        "unsupported-content",
      );
      assert.equal(
        yield* reason(
          requests.updateModelContext({
            ...own,
            content: [{ type: "text", text: "表".repeat(6000) }],
          }),
        ),
        "request-failed",
      );
      yield* requests.updateModelContext(own);
      assert.isFalse(storedContext.has(`${threadId}/${itemId}`));
    }).pipe(Effect.provide(makeLayer({ item: appItem({ t3McpApp: app }), live: false }))),
  );

  it.effect("stores a fork's model context under the fork, and refuses unrelated threads", () =>
    Effect.gen(function* () {
      const requests = yield* McpAppRequests.McpAppRequests;
      const content = [{ type: "text", text: "Seen from the fork" }];
      yield* requests.updateModelContext({
        threadId,
        itemId,
        conversationThreadId: forkId,
        content,
      });
      assert.equal(storedContext.get(`${forkId}/${itemId}`), "Seen from the fork");
      assert.isFalse(storedContext.has(`${threadId}/${itemId}`));
      assert.equal(
        yield* reason(
          requests.updateModelContext({
            threadId,
            itemId,
            conversationThreadId: unrelatedId,
            content,
          }),
        ),
        "not-an-app",
      );
      yield* requests.updateModelContext({
        threadId,
        itemId,
        conversationThreadId: deepForkId(70),
        content,
      });
      assert.isTrue(storedContext.has(`${deepForkId(70)}/${itemId}`));
    }).pipe(Effect.provide(makeLayer({ item: appItem({ t3McpApp: app }), live: false }))),
  );
});