@agent-native/creative-context 0.1.0

package/src/server/generation-context-a2a.spec.ts

@@ -0,0 +1,131 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  readAppState: vi.fn(),
+  getContextPack: vi.fn(),
+  getCreativeContextItem: vi.fn(),
+  listAccessibleSearchDocuments: vi.fn(),
+  performCreativeContextSearch: vi.fn(),
+  recordLocal: vi.fn(),
+  getLocal: vi.fn(),
+  hasA2A: vi.fn(),
+  callA2A: vi.fn(),
+}));
+
+vi.mock("@agent-native/core/application-state", () => ({
+  readAppState: mocks.readAppState,
+}));
+
+vi.mock("../store/index.js", () => ({
+  getContextPack: mocks.getContextPack,
+  getCreativeContextItem: mocks.getCreativeContextItem,
+  listAccessibleSearchDocuments: mocks.listAccessibleSearchDocuments,
+}));
+
+vi.mock("../store/generation.js", () => ({
+  recordGenerationCreativeContext: mocks.recordLocal,
+  getGenerationCreativeContext: mocks.getLocal,
+}));
+
+vi.mock("./retrieval.js", () => ({
+  performCreativeContextSearch: mocks.performCreativeContextSearch,
+}));
+
+vi.mock("./isolated-a2a.js", () => ({
+  callIsolatedCreativeContextA2A: mocks.callA2A,
+  hasIsolatedCreativeContextA2A: mocks.hasA2A,
+  isolatedResolvePayload: vi.fn((input) => ({
+    query: input.query,
+    role: input.role,
+    limit: input.limit,
+    contextPackId: input.contextPackId,
+    contextPackSource: input.contextPackSource,
+  })),
+}));
+
+import {
+  getGenerationCreativeContext,
+  recordGenerationCreativeContext,
+  resolveGenerationCreativeContext,
+  validateGenerationCreativeContext,
+} from "./generation-context.js";
+
+const emptyRemoteContext = {
+  contextMode: "auto" as const,
+  contextPackId: null,
+  reuseLabels: [],
+  results: [],
+};
+
+describe("generation context isolated A2A routing", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.readAppState.mockResolvedValue({ contextMode: "auto" });
+    mocks.hasA2A.mockReturnValue(true);
+    mocks.callA2A.mockResolvedValue(emptyRemoteContext);
+  });
+
+  it("routes bounded resolve, validate, read, and record operations remotely", async () => {
+    await resolveGenerationCreativeContext({
+      role: "slides",
+      query: "launch deck",
+    });
+    await validateGenerationCreativeContext({ reuseLabels: [] });
+    await getGenerationCreativeContext({
+      appId: "slides",
+      artifactType: "deck",
+      artifactId: "deck-1",
+    });
+    await recordGenerationCreativeContext({
+      appId: "slides",
+      artifactType: "deck",
+      artifactId: "deck-1",
+      contextMode: "auto",
+      contextPackId: null,
+      reuseLabels: [],
+    });
+
+    expect(mocks.callA2A).toHaveBeenNthCalledWith(1, "resolve", {
+      role: "slides",
+      query: "launch deck",
+      limit: undefined,
+      contextPackId: undefined,
+      contextPackSource: undefined,
+    });
+    expect(mocks.callA2A).toHaveBeenNthCalledWith(2, "validate", {
+      contextPackId: undefined,
+      contextPackSource: undefined,
+      reuseLabels: [],
+      reuseLabelsSource: undefined,
+    });
+    expect(mocks.callA2A).toHaveBeenNthCalledWith(3, "read", {
+      identity: {
+        appId: "slides",
+        artifactType: "deck",
+        artifactId: "deck-1",
+      },
+      accessScope: "owner",
+    });
+    expect(mocks.callA2A).toHaveBeenNthCalledWith(
+      4,
+      "record",
+      expect.objectContaining({ artifactId: "deck-1" }),
+    );
+    expect(mocks.recordLocal).not.toHaveBeenCalled();
+    expect(mocks.getLocal).not.toHaveBeenCalled();
+  });
+
+  it("keeps the in-process path as the zero-configuration default", async () => {
+    mocks.hasA2A.mockReturnValue(false);
+    mocks.performCreativeContextSearch.mockResolvedValue({
+      contextPackId: null,
+      results: [],
+    });
+
+    await expect(
+      resolveGenerationCreativeContext({ role: "content", query: "brief" }),
+    ).resolves.toEqual(emptyRemoteContext);
+    expect(mocks.performCreativeContextSearch).toHaveBeenCalled();
+    expect(mocks.callA2A).not.toHaveBeenCalled();
+  });
+});

package/src/server/generation-context-off.spec.ts

