Media Provenance & C2PA

pnpm add @provenancekit/media

import { isC2PAAvailable } from "@provenancekit/media";

if (!await isC2PAAvailable()) {
  console.warn("C2PA not available — install @contentauth/c2pa-node");
}

import { readManifest, readManifestFromBuffer } from "@provenancekit/media";

// From file path
const manifest = await readManifest("/path/to/image.jpg");

if (manifest) {
  console.log(manifest.title);
  console.log(manifest.generator);   // tool that created the content
  console.log(manifest.aiDisclosure); // "ai_generated" | "ai_assisted" | null
  console.log(manifest.ingredients); // previous versions, training data
  console.log(manifest.actions);     // list of edits/transformations
}

// From buffer (e.g. in-memory or uploaded file)
const buffer = await fs.readFile("photo.jpg");
const manifest = await readManifestFromBuffer(buffer, "image/jpeg");

import { embedManifest } from "@provenancekit/media";

const outputBuffer = await embedManifest({
  inputPath: "/path/to/original.jpg",
  manifest: {
    title: "My Photograph",
    generator: { name: "Lightroom", version: "25.0" },
    actions: [
      { action: "c2pa.color_adjustments", when: new Date().toISOString() },
      { action: "c2pa.cropped", when: new Date().toISOString() },
    ],
    aiDisclosure: null,  // purely human-authored
    signingCertificate: process.env.SIGNING_CERT_PEM!,
    signingKey: process.env.SIGNING_KEY_PEM!,
  },
});

await fs.writeFile("/path/to/signed.jpg", outputBuffer);

import { detectAIContent, hasManifest, getManifestSummary } from "@provenancekit/media";

// Quick check — is this file AI-generated or AI-assisted?
const detection = await detectAIContent("/path/to/image.jpg");
// { isAIGenerated: true, isAIAssisted: false, confidence: "high", source: "c2pa-manifest" }

// Get a human-readable summary
const summary = await getManifestSummary("/path/to/image.jpg");
// "Adobe Firefly (AI generated) · edited in Photoshop · signed by Adobe"

import { c2paToEAA, eaaToC2PA } from "@provenancekit/media";

// Convert a C2PA manifest to an EAA ProvenanceBundle
const manifest = await readManifest("/path/to/image.jpg");
if (manifest) {
  const bundle = c2paToEAA(manifest);
  // bundle.entities = [{ id: "c2pa:Adobe", role: "organization" }]
  // bundle.actions = [{ type: "create", ... }]
  // bundle.resources = [{ cid: "...", type: "image" }]

  // Store in ProvenanceKit
  const pk = new ProvenanceKit({ apiKey: "pk_live_..." });
  // Use bundle data to record EAA provenance...
}

// Convert an EAA bundle to a C2PA manifest
import type { ProvenanceBundle } from "@provenancekit/eaa-types";

const bundle: ProvenanceBundle = { ... };
const c2paManifest = eaaToC2PA(bundle);

import { embedManifest } from "@provenancekit/media";
import { ProvenanceKit } from "@provenancekit/sdk";

async function publishAIGeneratedImage(
  imageBuffer: Buffer,
  generatingModel: { provider: string; model: string }
) {
  const pk = new ProvenanceKit({ apiKey: "pk_live_..." });

  // 1. Record EAA provenance
  const { cid, actionId } = await pk.file(imageBuffer, {
    entity: { id: "org:myapp", role: "organization" },
    action: {
      type: "create",
      extensions: {
        "ext:ai@1.0.0": {
          provider: generatingModel.provider,
          model: generatingModel.model,
          autonomyLevel: "autonomous",
        },
      },
    },
    resourceType: "image",
  });

  // 2. Embed C2PA manifest for interoperability
  const signedBuffer = await embedManifest({
    inputBuffer: imageBuffer,
    mimeType: "image/jpeg",
    manifest: {
      title: `AI-generated image (${generatingModel.model})`,
      generator: {
        name: generatingModel.provider,
        version: generatingModel.model,
      },
      aiDisclosure: "ai_generated",   // required by EU AI Act Art. 50
      actions: [
        {
          action: "c2pa.created",
          softwareAgent: `${generatingModel.provider}/${generatingModel.model}`,
          when: new Date().toISOString(),
        },
      ],
      // Link to EAA provenance record
      metadata: {
        "provenancekit:cid": cid,
        "provenancekit:actionId": actionId,
      },
    },
  });

  return { cid, signedBuffer };
}

{
  "ext:c2pa@1.0.0": {
    "manifestCid": "bafybeig...",
    "generator": "Adobe Firefly 3.0",
    "aiDisclosure": "ai_generated",
    "actions": ["c2pa.created"],
    "ingredientCids": [],
    "validSignature": true,
    "signedBy": "Adobe Inc."
  }
}

# Extract manifest from an uploaded image
curl -X POST https://api.provenancekit.com/v1/media/extract \
  -H "Authorization: Bearer pk_live_..." \
  -F "file=@image.jpg"

# Embed manifest and record provenance in one call
curl -X POST https://api.provenancekit.com/v1/media/embed \
  -H "Authorization: Bearer pk_live_..." \
  -F "file=@image.jpg" \
  -F 'json={"entityId":"org:myapp","generator":"DALL-E 3","aiDisclosure":"ai_generated"}'