File Attribution & Ownership Claims

Search result: { cid: "Qm...", score: 1.0, ... }
                        ↓
Use this CID directly as inputCid in the AI response action.

// POST /api/claim
// FormData: { file, owned: "true"|"false", userId, mimeType }
import { ProvenanceKit } from "@provenancekit/sdk";

export async function POST(req: Request) {
  const form = await req.formData();
  const file = form.get("file") as File;
  const owned = form.get("owned") === "true";
  const userId = (form.get("userId") as string) ?? "anonymous";
  const mimeType = (form.get("mimeType") as string) ?? file.type;

  const pk = new ProvenanceKit({ apiKey: process.env.PK_API_KEY });

  const entityId = await pk.entity({ role: "human", name: userId });

  const result = await pk.file(file, {
    entity: { id: entityId, role: "human", name: userId },
    action: {
      type: owned ? "create" : "reference",
    },
    resourceType: mimeType.startsWith("image/") ? "image" : "text",
    // On-chain recording fires automatically if CHAIN_PRIVATE_KEY is set
  });

  return Response.json({
    cid: result.cid,
    actionId: result.actionId,
    onchain: result.onchain ?? null,
    status: owned ? "claimed" : "referenced",
  });
}

import { FileProvenanceTag } from "@provenancekit/ui";

function AttachmentPreview({ file, userId, onCidAssigned }) {
  async function handleClaim(owned: boolean) {
    const form = new FormData();
    form.append("file", file, file.name);
    form.append("owned", String(owned));
    form.append("userId", userId);
    form.append("mimeType", file.type);

    const res = await fetch("/api/claim", { method: "POST", body: form });
    if (!res.ok) throw new Error("Claim failed");

    const { cid, status } = await res.json();
    onCidAssigned(cid);                         // ← propagate CID to parent state
    return { cid, status };                     // ← returned to FileOwnershipClaim
  }

  return (
    <div className="attachment">
      <span>{file.name}</span>
      <FileProvenanceTag
        file={file}
        onClaim={handleClaim}                   // ← shown when file not found
        onViewDetail={(cid) => navigate(`/provenance/${cid}`)}
      />
    </div>
  );
}

┌─────────────────────────────────────────┐
│ New file — do you own this?             │
│ [✓ Yes, I own it]  [↗ No, I don't]     │
└─────────────────────────────────────────┘

✓ Claimed as your work       (owned = true)
✓ Recorded as external source (owned = false)

// The claimed CID is now a first-class provenance input
const response = await pk.file(responseBlob, {
  entity: { id: agentId, role: "ai", name: "openai/gpt-4o" },
  action: {
    type: "generate",
    inputCids: [
      promptCid,          // the user's text prompt
      attachedFileCid,    // ← the claimed or matched file CID
    ],
    aiTool: { provider: "openai", model: "gpt-4o" },
  },
  resourceType: "text",
});

[user] ──creates──► [photo.jpg]        (owned = true)
    OR
[user] ──references──► [photo.jpg]     (owned = false)

Both connect as:

[photo.jpg] ──inputCid──► [generate action] ──produces──► [AI response]

const result = await pk.file(file, { ... });

if (result.onchain) {
  console.log("Anchored on-chain:", result.onchain.txHash);
  // txHash can be verified on Basescan
}

Entities:    alice (role: human)
Resources:   photo.jpg (CID: Qm..., type: image)
             ai-response.txt (CID: Qm..., type: text)
Actions:     [create] alice → photo.jpg
             [generate] gpt-4o → ai-response.txt
               inputCids: [photo.jpg, prompt.json]

Entities:    alice (role: human)
Resources:   external-file.jpg (CID: Qm..., type: image)
             ai-response.txt (CID: Qm..., type: text)
Actions:     [reference] alice → external-file.jpg
             [generate] gpt-4o → ai-response.txt
               inputCids: [external-file.jpg, prompt.json]