@@ -0,0 +1,213 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  readAppState: vi.fn(),
+  getContextPack: vi.fn(),
+  getCreativeContextItem: vi.fn(),
+  listAccessibleSearchDocuments: vi.fn(),
+  performCreativeContextSearch: vi.fn(),
+  callIsolatedCreativeContextA2A: vi.fn(),
+}));
+
+vi.mock("@agent-native/core/application-state", () => ({
+  readAppState: mocks.readAppState,
+}));
+
+vi.mock("../store/index.js", () => ({
+  getContextPack: mocks.getContextPack,
+  getCreativeContextItem: mocks.getCreativeContextItem,
+  listAccessibleSearchDocuments: mocks.listAccessibleSearchDocuments,
+}));
+
+vi.mock("./retrieval.js", () => ({
+  performCreativeContextSearch: mocks.performCreativeContextSearch,
+}));
+
+vi.mock("./isolated-a2a.js", () => ({
+  callIsolatedCreativeContextA2A: mocks.callIsolatedCreativeContextA2A,
+  hasIsolatedCreativeContextA2A: vi.fn(() => true),
+  isolatedResolvePayload: vi.fn((input) => input),
+}));
+
+import {
+  resolveGenerationCreativeContext,
+  validateGenerationCreativeContext,
+} from "./generation-context.js";
+
+describe("creative context structural opt-out", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.readAppState.mockResolvedValue({ contextMode: "off" });
+  });
+
+  it("rejects an explicit pack before resolving any saved evidence", async () => {
+    await expect(
+      resolveGenerationCreativeContext({
+        role: "slides",
+        contextPackId: "pack-1",
+      }),
+    ).rejects.toThrow(/context is off/i);
+    expect(mocks.getContextPack).not.toHaveBeenCalled();
+    expect(mocks.performCreativeContextSearch).not.toHaveBeenCalled();
+    expect(mocks.callIsolatedCreativeContextA2A).not.toHaveBeenCalled();
+  });
+
+  it("rejects an explicit pack before validating final-write provenance", async () => {
+    await expect(
+      validateGenerationCreativeContext({
+        contextPackId: "pack-1",
+        reuseLabels: [],
+      }),
+    ).rejects.toThrow(/context is off/i);
+    expect(mocks.getContextPack).not.toHaveBeenCalled();
+  });
+
+  it("returns no context and permits only generated labels when off", async () => {
+    await expect(
+      resolveGenerationCreativeContext({ role: "design", query: "dashboard" }),
+    ).resolves.toMatchObject({
+      contextMode: "off",
+      contextPackId: null,
+      reuseLabels: [],
+      results: [],
+    });
+    await expect(
+      validateGenerationCreativeContext({
+        reuseLabels: [
+          {
+            kind: "screen",
+            label: "Net-new screen",
+            dataRole: "untrusted-reference",
+            elementId: "screen-1",
+            influence: "generated",
+          },
+        ],
+      }),
+    ).resolves.toMatchObject({
+      contextMode: "off",
+      contextPackId: null,
+      reuseLabels: [{ elementId: "screen-1", influence: "generated" }],
+    });
+  });
+
+  it("applies a one-generation off override without reading or mutating saved preference", async () => {
+    mocks.readAppState.mockResolvedValue({
+      contextMode: "auto",
+      pinnedPackId: "pack-saved",
+    });
+    await expect(
+      resolveGenerationCreativeContext({
+        role: "assets",
+        query: "campaign",
+        contextModeOverride: "off",
+      }),
+    ).resolves.toEqual({
+      contextMode: "off",
+      contextPackId: null,
+      reuseLabels: [],
+      results: [],
+    });
+    await expect(
+      validateGenerationCreativeContext({
+        contextModeOverride: "off",
+        reuseLabels: [
+          {
+            kind: "image",
+            label: "Net-new image",
+            dataRole: "untrusted-reference",
+            influence: "generated",
+          },
+        ],
+      }),
+    ).resolves.toMatchObject({ contextMode: "off", contextPackId: null });
+    expect(mocks.readAppState).not.toHaveBeenCalled();
+    expect(mocks.getContextPack).not.toHaveBeenCalled();
+    expect(mocks.performCreativeContextSearch).not.toHaveBeenCalled();
+    expect(mocks.callIsolatedCreativeContextA2A).not.toHaveBeenCalled();
+  });
+
+  it("rejects a pack combined with a one-generation off override", async () => {
+    await expect(
+      resolveGenerationCreativeContext({
+        role: "content",
+        contextPackId: "pack-1",
+        contextModeOverride: "off",
+      }),
+    ).rejects.toThrow(/off for this generation/i);
+    await expect(
+      validateGenerationCreativeContext({
+        contextPackId: "pack-1",
+        contextModeOverride: "off",
+      }),
+    ).rejects.toThrow(/off for this generation/i);
+    expect(mocks.readAppState).not.toHaveBeenCalled();
+  });
+
+  it("ignores inherited packs when saved or per-request mode is off", async () => {
+    await expect(
+      resolveGenerationCreativeContext({
+        role: "slides",
+        contextPackId: "pack-inherited",
+        contextPackSource: "inherited",
+      }),
+    ).resolves.toMatchObject({ contextMode: "off", contextPackId: null });
+    await expect(
+      validateGenerationCreativeContext({
+        contextPackId: "pack-inherited",
+        contextPackSource: "inherited",
+        contextModeOverride: "off",
+        reuseLabels: [
+          {
+            kind: "slide",
+            label: "Fresh edit",
+            dataRole: "untrusted-reference",
+            influence: "generated",
+          },
+        ],
+      }),
+    ).resolves.toMatchObject({
+      contextMode: "off",
+      contextPackId: null,
+      reuseLabels: [{ influence: "generated" }],
+    });
+    expect(mocks.getContextPack).not.toHaveBeenCalled();
+  });
+
+  it("rejects explicit evidence labels and strips inherited evidence when off", async () => {
+    const evidence = {
+      itemId: "item-1",
+      itemVersionId: "version-1",
+      kind: "slide",
+      label: "Imported slide",
+      dataRole: "untrusted-reference" as const,
+      influence: "adapted" as const,
+    };
+    await expect(
+      validateGenerationCreativeContext({
+        contextModeOverride: "off",
+        reuseLabels: [evidence],
+        reuseLabelsSource: "explicit",
+      }),
+    ).rejects.toThrow(/only generated/i);
+    await expect(
+      validateGenerationCreativeContext({
+        contextModeOverride: "off",
+        reuseLabels: [
+          evidence,
+          {
+            kind: "slide",
+            label: "Fresh slide",
+            dataRole: "untrusted-reference",
+            influence: "generated",
+          },
+        ],
+        reuseLabelsSource: "inherited",
+      }),
+    ).resolves.toMatchObject({
+      contextMode: "off",
+      contextPackId: null,
+      reuseLabels: [{ label: "Fresh slide", influence: "generated" }],
+    });
+    expect(mocks.getContextPack).not.toHaveBeenCalled();
+  });
+});

