@agent-native/creative-context 0.3.0 → 0.5.0

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

@@ -5,6 +5,10 @@ const mocks = vi.hoisted(() => ({
   getContextPack: vi.fn(),
   getCreativeContextItem: vi.fn(),
   listAccessibleSearchDocuments: vi.fn(),
+  listCreativeContexts: vi.fn(),
+  getCreativeContextById: vi.fn(),
+  getCreativeContextAppBinding: vi.fn(),
+  createContextPack: vi.fn(),
   performCreativeContextSearch: vi.fn(),
   recordLocal: vi.fn(),
   getLocal: vi.fn(),
@@ -26,6 +30,10 @@ vi.mock("../store/index.js", () => ({
   getContextPack: mocks.getContextPack,
   getCreativeContextItem: mocks.getCreativeContextItem,
   listAccessibleSearchDocuments: mocks.listAccessibleSearchDocuments,
+  listCreativeContexts: mocks.listCreativeContexts,
+  getCreativeContextById: mocks.getCreativeContextById,
+  getCreativeContextAppBinding: mocks.getCreativeContextAppBinding,
+  createContextPack: mocks.createContextPack,
 }));
 
 vi.mock("../store/generation.js", () => ({
@@ -46,6 +54,9 @@ vi.mock("./isolated-a2a.js", () => ({
     limit: input.limit,
     contextPackId: input.contextPackId,
     contextPackSource: input.contextPackSource,
+    ...(input.selectedContextId
+      ? { selectedContextId: input.selectedContextId }
+      : {}),
   })),
 }));
 
@@ -78,6 +89,9 @@ describe("generation context isolated A2A routing", () => {
       async (_identity, _target, operation) => `cap-${operation}`,
     );
     mocks.callA2A.mockResolvedValue(emptyRemoteContext);
+    mocks.listCreativeContexts.mockResolvedValue({ contexts: [] });
+    mocks.getCreativeContextById.mockResolvedValue(null);
+    mocks.getCreativeContextAppBinding.mockResolvedValue(null);
   });
 
   it("routes bounded resolve, validate, read, and record operations remotely", async () => {
@@ -146,4 +160,123 @@ describe("generation context isolated A2A routing", () => {
     expect(mocks.performCreativeContextSearch).toHaveBeenCalled();
     expect(mocks.callA2A).not.toHaveBeenCalled();
   });
+
+  it("fuses Default with the selected specialty and snapshots the provenance", async () => {
+    mocks.hasA2A.mockReturnValue(false);
+    mocks.readAppState.mockResolvedValue({
+      contextMode: "auto",
+      selectedContextId: "specialty-1",
+    });
+    mocks.listCreativeContexts.mockResolvedValue({
+      contexts: [{ id: "default-1", kind: "default" }],
+    });
+    mocks.getCreativeContextById.mockResolvedValue({
+      id: "specialty-1",
+      kind: "specialty",
+    });
+    mocks.performCreativeContextSearch
+      .mockResolvedValueOnce({
+        results: [
+          {
+            itemId: "base-item",
+            itemVersionId: "base-v1",
+            kind: "slide",
+            title: "Default evidence",
+            score: 0.5,
+            reasons: ["default"],
+          },
+        ],
+      })
+      .mockResolvedValueOnce({
+        results: [
+          {
+            itemId: "specialty-item",
+            itemVersionId: "specialty-v1",
+            kind: "slide",
+            title: "Specialty evidence",
+            score: 0.5,
+            reasons: ["specialty"],
+          },
+        ],
+      });
+    mocks.createContextPack.mockResolvedValue({ id: "snapshot-1" });
+
+    await expect(
+      resolveGenerationCreativeContext({ role: "slides", query: "launch" }),
+    ).resolves.toMatchObject({ contextPackId: "snapshot-1" });
+    expect(mocks.performCreativeContextSearch).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ contextId: "default-1", snapshot: false }),
+    );
+    expect(mocks.performCreativeContextSearch).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ contextId: "specialty-1", snapshot: false }),
+    );
+    expect(mocks.createContextPack).toHaveBeenCalledWith(
+      expect.objectContaining({
+        baseContextId: "default-1",
+        specialtyContextId: "specialty-1",
+        selectionReason: "explicit specialty selection",
+      }),
+    );
+  });
+
+  it("uses one matching specialty when no explicit or app binding exists", async () => {
+    mocks.hasA2A.mockReturnValue(false);
+    mocks.listCreativeContexts.mockResolvedValue({
+      contexts: [
+        { id: "default-1", kind: "default", name: "Default" },
+        {
+          id: "marketing-1",
+          kind: "specialty",
+          name: "Marketing",
+          description: "Campaigns, launches, and demand generation",
+        },
+        { id: "product-1", kind: "specialty", name: "Product" },
+      ],
+    });
+    mocks.performCreativeContextSearch
+      .mockResolvedValueOnce({
+        results: [
+          {
+            itemId: "base-item",
+            itemVersionId: "base-v1",
+            kind: "slide",
+            title: "Default evidence",
+            score: 0.5,
+            reasons: ["default"],
+          },
+        ],
+      })
+      .mockResolvedValueOnce({ results: [] });
+    mocks.createContextPack.mockResolvedValue({ id: "snapshot-1" });
+
+    await resolveGenerationCreativeContext({
+      role: "slides",
+      query: "Build the marketing launch deck",
+    });
+
+    expect(mocks.performCreativeContextSearch).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ contextId: "marketing-1" }),
+    );
+    expect(mocks.createContextPack).toHaveBeenCalledWith(
+      expect.objectContaining({
+        specialtyContextId: "marketing-1",
+        selectionReason: "semantic specialty match",
+      }),
+    );
+  });
+
+  it("forwards a selected specialty to isolated resolution", async () => {
+    mocks.readAppState.mockResolvedValue({
+      contextMode: "auto",
+      selectedContextId: "specialty-1",
+    });
+    await resolveGenerationCreativeContext({ role: "design", query: "hero" });
+    expect(mocks.callA2A).toHaveBeenCalledWith(
+      "resolve",
+      expect.objectContaining({ selectedContextId: "specialty-1" }),
+    );
+  });
 });

