@stigmer/sdk 3.35.0 → 3.36.0

package/src/execution/__tests__/tool-view.fixtures.test.ts

@@ -1,225 +0,0 @@
-// Validates the tool-view layer against the shared cross-surface contract in
-// test/fixtures/tool-view/. The runner's middleware tests assert the same
-// fixtures from the writer side, so producers and this reader cannot drift in
-// classification, result interpretation, intent extraction, or secret redaction.
-
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, resolve } from "node:path";
-import { describe, it, expect } from "vitest";
-import { create, type JsonObject } from "@bufbuild/protobuf";
-import { ToolCallSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
-import { ToolCallStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import {
-  ToolKind,
-  resolveToolKindByName,
-  normalizeToolResult,
-  extractShellIntent,
-  SHELL_INTENT_ARG_FIELD,
-  isSecretArgKey,
-  redactSecretArgs,
-} from "../tool-view";
-
-const here = dirname(fileURLToPath(import.meta.url));
-// sdk/typescript/src/execution/__tests__ -> repo root is five levels up.
-const fixtureDir = resolve(here, "../../../../../test/fixtures/tool-view");
-
-function loadFixture<T>(name: string): T {
-  return JSON.parse(readFileSync(resolve(fixtureDir, name), "utf8")) as T;
-}
-
-describe("classification fixtures", () => {
-  const { cases } = loadFixture<{
-    cases: { name: string; mcpServerSlug: string; toolKind: string }[];
-  }>("classification.json");
-
-  it("loads the fixture", () => {
-    expect(cases.length).toBeGreaterThan(0);
-  });
-
-  for (const c of cases) {
-    const expected = ToolKind[c.toolKind.replace(/^TOOL_KIND_/, "") as keyof typeof ToolKind];
-    it(`classifies ${c.name || "(empty)"}${c.mcpServerSlug ? ` @${c.mcpServerSlug}` : ""}`, () => {
-      expect(resolveToolKindByName(c.name, c.mcpServerSlug)).toBe(expected);
-    });
-  }
-});
-
-describe("result-view fixtures", () => {
-  interface ResultCase {
-    name: string;
-    toolName: string;
-    mcpServerSlug: string;
-    args: Record<string, unknown>;
-    result: string;
-    error?: string;
-    status?: string;
-    expected: {
-      type: string;
-      path?: string;
-      exitCode?: number;
-      command?: string;
-      count?: number;
-      mcpServerSlug?: string;
-      linesAdded?: number;
-      linesRemoved?: number;
-      memoryId?: string;
-      fact?: string;
-    };
-  }
-
-  const { cases } = loadFixture<{ cases: ResultCase[] }>("result-views.json");
-
-  it("loads the fixture", () => {
-    expect(cases.length).toBeGreaterThan(0);
-  });
-
-  for (const c of cases) {
-    it(`normalizes ${c.name} -> ${c.expected.type}`, () => {
-      const status =
-        c.status === "TOOL_CALL_FAILED"
-          ? ToolCallStatus.TOOL_CALL_FAILED
-          : ToolCallStatus.TOOL_CALL_COMPLETED;
-
-      const toolCall = create(ToolCallSchema, {
-        id: c.name,
-        name: c.toolName,
-        mcpServerSlug: c.mcpServerSlug,
-        result: c.result,
-        error: c.error ?? "",
-        status,
-        args: c.args as JsonObject,
-      });
-
-      const view = normalizeToolResult(toolCall);
-      expect(view.type).toBe(c.expected.type);
-
-      // Only deterministic facts are part of the shared contract.
-      if (c.expected.path !== undefined && view.type === "diff") {
-        expect(view.path).toBe(c.expected.path);
-      }
-      if (c.expected.path !== undefined && view.type === "file") {
-        expect(view.path).toBe(c.expected.path);
-      }
-      if (c.expected.exitCode !== undefined && view.type === "terminal") {
-        expect(view.exitCode).toBe(c.expected.exitCode);
-      }
-      if (c.expected.command !== undefined && view.type === "terminal") {
-        expect(view.command).toBe(c.expected.command);
-      }
-      if (c.expected.count !== undefined && view.type === "search") {
-        expect(view.count).toBe(c.expected.count);
-      }
-      if (c.expected.count !== undefined && view.type === "list") {
-        expect(view.count).toBe(c.expected.count);
-      }
-      if (c.expected.mcpServerSlug !== undefined && view.type === "contentBlocks") {
-        expect(view.mcpServerSlug).toBe(c.expected.mcpServerSlug);
-      }
-      if (c.expected.linesAdded !== undefined && view.type === "diff") {
-        expect(view.linesAdded).toBe(c.expected.linesAdded);
-      }
-      if (c.expected.linesRemoved !== undefined && view.type === "diff") {
-        expect(view.linesRemoved).toBe(c.expected.linesRemoved);
-      }
-      if (c.expected.memoryId !== undefined && view.type === "memoryProposal") {
-        expect(view.memoryId).toBe(c.expected.memoryId);
-      }
-      if (c.expected.fact !== undefined && view.type === "memoryProposal") {
-        expect(view.fact).toBe(c.expected.fact);
-      }
-    });
-  }
-});
-
-describe("intent-title fixtures", () => {
-  interface IntentCase {
-    name: string;
-    mcpServerSlug: string;
-    args: Record<string, unknown>;
-    intent: string | null;
-  }
-
-  const fixture = loadFixture<{ argField: string; cases: IntentCase[] }>(
-    "intent-title.json",
-  );
-
-  it("loads the fixture and agrees on the wire key", () => {
-    expect(fixture.cases.length).toBeGreaterThan(0);
-    expect(SHELL_INTENT_ARG_FIELD).toBe(fixture.argField);
-  });
-
-  for (const c of fixture.cases) {
-    it(`extracts ${c.name}${c.mcpServerSlug ? ` @${c.mcpServerSlug}` : ""} -> ${JSON.stringify(c.intent)}`, () => {
-      const toolCall = create(ToolCallSchema, {
-        id: c.name,
-        name: c.name,
-        mcpServerSlug: c.mcpServerSlug,
-        args: c.args as JsonObject,
-      });
-      expect(extractShellIntent(toolCall)).toBe(c.intent);
-    });
-  }
-});
-
-describe("secret-args fixtures", () => {
-  // The runner's args-preview tests assert the same file from the writer side.
-  const { keys, marker, cases } = loadFixture<{
-    keys: string[];
-    marker: string;
-    cases: { name: string; args: Record<string, unknown>; redacted: Record<string, unknown> }[];
-  }>("secret-args.json");
-
-  it("recognises every secret key, in any case, and nothing that merely contains one", () => {
-    for (const key of keys) {
-      expect(isSecretArgKey(key)).toBe(true);
-      expect(isSecretArgKey(key.toUpperCase())).toBe(true);
-    }
-    expect(isSecretArgKey("token_count")).toBe(false);
-    expect(isSecretArgKey("repo")).toBe(false);
-  });
-
-  for (const c of cases) {
-    it(`redacts ${c.name}`, () => {
-      expect(redactSecretArgs(c.args)).toEqual(c.redacted);
-    });
-  }
-
-  it("writes the runner's marker and keeps the reference when nothing is secret", () => {
-    expect(redactSecretArgs({ token: "t" }).token).toBe(marker);
-    const clean = { repo: "acme/x" };
-    expect(redactSecretArgs(clean)).toBe(clean);
-  });
-});
-
-describe("resolveToolKind wire field precedence", () => {
-  it("prefers the wire tool_kind over the name fallback", () => {
-    const toolCall = create(ToolCallSchema, {
-      name: "some_unknown_name",
-      toolKind: ToolKind.SHELL,
-    });
-    // resolveToolKind is exercised indirectly via normalizeToolResult routing.
-    const view = normalizeToolResult(
-      create(ToolCallSchema, {
-        name: "some_unknown_name",
-        toolKind: ToolKind.SHELL,
-        result: "done\n[Command succeeded]",
-        status: ToolCallStatus.TOOL_CALL_COMPLETED,
-      }),
-    );
-    expect(view.type).toBe("terminal");
-    expect(toolCall.toolKind).toBe(ToolKind.SHELL);
-  });
-
-  it("degrades unknown results to json or text", () => {
-    const jsonView = normalizeToolResult(
-      create(ToolCallSchema, { name: "mystery", result: '{"a":1}', status: ToolCallStatus.TOOL_CALL_COMPLETED }),
-    );
-    expect(jsonView.type).toBe("json");
-
-    const textView = normalizeToolResult(
-      create(ToolCallSchema, { name: "mystery", result: "plain", status: ToolCallStatus.TOOL_CALL_COMPLETED }),
-    );
-    expect(textView.type).toBe("text");
-  });
-});

package/src/execution/__tests__/tool-view.output-ref.test.ts

@@ -1,76 +0,0 @@
-// Covers the offloaded tool-output path: when a result is spilled to artifact
-// storage the runner replaces it with a ToolCallOutputRef. The view must surface
-// the STABLE storageKey (+ contentHash) so consumers resolve the bytes/URL on
-// demand — it must never depend on a persisted (ephemeral) URL.
-
-import { describe, it, expect } from "vitest";
-import { create, type JsonObject } from "@bufbuild/protobuf";
-import {
-  ToolCallSchema,
-  ToolCallOutputRefSchema,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
-import {
-  ToolCallStatus,
-  ToolKind,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import { normalizeToolResult } from "../tool-view";
-
-function toolCallWithOutputRef(ref: ReturnType<typeof create<typeof ToolCallOutputRefSchema>> | undefined, result = "") {
-  return create(ToolCallSchema, {
-    id: "tc-1",
-    name: "some_tool",
-    toolKind: ToolKind.UNSPECIFIED,
-    status: ToolCallStatus.TOOL_CALL_COMPLETED,
-    args: {} as JsonObject,
-    result,
-    outputRef: ref,
-  });
-}
-
-describe("normalizeToolResult — offloaded output ref", () => {
-  it("emits an outputRef view carrying the stable storageKey and contentHash", () => {
-    const ref = create(ToolCallOutputRefSchema, {
-      storageKey: "artifacts/exec-1/toolcalls/tc-1.txt",
-      contentHash: "sha256:abc",
-      sizeBytes: 900_000n,
-      mimeType: "text/plain",
-      isImage: false,
-      truncatedPreview: "head of the output…",
-    });
-
-    const view = normalizeToolResult(toolCallWithOutputRef(ref, "[output truncated]"));
-
-    expect(view.type).toBe("outputRef");
-    if (view.type !== "outputRef") return;
-    expect(view.storageKey).toBe("artifacts/exec-1/toolcalls/tc-1.txt");
-    expect(view.contentHash).toBe("sha256:abc");
-    expect(view.isImage).toBe(false);
-    expect(view.mimeType).toBe("text/plain");
-    expect(view.sizeBytes).toBe(900_000);
-    expect(view.preview).toBe("head of the output…");
-  });
-
-  it("gates on storageKey, not a URL — an image ref renders inline", () => {
-    const ref = create(ToolCallOutputRefSchema, {
-      storageKey: "artifacts/exec-1/toolcalls/tc-1.png",
-      contentHash: "sha256:img",
-      sizeBytes: 12_345n,
-      mimeType: "image/png",
-      isImage: true,
-    });
-
-    const view = normalizeToolResult(toolCallWithOutputRef(ref));
-
-    expect(view.type).toBe("outputRef");
-    if (view.type !== "outputRef") return;
-    expect(view.isImage).toBe(true);
-    expect(view.storageKey).toBe("artifacts/exec-1/toolcalls/tc-1.png");
-  });
-
-  it("does not produce an outputRef view when no storageKey is present", () => {
-    // A ref with no storageKey is not a usable offload pointer; fall back to text.
-    const ref = create(ToolCallOutputRefSchema, { sizeBytes: 10n });
-    const view = normalizeToolResult(toolCallWithOutputRef(ref, "plain result"));
-    expect(view.type).not.toBe("outputRef");
-  });
-});

package/src/execution/__tests__/tool-view.read.test.ts

@@ -1,71 +0,0 @@
-// Covers read normalization over the native engine's read frame: deepagents
-// (1.12+) renders a text read as one-line bracketed notices, a status header
-// `@@ lines A-B[ of T][ | …] @@`, and then the file's lines unmodified. The view
-// shows the file, so the frame is dropped; a truncation the header reports is
-// kept. The cross-language fixture (result-views.json) asserts the happy path;
-// these cover the frame's variants and the results that carry no frame (Cursor,
-// and native rows recorded before the frame existed).
-
-import { describe, it, expect } from "vitest";
-import { create, type JsonObject } from "@bufbuild/protobuf";
-import { ToolCallSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
-import {
-  ToolCallStatus,
-  ToolKind,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import { normalizeToolResult } from "../tool-view";
-
-function readCall(result: string) {
-  return create(ToolCallSchema, {
-    id: "tc-read",
-    name: "read_file",
-    toolKind: ToolKind.FILE_READ,
-    status: ToolCallStatus.TOOL_CALL_COMPLETED,
-    args: { file_path: "/workspace/main.go" } as JsonObject,
-    result,
-  });
-}
-
-function fileView(result: string) {
-  const view = normalizeToolResult(readCall(result));
-  expect(view.type).toBe("file");
-  if (view.type !== "file") throw new Error("not a file view");
-  return view;
-}
-
-describe("normalizeToolResult — native read frame", () => {
-  it("drops the status header and shows the file's lines", () => {
-    const view = fileView("@@ lines 1-2 of 2 @@\npackage main\n");
-    expect(view.content).toBe("package main\n");
-    expect(view.truncated).toBe(false);
-  });
-
-  it("drops a paginated header and the notices above it", () => {
-    const view = fileView(
-      "[Requested offset -3 is before the start of the file; read from line 1 instead.]\n" +
-        "@@ lines 1-100 of 250 | next offset 100 @@\nline one\nline two",
-    );
-    expect(view.content).toBe("line one\nline two");
-    expect(view.truncated).toBe(false);
-  });
-
-  it("keeps a truncation the header reports", () => {
-    const whole = fileView(
-      "[Output was truncated due to size limits.]\n@@ lines 1-40 of 900 | next offset 40 | truncated due to size @@\nfirst",
-    );
-    expect(whole.content).toBe("first");
-    expect(whole.truncated).toBe(true);
-
-    const midLine = fileView("@@ lines 1-1 | truncated mid-line | 10 of 90 chars @@\n0123456789");
-    expect(midLine.content).toBe("0123456789");
-    expect(midLine.truncated).toBe(true);
-  });
-
-  it("leaves a result without the frame as it is", () => {
-    expect(fileView("     1\tpackage main\n     2\t").content).toBe("     1\tpackage main\n     2\t");
-    expect(fileView("[a bracketed first line of the file]\nsecond").content).toBe(
-      "[a bracketed first line of the file]\nsecond",
-    );
-    expect(fileView("@@ -1,2 +1,3 @@\n diff text").content).toBe("@@ -1,2 +1,3 @@\n diff text");
-  });
-});

package/src/execution/__tests__/tool-view.search.test.ts

@@ -1,264 +0,0 @@
-// Covers search normalization's envelope handling: the Cursor SDK returns search
-// results as a stringified JSON envelope (file-name search via {status,value} and
-// grep/codebase search via {workspaceResults}), which the original parser dumped
-// as a single fake "match". The cross-language fixture (result-views.json)
-// asserts the happy-path `type`/`count`; these cover the `kind`/`truncated`
-// presentation hints, the multi-workspace flatten, the content-match mapping, and
-// the unrecognized-JSON -> json degradation that is not a shared scalar fact.
-
-import { describe, it, expect } from "vitest";
-import { create, type JsonObject } from "@bufbuild/protobuf";
-import { ToolCallSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
-import {
-  ToolCallStatus,
-  ToolKind,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import { normalizeToolResult } from "../tool-view";
-
-function searchCall(args: Record<string, unknown>, result: string) {
-  return create(ToolCallSchema, {
-    id: "tc-search",
-    name: "Grep",
-    toolKind: ToolKind.SEARCH,
-    status: ToolCallStatus.TOOL_CALL_COMPLETED,
-    args: args as JsonObject,
-    result,
-  });
-}
-
-describe("normalizeToolResult — Cursor file-name search envelope", () => {
-  it("unwraps an empty {status,value} file search (the reported bug: not '1 match')", () => {
-    const view = normalizeToolResult(
-      searchCall(
-        { pattern: "**/*.nope" },
-        JSON.stringify({
-          status: "success",
-          value: { files: [], totalFiles: 0, clientTruncated: false, ripgrepTruncated: false },
-        }),
-      ),
-    );
-    expect(view.type).toBe("search");
-    if (view.type !== "search") return;
-    expect(view.kind).toBe("files");
-    expect(view.count).toBe(0);
-    expect(view.matches).toHaveLength(0);
-    expect(view.truncated).toBe(false);
-  });
-
-  it("unwraps a non-empty file search into clickable file matches", () => {
-    const view = normalizeToolResult(
-      searchCall(
-        { pattern: "Dockerfile" },
-        JSON.stringify({
-          status: "success",
-          value: { files: ["Dockerfile"], totalFiles: 1, clientTruncated: false, ripgrepTruncated: false },
-        }),
-      ),
-    );
-    expect(view.type).toBe("search");
-    if (view.type !== "search") return;
-    expect(view.kind).toBe("files");
-    expect(view.count).toBe(1);
-    // Both file and text are set so a kind-unaware consumer still shows the path.
-    expect(view.matches[0]).toEqual({ file: "Dockerfile", text: "Dockerfile" });
-  });
-
-  it("carries the engine's truncation flags and authoritative totalFiles", () => {
-    const view = normalizeToolResult(
-      searchCall(
-        { pattern: "*.ts" },
-        JSON.stringify({
-          status: "success",
-          value: { files: ["a.ts", "b.ts"], totalFiles: 200, clientTruncated: true, ripgrepTruncated: false },
-        }),
-      ),
-    );
-    expect(view.type).toBe("search");
-    if (view.type !== "search") return;
-    // totalFiles is authoritative and can exceed the returned page.
-    expect(view.count).toBe(200);
-    expect(view.matches).toHaveLength(2);
-    expect(view.truncated).toBe(true);
-  });
-});
-
-describe("normalizeToolResult — Cursor grep workspaceResults envelope", () => {
-  it("unwraps the real {status,value:{workspaceResults}} grep shape (the reported bug)", () => {
-    // The grep payload nests workspaceResults INSIDE the {status,value} envelope —
-    // the shape the runner actually persists. The original parser only looked at
-    // the top level, so this fell through to a raw JSON dump.
-    const view = normalizeToolResult(
-      searchCall(
-        { pattern: "pipeline" },
-        JSON.stringify({
-          status: "success",
-          value: {
-            workspaceResults: {
-              "/work/demo": { type: "files", output: { files: [], count: 0 } },
-            },
-          },
-        }),
-      ),
-    );
-    expect(view.type).toBe("search");
-    if (view.type !== "search") return;
-    expect(view.kind).toBe("files");
-    expect(view.count).toBe(0);
-  });
-
-  it("still reads an un-enveloped top-level workspaceResults (defensive)", () => {
-    const view = normalizeToolResult(
-      searchCall(
-        { pattern: "pipeline" },
-        JSON.stringify({
-          workspaceResults: { "/work/demo": { type: "files", output: { files: [], count: 0 } } },
-        }),
-      ),
-    );
-    expect(view.type).toBe("search");
-    if (view.type !== "search") return;
-    expect(view.kind).toBe("files");
-    expect(view.count).toBe(0);
-  });
-
-  it("flattens file matches across multiple workspaces and sums reported counts", () => {
-    const view = normalizeToolResult(
-      searchCall(
-        { pattern: "TODO" },
-        JSON.stringify({
-          status: "success",
-          value: {
-            workspaceResults: {
-              "/work/a": { type: "files", output: { files: ["a/x.ts"], count: 1 } },
-              "/work/b": { type: "files", output: { files: ["b/y.ts"], count: 1 } },
-            },
-          },
-        }),
-      ),
-    );
-    expect(view.type).toBe("search");
-    if (view.type !== "search") return;
-    expect(view.kind).toBe("files");
-    expect(view.count).toBe(2);
-    expect(view.matches.map((m) => m.file)).toEqual(["a/x.ts", "b/y.ts"]);
-  });
-
-  it("renders a non-empty grep (type:files) as a file list, not 0 files", () => {
-    // The real wrapped shape with results present — proves a populated grep is
-    // shown (the user's concern that a non-empty response might render as empty).
-    const view = normalizeToolResult(
-      searchCall(
-        { pattern: "pipeline" },
-        JSON.stringify({
-          status: "success",
-          value: {
-            workspaceResults: {
-              "/work/demo": {
-                type: "files",
-                output: { files: [".tekton/pipeline.yaml", "README.md"], count: 2 },
-              },
-            },
-          },
-        }),
-      ),
-    );
-    expect(view.type).toBe("search");
-    if (view.type !== "search") return;
-    expect(view.kind).toBe("files");
-    expect(view.count).toBe(2);
-    expect(view.matches.map((m) => m.file)).toEqual([".tekton/pipeline.yaml", "README.md"]);
-  });
-
-  it("falls back to JSON (never hides data) when a count is reported but nothing extracts", () => {
-    // Shape drift: the engine says count:5 but the matches live under a key we
-    // don't recognise. Surfacing the raw JSON beats a misleading "No matches".
-    const view = normalizeToolResult(
-      searchCall(
-        { pattern: "x" },
-        JSON.stringify({
-          status: "success",
-          value: {
-            workspaceResults: {
-              "/work/demo": { type: "weird", output: { hits: ["a", "b"], count: 5 } },
-            },
-          },
-        }),
-      ),
-    );
-    expect(view.type).toBe("json");
-  });
-
-  it("falls back to JSON when a file search reports totalFiles but no extractable paths", () => {
-    // files are objects, not strings (a drift) — but totalFiles says 3.
-    const view = normalizeToolResult(
-      searchCall(
-        { pattern: "*.ts" },
-        JSON.stringify({
-          status: "success",
-          value: { files: [{ path: "a.ts" }], totalFiles: 3 },
-        }),
-      ),
-    );
-    expect(view.type).toBe("json");
-  });
-
-  it("maps line-bearing matches into grouped content matches", () => {
-    const view = normalizeToolResult(
-      searchCall(
-        { pattern: "TODO" },
-        JSON.stringify({
-          status: "success",
-          value: {
-            workspaceResults: {
-              "/work/a": {
-                type: "matches",
-                output: {
-                  matches: [
-                    { file: "a/x.ts", line: 12, text: "// TODO: fix" },
-                    { file: "a/x.ts", line: 30, text: "// TODO: later" },
-                  ],
-                  count: 2,
-                },
-              },
-            },
-          },
-        }),
-      ),
-    );
-    expect(view.type).toBe("search");
-    if (view.type !== "search") return;
-    expect(view.kind).toBe("content");
-    expect(view.count).toBe(2);
-    expect(view.matches[0]).toEqual({ file: "a/x.ts", line: 12, text: "// TODO: fix" });
-  });
-});
-
-describe("normalizeToolResult — search plain text and graceful degradation", () => {
-  it("keeps native grep line matches as content (unchanged behavior)", () => {
-    const view = normalizeToolResult(
-      searchCall(
-        { pattern: "TODO" },
-        "\n/workspace/a.go:\n  12: // TODO: fix\n/workspace/b.go:\n  7: // TODO: later",
-      ),
-    );
-    expect(view.type).toBe("search");
-    if (view.type !== "search") return;
-    expect(view.kind).toBe("content");
-    expect(view.count).toBe(2);
-  });
-
-  it("treats native path/name lines as file matches", () => {
-    const view = normalizeToolResult(searchCall({ pattern: "*.go" }, "src/a.go\nsrc/b.go"));
-    expect(view.type).toBe("search");
-    if (view.type !== "search") return;
-    expect(view.kind).toBe("files");
-    expect(view.count).toBe(2);
-  });
-
-  it("degrades an unrecognized JSON shape to a json view, not a fake match", () => {
-    const view = normalizeToolResult(
-      searchCall({ pattern: "x" }, JSON.stringify({ somethingElse: true })),
-    );
-    expect(view.type).toBe("json");
-  });
-});