package/src/server/generation-context.spec.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+
+import type { CreativeContextReuseLabel } from "../types.js";
+import {
+  mergeCreativeContextReuseLabels,
+  replaceCreativeContextElementProvenance,
+  validateCreativeContextReuseLabels,
+} from "./generation-context.js";
+
+const evidence: CreativeContextReuseLabel = {
+  itemId: "item-1",
+  itemVersionId: "version-1",
+  kind: "slide",
+  label: "Metrics slide",
+  dataRole: "untrusted-reference",
+};
+
+describe("validateCreativeContextReuseLabels", () => {
+  it("preserves explicit per-element influence and element ids", () => {
+    expect(
+      validateCreativeContextReuseLabels(
+        [{ ...evidence, elementId: "slide-2", influence: "adapted" }],
+        { allowedEvidence: new Set(["item-1:version-1"]) },
+      ),
+    ).toEqual([
+      {
+        ...evidence,
+        elementId: "slide-2",
+        influence: "adapted",
+      },
+    ]);
+  });
+
+  it("allows generated elements to omit corpus evidence ids", () => {
+    expect(
+      validateCreativeContextReuseLabels(
+        [
+          {
+            kind: "slide",
+            label: "Net-new closing slide",
+            dataRole: "untrusted-reference",
+            elementId: "slide-8",
+            influence: "generated",
+          },
+        ],
+        { generatedOnly: true },
+      ),
+    ).toMatchObject([{ influence: "generated", elementId: "slide-8" }]);
+  });
+
+  it("rejects source-backed influence outside the exact pack", () => {
+    expect(() =>
+      validateCreativeContextReuseLabels([evidence], {
+        allowedEvidence: new Set(["item-2:version-2"]),
+      }),
+    ).toThrow("must belong to contextPackId");
+  });
+
+  it("rejects incomplete evidence pairs and non-generated missing ids", () => {
+    expect(() =>
+      validateCreativeContextReuseLabels([
+        { ...evidence, itemVersionId: undefined },
+      ]),
+    ).toThrow("both itemId and itemVersionId");
+    expect(() =>
+      validateCreativeContextReuseLabels([
+        {
+          kind: "document",
+          label: "Draft",
+          dataRole: "untrusted-reference",
+          influence: "adapted",
+        },
+      ]),
+    ).toThrow("Only generated element labels");
+  });
+});
+
+describe("creative context provenance merging", () => {
+  it("keeps prior labels while deduplicating exact evidence", () => {
+    expect(
+      mergeCreativeContextReuseLabels(
+        [evidence],
+        [evidence, { ...evidence, elementId: "slide-2" }],
+      ),
+    ).toEqual([evidence, { ...evidence, elementId: "slide-2" }]);
+  });
+
+  it("replaces only the provenance for regenerated elements", () => {
+    expect(
+      replaceCreativeContextElementProvenance(
+        [
+          {
+            elementId: "slide-1",
+            influence: "adapted",
+            itemId: "item-1",
+            itemVersionId: "version-1",
+          },
+          { elementId: "slide-2", influence: "generated" },
+        ],
+        [
+          {
+            elementId: "slide-2",
+            influence: "reference-conditioned",
+            itemId: "item-2",
+            itemVersionId: "version-2",
+          },
+        ],
+      ),
+    ).toEqual([
+      {
+        elementId: "slide-1",
+        influence: "adapted",
+        itemId: "item-1",
+        itemVersionId: "version-1",
+      },
+      {
+        elementId: "slide-2",
+        influence: "reference-conditioned",
+        itemId: "item-2",
+        itemVersionId: "version-2",
+      },
+    ]);
+  });
+});