package/src/server/generation-context.ts

@@ -6,13 +6,18 @@ import {
   recordGenerationCreativeContext as recordGenerationCreativeContextLocal,
 } from "../store/generation.js";
 import {
+  createContextPack,
+  getCreativeContextAppBinding,
+  getCreativeContextById,
   getContextPack,
   getCreativeContextItem,
+  listCreativeContexts,
   listAccessibleSearchDocuments,
 } from "../store/index.js";
 import type {
   CreativeContextElementProvenance,
   CreativeContextReuseLabel,
+  CreativeContextSummary,
 } from "../types.js";
 import {
   assertGenerationArtifactAccess,
@@ -32,9 +37,56 @@ import {
   UNTRUSTED_REFERENCE_ROLE,
 } from "./untrusted-reference.js";
 
-export type CreativeGenerationRole = "slides" | "design" | "assets" | "content";
+export type CreativeGenerationRole =
+  | "slides"
+  | "design"
+  | "assets"
+  | "content"
+  | "analytics";
 export type CreativeContextModeOverride = "off";
 
+const SPECIALTY_STOP_WORDS = new Set([
+  "and",
+  "for",
+  "from",
+  "into",
+  "our",
+  "the",
+  "this",
+  "with",
+]);
+
+function specialtyTokens(value: string) {
+  return new Set(
+    value
+      .toLocaleLowerCase()
+      .split(/[^\p{L}\p{N}]+/u)
+      .filter((token) => token.length >= 3 && !SPECIALTY_STOP_WORDS.has(token)),
+  );
+}
+
+export function selectSemanticSpecialty(
+  contexts: readonly CreativeContextSummary[],
+  query: string,
+): CreativeContextSummary | null {
+  const queryText = query.toLocaleLowerCase();
+  const queryTokens = specialtyTokens(query);
+  let best: { context: CreativeContextSummary; score: number } | null = null;
+  for (const context of contexts) {
+    if (context.kind !== "specialty") continue;
+    const name = context.name.toLocaleLowerCase().trim();
+    const nameTokens = specialtyTokens(context.name);
+    const descriptionTokens = specialtyTokens(context.description ?? "");
+    let score = name.length >= 3 && queryText.includes(name) ? 4 : 0;
+    for (const token of queryTokens) {
+      if (nameTokens.has(token)) score += 2;
+      else if (descriptionTokens.has(token)) score += 1;
+    }
+    if (score >= 2 && (!best || score > best.score)) best = { context, score };
+  }
+  return best?.context ?? null;
+}
+
 function defaultArtifactAccessTarget(
   identity: GenerationArtifactIdentity,
 ): GenerationArtifactAccessTarget | undefined {
@@ -110,6 +162,8 @@ export interface ResolveGenerationCreativeContextInput {
   limit?: number;
   contextPackId?: string;
   contextPackSource?: "explicit" | "inherited";
+  /** Forwarded by isolated callers; local callers normally use app state. */
+  selectedContextId?: string | null;
   contextModeOverride?: CreativeContextModeOverride;
 }
 
@@ -201,6 +255,7 @@ export async function resolveGenerationCreativeContext(
     )) as {
       contextMode?: "auto" | "off";
       pinnedPackId?: string | null;
+      selectedContextId?: string | null;
     } | null;
     if (state?.contextMode === "off") {
       return resolveGenerationCreativeContextLocal(input);
@@ -213,6 +268,9 @@ export async function resolveGenerationCreativeContext(
             contextPackId: state.pinnedPackId,
             contextPackSource: "inherited" as const,
           }),
+      ...(state?.selectedContextId
+        ? { selectedContextId: state.selectedContextId }
+        : {}),
     });
   }
   return resolveGenerationCreativeContextLocal(input);
@@ -240,6 +298,7 @@ export async function resolveGenerationCreativeContextLocal(
   const state = (await readAppState("creative-context").catch(() => null)) as {
     contextMode?: "auto" | "off";
     pinnedPackId?: string | null;
+    selectedContextId?: string | null;
   } | null;
   if (state?.contextMode === "off") {
     if (
@@ -265,17 +324,104 @@ export async function resolveGenerationCreativeContextLocal(
       "query is required when no exact contextPackId is supplied",
     );
   }
-  const search = await performCreativeContextSearch({
+  const selectedContextId = input.selectedContextId ?? state?.selectedContextId;
+  const [contexts, selected, bound] = await Promise.all([
+    listCreativeContexts({ limit: 100 }),
+    selectedContextId ? getCreativeContextById(selectedContextId) : null,
+    selectedContextId
+      ? Promise.resolve(null)
+      : getCreativeContextAppBinding(input.role),
+  ]);
+  const base =
+    selected?.kind === "default"
+      ? selected
+      : (contexts.contexts.find((context) => context.kind === "default") ??
+        null);
+  const semantic =
+    !selected && !bound
+      ? selectSemanticSpecialty(contexts.contexts, input.query)
+      : null;
+  const specialty =
+    selected?.kind === "specialty"
+      ? selected
+      : bound?.kind === "specialty"
+        ? bound
+        : semantic;
+  const searchInput = {
     query: input.query,
     limit: Math.max(1, Math.min(20, input.limit ?? 8)),
     maxPerSource: 3,
-    snapshot: true,
-    contextPackName: `${input.role}: ${input.query.slice(0, 100)}`,
+    snapshot: false,
+  };
+  const [baseSearch, specialtySearch] = await Promise.all([
+    base
+      ? performCreativeContextSearch({ ...searchInput, contextId: base.id })
+      : performCreativeContextSearch(searchInput),
+    specialty
+      ? performCreativeContextSearch({
+          ...searchInput,
+          contextId: specialty.id,
+        })
+      : Promise.resolve(null),
+  ]);
+  const fused = new Map<string, (typeof baseSearch.results)[number]>();
+  for (const result of baseSearch.results)
+    fused.set(`${result.itemId}:${result.itemVersionId}`, result);
+  for (const result of specialtySearch?.results ?? []) {
+    const key = `${result.itemId}:${result.itemVersionId}`;
+    const existing = fused.get(key);
+    fused.set(key, {
+      ...result,
+      score: Math.max(
+        result.score + 0.15,
+        existing?.score ?? Number.NEGATIVE_INFINITY,
+      ),
+      reasons: [...(existing?.reasons ?? []), "specialty context boost"],
+    });
+  }
+  const results = [...fused.values()]
+    .sort((a, b) => b.score - a.score)
+    .slice(0, searchInput.limit);
+  if (!results.length) {
+    return {
+      contextMode: "auto" as const,
+      contextPackId: null,
+      reuseLabels: [],
+      results: [],
+    };
+  }
+  const pack = await createContextPack({
+    name: `${input.role}: ${input.query.slice(0, 100)}`,
+    description: "Immutable governed-context generation snapshot.",
+    contextMode: "auto",
+    baseContextId: base?.id ?? null,
+    specialtyContextId: specialty?.id ?? null,
+    selectionReason: specialty
+      ? selected?.id === specialty.id
+        ? "explicit specialty selection"
+        : bound?.id === specialty.id
+          ? "app specialty binding"
+          : "semantic specialty match"
+      : base
+        ? "Default context"
+        : "legacy accessible corpus fallback",
+    request: {
+      query: input.query,
+      role: input.role,
+      baseContextId: base?.id ?? null,
+      specialtyContextId: specialty?.id ?? null,
+    },
+    members: results.map((result) => ({
+      itemId: result.itemId,
+      itemVersionId: result.itemVersionId,
+      reason: result.reasons.join("; ") || "governed context match",
+      score: result.score,
+    })),
   });
   return {
     contextMode: "auto" as const,
-    contextPackId: search.contextPackId,
-    reuseLabels: search.results.map((result) => ({
+    contextPackId: pack.id,
+    reuseLabels: results.map((result) => ({
       itemId: result.itemId,
       itemVersionId: result.itemVersionId,
       kind: result.kind,
@@ -285,7 +431,7 @@ export async function resolveGenerationCreativeContextLocal(
         .trim(),
       dataRole: UNTRUSTED_REFERENCE_ROLE,
     })),
-    results: search.results,
+    results,
   };
 }
 

package/src/server/index.spec.ts

@@ -0,0 +1,15 @@
+import { getShareableResource } from "@agent-native/core/sharing";
+import { describe, expect, it } from "vitest";
+
+import "./index.js";
+
+describe("creative context shareable registrations", () => {
+  it("requires org membership for creative context pack user shares", () => {
+    const registration = getShareableResource("creative-context-pack");
+
+    expect(registration).toMatchObject({
+      allowPublic: false,
+      requireOrgMemberForUserShares: true,
+    });
+  });
+});

package/src/server/index.ts

@@ -41,6 +41,17 @@ registerWorkspaceConnectionLifecycleListener(async (event) => {
 
 function registerCreativeContextShareables(): void {
   const getDb = () => getCreativeContext().getDb();
+  registerShareableResource({
+    type: "creative-context",
+    resourceTable: schema.creativeContexts,
+    sharesTable: schema.creativeContextShares,
+    displayName: "Creative context",
+    titleColumn: "name",
+    getResourcePath: getCreativeContextResourcePath,
+    getDb,
+    allowPublic: false,
+    requireOrgMemberForUserShares: true,
+  });
   registerShareableResource({
     type: "creative-context-source",
     resourceTable: schema.contextSources,
@@ -70,6 +81,7 @@ function registerCreativeContextShareables(): void {
     getResourcePath: getCreativeContextResourcePath,
     getDb,
     allowPublic: false,
+    requireOrgMemberForUserShares: true,
   });
 }
 
@@ -128,6 +140,10 @@ export * from "./prompt-provider.js";
 export * from "./retrieval.js";
 export * from "./untrusted-reference.js";
 export * from "./media.js";
+export * from "./native-resource-capture.js";
+export * from "./safe-native-preview.js";
+export { serializePrivateBlobHandle } from "../connectors/private-artifacts.js";
+export { resolveNativeContextCloneReference } from "../store/contexts.js";
 export {
   CREATIVE_CONTEXT_BACKGROUND_PROCESSOR_ROUTE,
   CREATIVE_CONTEXT_IMPORT_PROCESSOR_ROUTE,

package/src/server/isolated-a2a.ts

@@ -95,10 +95,11 @@ const resolvedContextSchema = z
 const resolvePayloadSchema = z
   .object({
     query: z.string().max(1_000).optional(),
-    role: z.enum(["slides", "design", "assets", "content"]),
+    role: z.enum(["slides", "design", "assets", "content", "analytics"]),
     limit: z.number().int().min(1).max(20).optional(),
     contextPackId: boundedId.optional(),
     contextPackSource: z.enum(["explicit", "inherited"]).optional(),
+    selectedContextId: boundedId.nullable().optional(),
   })
   .strict();
 const validatePayloadSchema = z
@@ -387,6 +388,7 @@ export type IsolatedResolvePayload = {
   limit?: number;
   contextPackId?: string;
   contextPackSource?: "explicit" | "inherited";
+  selectedContextId?: string | null;
 };
 
 export function isolatedResolvePayload(
@@ -398,6 +400,7 @@ export function isolatedResolvePayload(
     limit: input.limit,
     contextPackId: input.contextPackId,
     contextPackSource: input.contextPackSource,
+    selectedContextId: input.selectedContextId ?? undefined,
   };
 }
 

package/src/server/media.spec.ts

@@ -6,6 +6,7 @@ const mocks = vi.hoisted(() => ({
   runWithRequestContext: vi.fn(async (_context, fn) => fn()),
   readPrivateArtifact: vi.fn(async () => new Uint8Array([1, 2, 3])),
   getCreativeContextItem: vi.fn(),
+  readPendingCreativeContextMedia: vi.fn(),
 }));
 
 vi.mock("@agent-native/core/server", () => ({
@@ -31,6 +32,7 @@ vi.mock("../connectors/private-artifacts.js", () => ({
 
 vi.mock("../store/index.js", () => ({
   getCreativeContextItem: mocks.getCreativeContextItem,
+  readPendingCreativeContextMedia: mocks.readPendingCreativeContextMedia,
 }));
 
 vi.mock("./context.js", () => ({
@@ -43,7 +45,7 @@ function event() {
   return {
     req: {
       method: "GET",
-      url: "http://app.example/_agent-native/creative-context/media?itemId=item-1",
+      url: "http://app.example/_agent-native/creative-context/media?itemId=item-1&itemVersionId=version-1",
       headers: new Headers({ origin: "http://app.example" }),
     },
   };
@@ -62,6 +64,7 @@ describe("creative context media route", () => {
       version: { id: "version-1" },
       media: [],
     });
+    mocks.readPendingCreativeContextMedia.mockReset().mockResolvedValue(null);
     await createCreativeContextMediaPlugin()({});
   });
 
@@ -86,7 +89,32 @@ describe("creative context media route", () => {
     );
     expect(mocks.getCreativeContextItem).toHaveBeenCalledWith(
       "item-1",
-      undefined,
+      "version-1",
     );
   });
+
+  it("uses the narrow pending-submission path only after generic item access fails", async () => {
+    mocks.getSession.mockResolvedValue({
+      email: "bob@example.test",
+      orgId: "org-1",
+    });
+    mocks.getCreativeContextItem.mockResolvedValue(null);
+    mocks.readPendingCreativeContextMedia.mockResolvedValue({
+      itemId: "item-1",
+      itemVersionId: "version-1",
+      mediaId: null,
+      storageKey: "creative-context-blob:v1:example",
+      mimeType: "image/png",
+    });
+
+    const response = await mocks.handler!(event());
+
+    expect(response.status).toBe(200);
+    expect(mocks.readPendingCreativeContextMedia).toHaveBeenCalledWith({
+      itemId: "item-1",
+      itemVersionId: "version-1",
+      mediaId: undefined,
+    });
+    expect(await response.text()).not.toContain("creative-context-blob");
+  });
 });

package/src/server/media.ts

@@ -11,7 +11,10 @@ import {
   readPrivateArtifact,
 } from "../connectors/private-artifacts.js";
 import { CREATIVE_CONTEXT_MEDIA_ROUTE } from "../media-url.js";
-import { getCreativeContextItem } from "../store/index.js";
+import {
+  getCreativeContextItem,
+  readPendingCreativeContextMedia,
+} from "../store/index.js";
 import { getCreativeContext } from "./context.js";
 
 const SAFE_MIME_TYPES = new Set([
@@ -20,6 +23,8 @@ const SAFE_MIME_TYPES = new Set([
   "image/webp",
   "image/gif",
   "image/svg+xml",
+  "video/mp4",
+  "video/webm",
 ]);
 
 export function createCreativeContextMediaPlugin(): NitroPluginDef {
@@ -95,23 +100,37 @@ export async function readCreativeContextMedia(input: {
   }
   if (!itemId) throw new Error("Creative context media was not found");
   const detail = await getCreativeContextItem(itemId, itemVersionId);
-  if (!detail) throw new Error("Creative context media is not accessible");
-  const media = input.mediaId
-    ? detail.media.find((entry) => entry.id === input.mediaId)
-    : null;
-  const handle = parsePrivateBlobHandle(
-    media?.storageKey ?? detail.item.thumbnailBlobRef,
-  );
+  const pending = detail
+    ? null
+    : await readPendingCreativeContextMedia({
+        mediaId: input.mediaId,
+        itemId,
+        itemVersionId,
+      });
+  if (!detail && !pending)
+    throw new Error("Creative context media is not accessible");
+  const media =
+    detail && input.mediaId
+      ? (detail.media.find((entry) => entry.id === input.mediaId) ?? null)
+      : null;
+  const storageKey = detail
+    ? (media?.storageKey ?? detail.item.thumbnailBlobRef)
+    : pending?.storageKey;
+  const handle = parsePrivateBlobHandle(storageKey);
   if (!handle) throw new Error("Creative context media has no private blob");
   return {
     data: await readPrivateArtifact(
       handle,
       getCreativeContext().connectorContext,
     ),
-    mimeType: media?.mimeType ?? handle.mimeType ?? "application/octet-stream",
-    itemId: detail.item.id,
-    itemVersionId: detail.version.id,
-    mediaId: media?.id ?? null,
+    mimeType:
+      media?.mimeType ??
+      (detail ? detail.version.mimeType : pending?.mimeType) ??
+      handle.mimeType ??
+      "application/octet-stream",
+    itemId: detail?.item.id ?? pending!.itemId,
+    itemVersionId: detail?.version.id ?? pending!.itemVersionId,
+    mediaId: media?.id ?? pending?.mediaId ?? null,
     media,
   };
 }