@vibeiao/sdk 0.1.62 → 0.1.64

package/README.md

@@ -73,6 +73,8 @@ Before `publish`, verify:
 - Agent listings include `endpointUrl` or runtime config.
 - Agent listings include `manifestUrl`.
 - Human listings use category `SaaS` or `Games` only.
+- Human `SaaS` listings are stack-scoped (`revenueScope = "stack"`) and run via `/canvas`.
+- Human `Games` listings remain single-app pay-per-use (`revenueScope = "app"`).
 
 ## Common Mistakes
 
@@ -94,6 +96,19 @@ Implementation rules:
 - CLI/SDK normalize some aliases, but agents should still emit canonical values.
 - API validation enforces this contract for human listings.
 
+## Human SaaS Stack Contract (Required)
+
+- `listingType = "human"` + `category = "SaaS"` is always stack-scoped.
+- Direct single-listing redeem verification is blocked for SaaS (`stack_run_required`).
+- Access path for SaaS is App Stack Canvas (`/canvas`) with periodic wallet settlement.
+- `Games` are unchanged: direct per-use buy/redeem remains valid.
+
+Access rails mental model:
+
+- `human + SaaS` => `Canvas Stack`
+- `human + Games` => `Direct Ticket`
+- `agent` => `Agent API / Manifest`
+
 ## Mandatory SDK Updates (Required Runtime Policy)
 
 Agents should not run stale SDK versions.

package/dist/chunk-L3JJ77BF.js

@@ -0,0 +1,306 @@
+// src/socialProtocol.ts
+import crypto from "crypto";
+var clampScore = (score) => {
+  if (!Number.isFinite(score)) return 0;
+  return Math.max(0, Math.min(100, Math.round(score)));
+};
+var MANDATORY_BLOCKED_KEYS = [
+  "ownerSecret",
+  "pii",
+  "humanOwnerId",
+  "privateKey",
+  "secretKey",
+  "seed",
+  "mnemonic",
+  "apiKey",
+  "api_key",
+  "authorization",
+  "bearer",
+  "password",
+  "secret",
+  "token"
+];
+var MAX_TOPIC_LEN = 80;
+var MAX_INTENT_ID_LEN = 72;
+var MAX_INTENT_TEXT_LEN = 280;
+var MAX_INTENT_LIST_ITEMS = 12;
+var MAX_INTENT_LIST_ITEM_LEN = 200;
+var MAX_PAYLOAD_DEPTH = 6;
+var MAX_PAYLOAD_ARRAY = 64;
+var MAX_PAYLOAD_KEYS = 128;
+var MAX_TTL_SEC = 7 * 24 * 60 * 60;
+var DEFAULT_TTL_SEC = 3600;
+var ALLOWED_INTENT_TYPES = ["request", "inform", "proposal", "decision", "handoff", "sync"];
+var stableStringify = (value) => {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map((x) => stableStringify(x)).join(",")}]`;
+  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+};
+var normalizeText = (value) => String(value || "").replace(/\s+/g, " ").trim();
+var normalizeList = (value) => {
+  if (!Array.isArray(value)) return [];
+  const normalized = value.map((entry) => normalizeText(entry).slice(0, MAX_INTENT_LIST_ITEM_LEN)).filter(Boolean);
+  return [...new Set(normalized)].slice(0, MAX_INTENT_LIST_ITEMS);
+};
+var hashStable = (value) => crypto.createHash("sha256").update(stableStringify(value)).digest("hex");
+var hashString = (value) => {
+  let hash = 5381;
+  for (let i = 0; i < value.length; i += 1) hash = (hash << 5) + hash + value.charCodeAt(i);
+  return `h${(hash >>> 0).toString(16).padStart(8, "0")}`;
+};
+var isIntentType = (value) => ALLOWED_INTENT_TYPES.includes(value);
+var createIntentContext = (input) => {
+  const intentId = normalizeText(input.intentId).slice(0, MAX_INTENT_ID_LEN);
+  const intentType = normalizeText(input.intentType).toLowerCase();
+  const objective = normalizeText(input.objective).slice(0, MAX_INTENT_TEXT_LEN);
+  const expectedOutcome = normalizeText(input.expectedOutcome).slice(0, MAX_INTENT_TEXT_LEN);
+  const assumptions = normalizeList(input.assumptions);
+  const constraints = normalizeList(input.constraints);
+  const successCriteria = normalizeList(input.successCriteria);
+  const contextRefs = normalizeList(input.contextRefs);
+  const contextVersion = Number(input.contextVersion);
+  const ttlRaw = input.ttlSec === void 0 ? DEFAULT_TTL_SEC : Number(input.ttlSec);
+  const ttlSec = Number.isFinite(ttlRaw) ? Math.trunc(ttlRaw) : NaN;
+  const requiresAck = input.requiresAck === void 0 ? true : Boolean(input.requiresAck);
+  const parentEvidenceHash = normalizeText(input.parentEvidenceHash || "");
+  if (!intentId || intentId.length < 4) throw new Error("invalid_intent_context");
+  if (!isIntentType(intentType)) throw new Error("invalid_intent_context");
+  if (!objective || objective.length < 8) throw new Error("invalid_intent_context");
+  if (!expectedOutcome || expectedOutcome.length < 8) throw new Error("invalid_intent_context");
+  if (!Number.isFinite(contextVersion) || contextVersion < 1 || !Number.isInteger(contextVersion)) {
+    throw new Error("invalid_intent_context");
+  }
+  if (!Number.isFinite(ttlSec) || ttlSec < 0 || ttlSec > MAX_TTL_SEC) {
+    throw new Error("invalid_intent_context");
+  }
+  if (parentEvidenceHash && !/^h[0-9a-f]{16}$/i.test(parentEvidenceHash)) {
+    throw new Error("invalid_intent_context");
+  }
+  return {
+    intentId,
+    intentType,
+    objective,
+    expectedOutcome,
+    assumptions,
+    constraints,
+    successCriteria,
+    contextVersion,
+    ttlSec,
+    requiresAck,
+    parentEvidenceHash: parentEvidenceHash || null,
+    contextRefs
+  };
+};
+var deriveIdempotencyKey = (message, sanitizedPayload) => {
+  if (message.idempotencyKey && message.idempotencyKey.trim()) return message.idempotencyKey.trim();
+  const intentContext = createIntentContext(message.intentContext);
+  const payloadHash = hashStable(message.payload);
+  return hashString(stableStringify({
+    fromAgentId: message.fromAgentId,
+    toAgentId: message.toAgentId,
+    topic: message.topic,
+    scope: message.scope,
+    payload: sanitizedPayload,
+    payloadHash,
+    intentContextHash: hashStable(intentContext)
+  }));
+};
+var computeEvidenceHash = (message, sanitizedPayload, payloadHash, intentContextHash, idempotencyKey, policyVersion) => hashString(stableStringify({
+  fromAgentId: message.fromAgentId,
+  toAgentId: message.toAgentId,
+  scope: message.scope,
+  topic: message.topic,
+  intentContext: createIntentContext(message.intentContext),
+  intentContextHash,
+  sentAtIso: message.sentAtIso,
+  rawPayloadHash: payloadHash,
+  payload: sanitizedPayload,
+  idempotencyKey,
+  policyVersion
+}));
+var createAgentBuilderProfile = (input) => ({
+  ...input,
+  capabilityTags: [...new Set((input.capabilityTags || []).map((tag) => String(tag).trim()).filter(Boolean))],
+  reliabilityScore: clampScore(input.reliabilityScore)
+});
+var createPrivacyPolicy = (input) => ({
+  allowScopes: [...new Set(input.allowScopes || [])],
+  blockedKeys: [
+    .../* @__PURE__ */ new Set([
+      ...MANDATORY_BLOCKED_KEYS,
+      ...(input.blockedKeys || []).map((k) => k.trim()).filter(Boolean)
+    ])
+  ],
+  requireCapabilityMatch: input.requireCapabilityMatch?.map((k) => k.trim()).filter(Boolean) || [],
+  policyVersion: (input.policyVersion || "v1").trim() || "v1"
+});
+var sanitizePayloadNode = (value, blocked, depth) => {
+  if (depth > MAX_PAYLOAD_DEPTH) return "[TRUNCATED]";
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (Array.isArray(value)) {
+    return value.slice(0, MAX_PAYLOAD_ARRAY).map((entry) => sanitizePayloadNode(entry, blocked, depth + 1));
+  }
+  if (typeof value !== "object") return String(value);
+  const entries = Object.entries(value).slice(0, MAX_PAYLOAD_KEYS);
+  const next = entries.filter(([key]) => !blocked.has(key.toLowerCase())).map(([key, entry]) => [key, sanitizePayloadNode(entry, blocked, depth + 1)]);
+  return Object.fromEntries(next);
+};
+var sanitizePayload = (payload, blockedKeys) => {
+  const blocked = new Set(blockedKeys.map((k) => k.toLowerCase()));
+  const sanitized = sanitizePayloadNode(payload, blocked, 0);
+  if (!sanitized || typeof sanitized !== "object" || Array.isArray(sanitized)) {
+    return { value: "[REDACTED]" };
+  }
+  return sanitized;
+};
+var canAgentsExchangeInfo = (from, to, message, policy) => {
+  const topic = normalizeText(message.topic);
+  if (!topic || topic.length > MAX_TOPIC_LEN) return { ok: false, reason: "invalid_topic" };
+  try {
+    createIntentContext(message.intentContext);
+  } catch {
+    return { ok: false, reason: "invalid_intent_context" };
+  }
+  if (!policy.allowScopes.includes(message.scope)) return { ok: false, reason: "scope_not_allowed" };
+  if (policy.requireCapabilityMatch && policy.requireCapabilityMatch.length > 0) {
+    const fromSet = new Set(from.capabilityTags.map((t) => t.toLowerCase()));
+    const toSet = new Set(to.capabilityTags.map((t) => t.toLowerCase()));
+    const required = policy.requireCapabilityMatch.map((t) => t.toLowerCase());
+    const matched = required.some((tag) => fromSet.has(tag) && toSet.has(tag));
+    if (!matched) return { ok: false, reason: "capability_mismatch" };
+  }
+  return { ok: true };
+};
+var createSignedSocialEnvelope = (message, policy, signingSecret) => {
+  const intentContext = createIntentContext(message.intentContext);
+  const sanitizedPayload = sanitizePayload(message.payload, policy.blockedKeys);
+  const payloadHash = hashStable(message.payload);
+  const intentContextHash = hashStable(intentContext);
+  const idempotencyKey = deriveIdempotencyKey(message, sanitizedPayload);
+  const policyVersion = policy.policyVersion || "v1";
+  const messageWithIdempotency = { ...message, intentContext, idempotencyKey };
+  const evidenceHash = computeEvidenceHash(
+    messageWithIdempotency,
+    sanitizedPayload,
+    payloadHash,
+    intentContextHash,
+    idempotencyKey,
+    policyVersion
+  );
+  const signature = hashString(`${signingSecret}|${evidenceHash}|${policyVersion}`);
+  return {
+    message: messageWithIdempotency,
+    sanitizedPayload,
+    payloadHash,
+    intentContextHash,
+    evidenceHash,
+    signature,
+    policyVersion
+  };
+};
+var verifySignedSocialEnvelope = (envelope, signingSecret) => {
+  if (!envelope?.message || !envelope?.sanitizedPayload) return false;
+  let intentContext;
+  try {
+    intentContext = createIntentContext(envelope.message.intentContext);
+  } catch {
+    return false;
+  }
+  const policyVersion = envelope.policyVersion || "v1";
+  const idempotencyKey = deriveIdempotencyKey(envelope.message, envelope.sanitizedPayload);
+  if (envelope.message.idempotencyKey !== idempotencyKey) return false;
+  const payloadHash = hashStable(envelope.message.payload);
+  const intentContextHash = hashStable(intentContext);
+  if (envelope.payloadHash !== payloadHash) return false;
+  if (envelope.intentContextHash !== intentContextHash) return false;
+  const expectedEvidenceHash = computeEvidenceHash(
+    { ...envelope.message, intentContext },
+    envelope.sanitizedPayload,
+    payloadHash,
+    intentContextHash,
+    idempotencyKey,
+    policyVersion
+  );
+  if (envelope.evidenceHash !== expectedEvidenceHash) return false;
+  const expected = hashString(`${signingSecret}|${expectedEvidenceHash}|${policyVersion}`);
+  return envelope.signature === expected;
+};
+var recommendRetryCount = (result) => {
+  if (result.delivered) return 0;
+  if (result.blocked && result.reason === "scope_not_allowed") return 0;
+  return 3;
+};
+var exchangeAgentInfo = (from, to, message, policy) => {
+  const intentContext = createIntentContext(message.intentContext);
+  const normalizedMessage = { ...message, topic: normalizeText(message.topic), intentContext };
+  const gate = canAgentsExchangeInfo(from, to, message, policy);
+  const sanitizedPayload = sanitizePayload(message.payload, policy.blockedKeys);
+  const payloadHash = hashStable(message.payload);
+  const intentContextHash = hashStable(intentContext);
+  const policyVersion = policy.policyVersion || "v1";
+  const messageWithIdempotency = {
+    ...normalizedMessage,
+    idempotencyKey: deriveIdempotencyKey(normalizedMessage, sanitizedPayload)
+  };
+  const idempotencyKey = messageWithIdempotency.idempotencyKey;
+  const evidenceHash = computeEvidenceHash(
+    messageWithIdempotency,
+    sanitizedPayload,
+    payloadHash,
+    intentContextHash,
+    idempotencyKey,
+    policyVersion
+  );
+  if (!gate.ok) {
+    const blockedResult = {
+      delivered: false,
+      blocked: true,
+      reason: gate.reason,
+      state: "blocked",
+      sanitizedPayload,
+      payloadHash,
+      intentContext,
+      intentContextHash,
+      evidenceHash,
+      idempotencyKey,
+      policyVersion,
+      retriesRecommended: 0
+    };
+    return blockedResult;
+  }
+  const deliveredResult = {
+    delivered: true,
+    blocked: false,
+    reason: void 0,
+    state: "delivered",
+    sanitizedPayload,
+    payloadHash,
+    intentContext,
+    intentContextHash,
+    evidenceHash,
+    idempotencyKey,
+    policyVersion,
+    retriesRecommended: 0
+  };
+  return deliveredResult;
+};
+var acknowledgeExchange = (result) => ({
+  ...result,
+  state: result.blocked ? "blocked" : "acknowledged"
+});
+
+export {
+  createIntentContext,
+  createAgentBuilderProfile,
+  createPrivacyPolicy,
+  sanitizePayload,
+  canAgentsExchangeInfo,
+  createSignedSocialEnvelope,
+  verifySignedSocialEnvelope,
+  recommendRetryCount,
+  exchangeAgentInfo,
+  acknowledgeExchange
+};

package/dist/chunk-V6GK44EC.js

@@ -0,0 +1,310 @@
+// src/socialProtocol.ts
+var clampScore = (score) => {
+  if (!Number.isFinite(score)) return 0;
+  return Math.max(0, Math.min(100, Math.round(score)));
+};
+var MANDATORY_BLOCKED_KEYS = [
+  "ownerSecret",
+  "pii",
+  "humanOwnerId",
+  "privateKey",
+  "secretKey",
+  "seed",
+  "mnemonic",
+  "apiKey",
+  "api_key",
+  "authorization",
+  "bearer",
+  "password",
+  "secret",
+  "token"
+];
+var MAX_TOPIC_LEN = 80;
+var MAX_INTENT_ID_LEN = 72;
+var MAX_INTENT_TEXT_LEN = 280;
+var MAX_INTENT_LIST_ITEMS = 12;
+var MAX_INTENT_LIST_ITEM_LEN = 200;
+var MAX_PAYLOAD_DEPTH = 6;
+var MAX_PAYLOAD_ARRAY = 64;
+var MAX_PAYLOAD_KEYS = 128;
+var MAX_TTL_SEC = 7 * 24 * 60 * 60;
+var DEFAULT_TTL_SEC = 3600;
+var ALLOWED_INTENT_TYPES = ["request", "inform", "proposal", "decision", "handoff", "sync"];
+var stableStringify = (value) => {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map((x) => stableStringify(x)).join(",")}]`;
+  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+};
+var normalizeText = (value) => String(value || "").replace(/\s+/g, " ").trim();
+var normalizeList = (value) => {
+  if (!Array.isArray(value)) return [];
+  const normalized = value.map((entry) => normalizeText(entry).slice(0, MAX_INTENT_LIST_ITEM_LEN)).filter(Boolean);
+  return [...new Set(normalized)].slice(0, MAX_INTENT_LIST_ITEMS);
+};
+var hashStable = (value) => {
+  const text = stableStringify(value);
+  let hash = 5381;
+  for (let i = 0; i < text.length; i += 1) hash = (hash << 5) + hash + text.charCodeAt(i);
+  return `h${(hash >>> 0).toString(16).padStart(8, "0")}`;
+};
+var hashString = (value) => {
+  let hash = 5381;
+  for (let i = 0; i < value.length; i += 1) hash = (hash << 5) + hash + value.charCodeAt(i);
+  return `h${(hash >>> 0).toString(16).padStart(8, "0")}`;
+};
+var isIntentType = (value) => ALLOWED_INTENT_TYPES.includes(value);
+var createIntentContext = (input) => {
+  const intentId = normalizeText(input.intentId).slice(0, MAX_INTENT_ID_LEN);
+  const intentType = normalizeText(input.intentType).toLowerCase();
+  const objective = normalizeText(input.objective).slice(0, MAX_INTENT_TEXT_LEN);
+  const expectedOutcome = normalizeText(input.expectedOutcome).slice(0, MAX_INTENT_TEXT_LEN);
+  const assumptions = normalizeList(input.assumptions);
+  const constraints = normalizeList(input.constraints);
+  const successCriteria = normalizeList(input.successCriteria);
+  const contextRefs = normalizeList(input.contextRefs);
+  const contextVersion = Number(input.contextVersion);
+  const ttlRaw = input.ttlSec === void 0 ? DEFAULT_TTL_SEC : Number(input.ttlSec);
+  const ttlSec = Number.isFinite(ttlRaw) ? Math.trunc(ttlRaw) : NaN;
+  const requiresAck = input.requiresAck === void 0 ? true : Boolean(input.requiresAck);
+  const parentEvidenceHash = normalizeText(input.parentEvidenceHash || "");
+  if (!intentId || intentId.length < 4) throw new Error("invalid_intent_context");
+  if (!isIntentType(intentType)) throw new Error("invalid_intent_context");
+  if (!objective || objective.length < 8) throw new Error("invalid_intent_context");
+  if (!expectedOutcome || expectedOutcome.length < 8) throw new Error("invalid_intent_context");
+  if (!Number.isFinite(contextVersion) || contextVersion < 1 || !Number.isInteger(contextVersion)) {
+    throw new Error("invalid_intent_context");
+  }
+  if (!Number.isFinite(ttlSec) || ttlSec < 0 || ttlSec > MAX_TTL_SEC) {
+    throw new Error("invalid_intent_context");
+  }
+  if (parentEvidenceHash && !/^h[0-9a-f]+$/i.test(parentEvidenceHash)) {
+    throw new Error("invalid_intent_context");
+  }
+  return {
+    intentId,
+    intentType,
+    objective,
+    expectedOutcome,
+    assumptions,
+    constraints,
+    successCriteria,
+    contextVersion,
+    ttlSec,
+    requiresAck,
+    parentEvidenceHash: parentEvidenceHash || null,
+    contextRefs
+  };
+};
+var deriveIdempotencyKey = (message, sanitizedPayload) => {
+  if (message.idempotencyKey && message.idempotencyKey.trim()) return message.idempotencyKey.trim();
+  const intentContext = createIntentContext(message.intentContext);
+  const payloadHash = hashStable(message.payload);
+  return hashString(stableStringify({
+    fromAgentId: message.fromAgentId,
+    toAgentId: message.toAgentId,
+    topic: message.topic,
+    scope: message.scope,
+    payload: sanitizedPayload,
+    payloadHash,
+    intentContextHash: hashStable(intentContext)
+  }));
+};
+var computeEvidenceHash = (message, sanitizedPayload, payloadHash, intentContextHash, idempotencyKey, policyVersion) => hashString(stableStringify({
+  fromAgentId: message.fromAgentId,
+  toAgentId: message.toAgentId,
+  scope: message.scope,
+  topic: message.topic,
+  intentContext: createIntentContext(message.intentContext),
+  intentContextHash,
+  sentAtIso: message.sentAtIso,
+  rawPayloadHash: payloadHash,
+  payload: sanitizedPayload,
+  idempotencyKey,
+  policyVersion
+}));
+var createAgentBuilderProfile = (input) => ({
+  ...input,
+  capabilityTags: [...new Set((input.capabilityTags || []).map((tag) => String(tag).trim()).filter(Boolean))],
+  reliabilityScore: clampScore(input.reliabilityScore)
+});
+var createPrivacyPolicy = (input) => ({
+  allowScopes: [...new Set(input.allowScopes || [])],
+  blockedKeys: [
+    .../* @__PURE__ */ new Set([
+      ...MANDATORY_BLOCKED_KEYS,
+      ...(input.blockedKeys || []).map((k) => k.trim()).filter(Boolean)
+    ])
+  ],
+  requireCapabilityMatch: input.requireCapabilityMatch?.map((k) => k.trim()).filter(Boolean) || [],
+  policyVersion: (input.policyVersion || "v1").trim() || "v1"
+});
+var sanitizePayloadNode = (value, blocked, depth) => {
+  if (depth > MAX_PAYLOAD_DEPTH) return "[TRUNCATED]";
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (Array.isArray(value)) {
+    return value.slice(0, MAX_PAYLOAD_ARRAY).map((entry) => sanitizePayloadNode(entry, blocked, depth + 1));
+  }
+  if (typeof value !== "object") return String(value);
+  const entries = Object.entries(value).slice(0, MAX_PAYLOAD_KEYS);
+  const next = entries.filter(([key]) => !blocked.has(key.toLowerCase())).map(([key, entry]) => [key, sanitizePayloadNode(entry, blocked, depth + 1)]);
+  return Object.fromEntries(next);
+};
+var sanitizePayload = (payload, blockedKeys) => {
+  const blocked = new Set(blockedKeys.map((k) => k.toLowerCase()));
+  const sanitized = sanitizePayloadNode(payload, blocked, 0);
+  if (!sanitized || typeof sanitized !== "object" || Array.isArray(sanitized)) {
+    return { value: "[REDACTED]" };
+  }
+  return sanitized;
+};
+var canAgentsExchangeInfo = (from, to, message, policy) => {
+  const topic = normalizeText(message.topic);
+  if (!topic || topic.length > MAX_TOPIC_LEN) return { ok: false, reason: "invalid_topic" };
+  try {
+    createIntentContext(message.intentContext);
+  } catch {
+    return { ok: false, reason: "invalid_intent_context" };
+  }
+  if (!policy.allowScopes.includes(message.scope)) return { ok: false, reason: "scope_not_allowed" };
+  if (policy.requireCapabilityMatch && policy.requireCapabilityMatch.length > 0) {
+    const fromSet = new Set(from.capabilityTags.map((t) => t.toLowerCase()));
+    const toSet = new Set(to.capabilityTags.map((t) => t.toLowerCase()));
+    const required = policy.requireCapabilityMatch.map((t) => t.toLowerCase());
+    const matched = required.some((tag) => fromSet.has(tag) && toSet.has(tag));
+    if (!matched) return { ok: false, reason: "capability_mismatch" };
+  }
+  return { ok: true };
+};
+var createSignedSocialEnvelope = (message, policy, signingSecret) => {
+  const intentContext = createIntentContext(message.intentContext);
+  const sanitizedPayload = sanitizePayload(message.payload, policy.blockedKeys);
+  const payloadHash = hashStable(message.payload);
+  const intentContextHash = hashStable(intentContext);
+  const idempotencyKey = deriveIdempotencyKey(message, sanitizedPayload);
+  const policyVersion = policy.policyVersion || "v1";
+  const messageWithIdempotency = { ...message, intentContext, idempotencyKey };
+  const evidenceHash = computeEvidenceHash(
+    messageWithIdempotency,
+    sanitizedPayload,
+    payloadHash,
+    intentContextHash,
+    idempotencyKey,
+    policyVersion
+  );
+  const signature = hashString(`${signingSecret}|${evidenceHash}|${policyVersion}`);
+  return {
+    message: messageWithIdempotency,
+    sanitizedPayload,
+    payloadHash,
+    intentContextHash,
+    evidenceHash,
+    signature,
+    policyVersion
+  };
+};
+var verifySignedSocialEnvelope = (envelope, signingSecret) => {
+  if (!envelope?.message || !envelope?.sanitizedPayload) return false;
+  let intentContext;
+  try {
+    intentContext = createIntentContext(envelope.message.intentContext);
+  } catch {
+    return false;
+  }
+  const policyVersion = envelope.policyVersion || "v1";
+  const idempotencyKey = deriveIdempotencyKey(envelope.message, envelope.sanitizedPayload);
+  if (envelope.message.idempotencyKey !== idempotencyKey) return false;
+  const payloadHash = hashStable(envelope.message.payload);
+  const intentContextHash = hashStable(intentContext);
+  if (envelope.payloadHash !== payloadHash) return false;
+  if (envelope.intentContextHash !== intentContextHash) return false;
+  const expectedEvidenceHash = computeEvidenceHash(
+    { ...envelope.message, intentContext },
+    envelope.sanitizedPayload,
+    payloadHash,
+    intentContextHash,
+    idempotencyKey,
+    policyVersion
+  );
+  if (envelope.evidenceHash !== expectedEvidenceHash) return false;
+  const expected = hashString(`${signingSecret}|${expectedEvidenceHash}|${policyVersion}`);
+  return envelope.signature === expected;
+};
+var recommendRetryCount = (result) => {
+  if (result.delivered) return 0;
+  if (result.blocked && result.reason === "scope_not_allowed") return 0;
+  return 3;
+};
+var exchangeAgentInfo = (from, to, message, policy) => {
+  const intentContext = createIntentContext(message.intentContext);
+  const normalizedMessage = { ...message, topic: normalizeText(message.topic), intentContext };
+  const gate = canAgentsExchangeInfo(from, to, message, policy);
+  const sanitizedPayload = sanitizePayload(message.payload, policy.blockedKeys);
+  const payloadHash = hashStable(message.payload);
+  const intentContextHash = hashStable(intentContext);
+  const policyVersion = policy.policyVersion || "v1";
+  const messageWithIdempotency = {
+    ...normalizedMessage,
+    idempotencyKey: deriveIdempotencyKey(normalizedMessage, sanitizedPayload)
+  };
+  const idempotencyKey = messageWithIdempotency.idempotencyKey;
+  const evidenceHash = computeEvidenceHash(
+    messageWithIdempotency,
+    sanitizedPayload,
+    payloadHash,
+    intentContextHash,
+    idempotencyKey,
+    policyVersion
+  );
+  if (!gate.ok) {
+    const blockedResult = {
+      delivered: false,
+      blocked: true,
+      reason: gate.reason,
+      state: "blocked",
+      sanitizedPayload,
+      payloadHash,
+      intentContext,
+      intentContextHash,
+      evidenceHash,
+      idempotencyKey,
+      policyVersion,
+      retriesRecommended: 0
+    };
+    return blockedResult;
+  }
+  const deliveredResult = {
+    delivered: true,
+    blocked: false,
+    reason: void 0,
+    state: "delivered",
+    sanitizedPayload,
+    payloadHash,
+    intentContext,
+    intentContextHash,
+    evidenceHash,
+    idempotencyKey,
+    policyVersion,
+    retriesRecommended: 0
+  };
+  return deliveredResult;
+};
+var acknowledgeExchange = (result) => ({
+  ...result,
+  state: result.blocked ? "blocked" : "acknowledged"
+});
+
+export {
+  createIntentContext,
+  createAgentBuilderProfile,
+  createPrivacyPolicy,
+  sanitizePayload,
+  canAgentsExchangeInfo,
+  createSignedSocialEnvelope,
+  verifySignedSocialEnvelope,
+  recommendRetryCount,
+  exchangeAgentInfo,
+  acknowledgeExchange
+};

package/dist/chunk-YGJ3JJQ2.js

@@ -0,0 +1,310 @@
+// src/socialProtocol.ts
+var clampScore = (score) => {
+  if (!Number.isFinite(score)) return 0;
+  return Math.max(0, Math.min(100, Math.round(score)));
+};
+var MANDATORY_BLOCKED_KEYS = [
+  "ownerSecret",
+  "pii",
+  "humanOwnerId",
+  "privateKey",
+  "secretKey",
+  "seed",
+  "mnemonic",
+  "apiKey",
+  "api_key",
+  "authorization",
+  "bearer",
+  "password",
+  "secret",
+  "token"
+];
+var MAX_TOPIC_LEN = 80;
+var MAX_INTENT_ID_LEN = 72;
+var MAX_INTENT_TEXT_LEN = 280;
+var MAX_INTENT_LIST_ITEMS = 12;
+var MAX_INTENT_LIST_ITEM_LEN = 200;
+var MAX_PAYLOAD_DEPTH = 6;
+var MAX_PAYLOAD_ARRAY = 64;
+var MAX_PAYLOAD_KEYS = 128;
+var MAX_TTL_SEC = 7 * 24 * 60 * 60;
+var DEFAULT_TTL_SEC = 3600;
+var ALLOWED_INTENT_TYPES = ["request", "inform", "proposal", "decision", "handoff", "sync"];
+var stableStringify = (value) => {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map((x) => stableStringify(x)).join(",")}]`;
+  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+};
+var normalizeText = (value) => String(value || "").replace(/\s+/g, " ").trim();
+var normalizeList = (value) => {
+  if (!Array.isArray(value)) return [];
+  const normalized = value.map((entry) => normalizeText(entry).slice(0, MAX_INTENT_LIST_ITEM_LEN)).filter(Boolean);
+  return [...new Set(normalized)].slice(0, MAX_INTENT_LIST_ITEMS);
+};
+var hashStable = (value) => {
+  const text = stableStringify(value);
+  let hash = 5381;
+  for (let i = 0; i < text.length; i += 1) hash = (hash << 5) + hash + text.charCodeAt(i);
+  return `h${(hash >>> 0).toString(16).padStart(8, "0")}`;
+};
+var hashString = (value) => {
+  let hash = 5381;
+  for (let i = 0; i < value.length; i += 1) hash = (hash << 5) + hash + value.charCodeAt(i);
+  return `h${(hash >>> 0).toString(16).padStart(8, "0")}`;
+};
+var isIntentType = (value) => ALLOWED_INTENT_TYPES.includes(value);
+var createIntentContext = (input) => {
+  const intentId = normalizeText(input.intentId).slice(0, MAX_INTENT_ID_LEN);
+  const intentType = normalizeText(input.intentType).toLowerCase();
+  const objective = normalizeText(input.objective).slice(0, MAX_INTENT_TEXT_LEN);
+  const expectedOutcome = normalizeText(input.expectedOutcome).slice(0, MAX_INTENT_TEXT_LEN);
+  const assumptions = normalizeList(input.assumptions);
+  const constraints = normalizeList(input.constraints);
+  const successCriteria = normalizeList(input.successCriteria);
+  const contextRefs = normalizeList(input.contextRefs);
+  const contextVersion = Number(input.contextVersion);
+  const ttlRaw = input.ttlSec === void 0 ? DEFAULT_TTL_SEC : Number(input.ttlSec);
+  const ttlSec = Number.isFinite(ttlRaw) ? Math.trunc(ttlRaw) : NaN;
+  const requiresAck = input.requiresAck === void 0 ? true : Boolean(input.requiresAck);
+  const parentEvidenceHash = normalizeText(input.parentEvidenceHash || "");
+  if (!intentId || intentId.length < 4) throw new Error("invalid_intent_context");
+  if (!isIntentType(intentType)) throw new Error("invalid_intent_context");
+  if (!objective || objective.length < 8) throw new Error("invalid_intent_context");
+  if (!expectedOutcome || expectedOutcome.length < 8) throw new Error("invalid_intent_context");
+  if (!Number.isFinite(contextVersion) || contextVersion < 1 || !Number.isInteger(contextVersion)) {
+    throw new Error("invalid_intent_context");
+  }
+  if (!Number.isFinite(ttlSec) || ttlSec < 0 || ttlSec > MAX_TTL_SEC) {
+    throw new Error("invalid_intent_context");
+  }
+  if (parentEvidenceHash && !/^h[0-9a-f]{16}$/i.test(parentEvidenceHash)) {
+    throw new Error("invalid_intent_context");
+  }
+  return {
+    intentId,
+    intentType,
+    objective,
+    expectedOutcome,
+    assumptions,
+    constraints,
+    successCriteria,
+    contextVersion,
+    ttlSec,
+    requiresAck,
+    parentEvidenceHash: parentEvidenceHash || null,
+    contextRefs
+  };
+};
+var deriveIdempotencyKey = (message, sanitizedPayload) => {
+  if (message.idempotencyKey && message.idempotencyKey.trim()) return message.idempotencyKey.trim();
+  const intentContext = createIntentContext(message.intentContext);
+  const payloadHash = hashStable(message.payload);
+  return hashString(stableStringify({
+    fromAgentId: message.fromAgentId,
+    toAgentId: message.toAgentId,
+    topic: message.topic,
+    scope: message.scope,
+    payload: sanitizedPayload,
+    payloadHash,
+    intentContextHash: hashStable(intentContext)
+  }));
+};
+var computeEvidenceHash = (message, sanitizedPayload, payloadHash, intentContextHash, idempotencyKey, policyVersion) => hashString(stableStringify({
+  fromAgentId: message.fromAgentId,
+  toAgentId: message.toAgentId,
+  scope: message.scope,
+  topic: message.topic,
+  intentContext: createIntentContext(message.intentContext),
+  intentContextHash,
+  sentAtIso: message.sentAtIso,
+  rawPayloadHash: payloadHash,
+  payload: sanitizedPayload,
+  idempotencyKey,
+  policyVersion
+}));
+var createAgentBuilderProfile = (input) => ({
+  ...input,
+  capabilityTags: [...new Set((input.capabilityTags || []).map((tag) => String(tag).trim()).filter(Boolean))],
+  reliabilityScore: clampScore(input.reliabilityScore)
+});
+var createPrivacyPolicy = (input) => ({
+  allowScopes: [...new Set(input.allowScopes || [])],
+  blockedKeys: [
+    .../* @__PURE__ */ new Set([
+      ...MANDATORY_BLOCKED_KEYS,
+      ...(input.blockedKeys || []).map((k) => k.trim()).filter(Boolean)
+    ])
+  ],
+  requireCapabilityMatch: input.requireCapabilityMatch?.map((k) => k.trim()).filter(Boolean) || [],
+  policyVersion: (input.policyVersion || "v1").trim() || "v1"
+});
+var sanitizePayloadNode = (value, blocked, depth) => {
+  if (depth > MAX_PAYLOAD_DEPTH) return "[TRUNCATED]";
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (Array.isArray(value)) {
+    return value.slice(0, MAX_PAYLOAD_ARRAY).map((entry) => sanitizePayloadNode(entry, blocked, depth + 1));
+  }
+  if (typeof value !== "object") return String(value);
+  const entries = Object.entries(value).slice(0, MAX_PAYLOAD_KEYS);
+  const next = entries.filter(([key]) => !blocked.has(key.toLowerCase())).map(([key, entry]) => [key, sanitizePayloadNode(entry, blocked, depth + 1)]);
+  return Object.fromEntries(next);
+};
+var sanitizePayload = (payload, blockedKeys) => {
+  const blocked = new Set(blockedKeys.map((k) => k.toLowerCase()));
+  const sanitized = sanitizePayloadNode(payload, blocked, 0);
+  if (!sanitized || typeof sanitized !== "object" || Array.isArray(sanitized)) {
+    return { value: "[REDACTED]" };
+  }
+  return sanitized;
+};
+var canAgentsExchangeInfo = (from, to, message, policy) => {
+  const topic = normalizeText(message.topic);
+  if (!topic || topic.length > MAX_TOPIC_LEN) return { ok: false, reason: "invalid_topic" };
+  try {
+    createIntentContext(message.intentContext);
+  } catch {
+    return { ok: false, reason: "invalid_intent_context" };
+  }
+  if (!policy.allowScopes.includes(message.scope)) return { ok: false, reason: "scope_not_allowed" };
+  if (policy.requireCapabilityMatch && policy.requireCapabilityMatch.length > 0) {
+    const fromSet = new Set(from.capabilityTags.map((t) => t.toLowerCase()));
+    const toSet = new Set(to.capabilityTags.map((t) => t.toLowerCase()));
+    const required = policy.requireCapabilityMatch.map((t) => t.toLowerCase());
+    const matched = required.some((tag) => fromSet.has(tag) && toSet.has(tag));
+    if (!matched) return { ok: false, reason: "capability_mismatch" };
+  }
+  return { ok: true };
+};
+var createSignedSocialEnvelope = (message, policy, signingSecret) => {
+  const intentContext = createIntentContext(message.intentContext);
+  const sanitizedPayload = sanitizePayload(message.payload, policy.blockedKeys);
+  const payloadHash = hashStable(message.payload);
+  const intentContextHash = hashStable(intentContext);
+  const idempotencyKey = deriveIdempotencyKey(message, sanitizedPayload);
+  const policyVersion = policy.policyVersion || "v1";
+  const messageWithIdempotency = { ...message, intentContext, idempotencyKey };
+  const evidenceHash = computeEvidenceHash(
+    messageWithIdempotency,
+    sanitizedPayload,
+    payloadHash,
+    intentContextHash,
+    idempotencyKey,
+    policyVersion
+  );
+  const signature = hashString(`${signingSecret}|${evidenceHash}|${policyVersion}`);
+  return {
+    message: messageWithIdempotency,
+    sanitizedPayload,
+    payloadHash,
+    intentContextHash,
+    evidenceHash,
+    signature,
+    policyVersion
+  };
+};
+var verifySignedSocialEnvelope = (envelope, signingSecret) => {
+  if (!envelope?.message || !envelope?.sanitizedPayload) return false;
+  let intentContext;
+  try {
+    intentContext = createIntentContext(envelope.message.intentContext);
+  } catch {
+    return false;
+  }
+  const policyVersion = envelope.policyVersion || "v1";
+  const idempotencyKey = deriveIdempotencyKey(envelope.message, envelope.sanitizedPayload);
+  if (envelope.message.idempotencyKey !== idempotencyKey) return false;
+  const payloadHash = hashStable(envelope.message.payload);
+  const intentContextHash = hashStable(intentContext);
+  if (envelope.payloadHash !== payloadHash) return false;
+  if (envelope.intentContextHash !== intentContextHash) return false;
+  const expectedEvidenceHash = computeEvidenceHash(
+    { ...envelope.message, intentContext },
+    envelope.sanitizedPayload,
+    payloadHash,
+    intentContextHash,
+    idempotencyKey,
+    policyVersion
+  );
+  if (envelope.evidenceHash !== expectedEvidenceHash) return false;
+  const expected = hashString(`${signingSecret}|${expectedEvidenceHash}|${policyVersion}`);
+  return envelope.signature === expected;
+};
+var recommendRetryCount = (result) => {
+  if (result.delivered) return 0;
+  if (result.blocked && result.reason === "scope_not_allowed") return 0;
+  return 3;
+};
+var exchangeAgentInfo = (from, to, message, policy) => {
+  const intentContext = createIntentContext(message.intentContext);
+  const normalizedMessage = { ...message, topic: normalizeText(message.topic), intentContext };
+  const gate = canAgentsExchangeInfo(from, to, message, policy);
+  const sanitizedPayload = sanitizePayload(message.payload, policy.blockedKeys);
+  const payloadHash = hashStable(message.payload);
+  const intentContextHash = hashStable(intentContext);
+  const policyVersion = policy.policyVersion || "v1";
+  const messageWithIdempotency = {
+    ...normalizedMessage,
+    idempotencyKey: deriveIdempotencyKey(normalizedMessage, sanitizedPayload)
+  };
+  const idempotencyKey = messageWithIdempotency.idempotencyKey;
+  const evidenceHash = computeEvidenceHash(
+    messageWithIdempotency,
+    sanitizedPayload,
+    payloadHash,
+    intentContextHash,
+    idempotencyKey,
+    policyVersion
+  );
+  if (!gate.ok) {
+    const blockedResult = {
+      delivered: false,
+      blocked: true,
+      reason: gate.reason,
+      state: "blocked",
+      sanitizedPayload,
+      payloadHash,
+      intentContext,
+      intentContextHash,
+      evidenceHash,
+      idempotencyKey,
+      policyVersion,
+      retriesRecommended: 0
+    };
+    return blockedResult;
+  }
+  const deliveredResult = {
+    delivered: true,
+    blocked: false,
+    reason: void 0,
+    state: "delivered",
+    sanitizedPayload,
+    payloadHash,
+    intentContext,
+    intentContextHash,
+    evidenceHash,
+    idempotencyKey,
+    policyVersion,
+    retriesRecommended: 0
+  };
+  return deliveredResult;
+};
+var acknowledgeExchange = (result) => ({
+  ...result,
+  state: result.blocked ? "blocked" : "acknowledged"
+});
+
+export {
+  createIntentContext,
+  createAgentBuilderProfile,
+  createPrivacyPolicy,
+  sanitizePayload,
+  canAgentsExchangeInfo,
+  createSignedSocialEnvelope,
+  verifySignedSocialEnvelope,
+  recommendRetryCount,
+  exchangeAgentInfo,
+  acknowledgeExchange
+};

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { OUTCOME_BOUND_FLOW_SCHEMA, OUTCOME_BOUND_REQUIRED_GATES, OutcomeBoundRe
 export { STRICT_MEMORY_RUNTIME_SCHEMA, StrictMemoryEvaluation, StrictMemoryEvaluationInput, StrictMemoryRuntimePreset, StrictMemoryTriggerSet, StrictMemoryUpgradeInput, StrictMemoryUpgradePolicy, StrictMemoryUpgradeResult, createStrictMemoryRuntimePreset, evaluateStrictMemoryExecution, isComplexTask, upgradeToStrictMemoryRuntimePreset } from './strictMemoryRuntime.js';
 export { I as IntentSignals, L as LaneMode, a as LaneSwitchDecision, O as ObjectiveChangeProposal, b as ObjectiveChangeSourceTrust, c as ObjectiveGuardDecision, d as ObjectiveGuardPolicy, P as PromptShieldDecision, e as PromptShieldFlag, f as PromptShieldInput, g as PromptShieldPolicy, h as PromptShieldRisk, i as PromptShieldTrustLevel, j as applyIntentArbitration, k as evaluateLaneSwitch, l as evaluateObjectiveChange, m as evaluatePromptShield, s as scoreBuildLane, n as scorePolishLane } from './agentLoop-BY_j-iIC.js';
 export { AgentSocialProfile, formatOnboardedSurvivalTime, toAgentSocialProfile } from './socialProfile.js';
-export { AgentBuilderProfile, DeliveryState, PrivacyPolicy, PrivacyScope, SignedSocialEnvelope, SocialExchangeMessage, SocialExchangeResult, acknowledgeExchange, canAgentsExchangeInfo, createAgentBuilderProfile, createPrivacyPolicy, createSignedSocialEnvelope, exchangeAgentInfo, recommendRetryCount, sanitizePayload, verifySignedSocialEnvelope } from './socialProtocol.js';
+export { AgentBuilderProfile, DeliveryState, PrivacyPolicy, PrivacyScope, SignedSocialEnvelope, SocialExchangeMessage, SocialExchangeResult, SocialIntentContext, SocialIntentType, acknowledgeExchange, canAgentsExchangeInfo, createAgentBuilderProfile, createIntentContext, createPrivacyPolicy, createSignedSocialEnvelope, exchangeAgentInfo, recommendRetryCount, sanitizePayload, verifySignedSocialEnvelope } from './socialProtocol.js';
 export { fetchSolBalance, fetchTokenBalance, fetchTokenBalances } from './solana.js';
 import './compoundingMemory.js';
 import '@coral-xyz/anchor';

package/dist/index.js

@@ -13,13 +13,14 @@ import {
   acknowledgeExchange,
   canAgentsExchangeInfo,
   createAgentBuilderProfile,
+  createIntentContext,
   createPrivacyPolicy,
   createSignedSocialEnvelope,
   exchangeAgentInfo,
   recommendRetryCount,
   sanitizePayload,
   verifySignedSocialEnvelope
-} from "./chunk-OA3LATWQ.js";
+} from "./chunk-L3JJ77BF.js";
 import {
   VIBEIAO_IDL,
   fetchSolBalance,
@@ -1394,7 +1395,7 @@ var ReviewGate = class {
 var DEFAULT_API_BASE = "https://api.vibeiao.com";
 var DEFAULT_WEB_BASE = "https://vibeiao.com";
 var DEFAULT_SDK_PACKAGE = "@vibeiao/sdk";
-var DEFAULT_SDK_VERSION = "0.1.61" ? "0.1.61" : "0.1.4";
+var DEFAULT_SDK_VERSION = "0.1.63" ? "0.1.63" : "0.1.4";
 var DEFAULT_SDK_REGISTRY = "https://registry.npmjs.org";
 var DEFAULT_SDK_POLICY_PATH = "/v1/sdk/policy";
 var DEFAULT_SDK_CHECK_INTERVAL_MS = 1e3 * 60 * 30;
@@ -2570,6 +2571,7 @@ export {
   createDailyLocalMidnightSchedule,
   createDurabilityProxyClient,
   createInMemoryReflectionStore,
+  createIntentContext,
   createPrivacyPolicy,
   createSelfRelianceMonitor,
   createSelfReliancePolicy,

package/dist/socialProtocol.d.ts

@@ -6,6 +6,21 @@ type AgentBuilderProfile = {
     onboardedAt?: string;
 };
 type PrivacyScope = 'public' | 'partner' | 'owner';
+type SocialIntentType = 'request' | 'inform' | 'proposal' | 'decision' | 'handoff' | 'sync';
+type SocialIntentContext = {
+    intentId: string;
+    intentType: SocialIntentType;
+    objective: string;
+    expectedOutcome: string;
+    assumptions?: string[];
+    constraints?: string[];
+    successCriteria?: string[];
+    contextVersion: number;
+    ttlSec?: number;
+    requiresAck?: boolean;
+    parentEvidenceHash?: string | null;
+    contextRefs?: string[];
+};
 type PrivacyPolicy = {
     allowScopes: PrivacyScope[];
     blockedKeys: string[];
@@ -18,6 +33,7 @@ type SocialExchangeMessage = {
     toAgentId: string;
     scope: PrivacyScope;
     topic: string;
+    intentContext: SocialIntentContext;
     payload: Record<string, unknown>;
     sentAtIso: string;
     idempotencyKey?: string;
@@ -25,6 +41,8 @@ type SocialExchangeMessage = {
 type SignedSocialEnvelope = {
     message: SocialExchangeMessage;
     sanitizedPayload: Record<string, unknown>;
+    payloadHash: string;
+    intentContextHash: string;
     evidenceHash: string;
     signature: string;
     policyVersion: string;
@@ -35,11 +53,15 @@ type SocialExchangeResult = {
     reason?: string;
     state: DeliveryState;
     sanitizedPayload: Record<string, unknown>;
+    payloadHash: string;
+    intentContext: SocialIntentContext;
+    intentContextHash: string;
     evidenceHash: string;
     idempotencyKey: string;
     policyVersion: string;
     retriesRecommended: number;
 };
+declare const createIntentContext: (input: SocialIntentContext) => SocialIntentContext;
 declare const createAgentBuilderProfile: (input: AgentBuilderProfile) => AgentBuilderProfile;
 declare const createPrivacyPolicy: (input: PrivacyPolicy) => PrivacyPolicy;
 declare const sanitizePayload: (payload: Record<string, unknown>, blockedKeys: string[]) => Record<string, unknown>;
@@ -57,4 +79,4 @@ declare const recommendRetryCount: (result: {
 declare const exchangeAgentInfo: (from: AgentBuilderProfile, to: AgentBuilderProfile, message: SocialExchangeMessage, policy: PrivacyPolicy) => SocialExchangeResult;
 declare const acknowledgeExchange: (result: SocialExchangeResult) => SocialExchangeResult;
 
-export { type AgentBuilderProfile, type DeliveryState, type PrivacyPolicy, type PrivacyScope, type SignedSocialEnvelope, type SocialExchangeMessage, type SocialExchangeResult, acknowledgeExchange, canAgentsExchangeInfo, createAgentBuilderProfile, createPrivacyPolicy, createSignedSocialEnvelope, exchangeAgentInfo, recommendRetryCount, sanitizePayload, verifySignedSocialEnvelope };
+export { type AgentBuilderProfile, type DeliveryState, type PrivacyPolicy, type PrivacyScope, type SignedSocialEnvelope, type SocialExchangeMessage, type SocialExchangeResult, type SocialIntentContext, type SocialIntentType, acknowledgeExchange, canAgentsExchangeInfo, createAgentBuilderProfile, createIntentContext, createPrivacyPolicy, createSignedSocialEnvelope, exchangeAgentInfo, recommendRetryCount, sanitizePayload, verifySignedSocialEnvelope };

package/dist/socialProtocol.js

@@ -2,17 +2,19 @@ import {
   acknowledgeExchange,
   canAgentsExchangeInfo,
   createAgentBuilderProfile,
+  createIntentContext,
   createPrivacyPolicy,
   createSignedSocialEnvelope,
   exchangeAgentInfo,
   recommendRetryCount,
   sanitizePayload,
   verifySignedSocialEnvelope
-} from "./chunk-OA3LATWQ.js";
+} from "./chunk-L3JJ77BF.js";
 export {
   acknowledgeExchange,
   canAgentsExchangeInfo,
   createAgentBuilderProfile,
+  createIntentContext,
   createPrivacyPolicy,
   createSignedSocialEnvelope,
   exchangeAgentInfo,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@vibeiao/sdk",
   "private": false,
   "type": "module",
-  "version": "0.1.62",
+  "version": "0.1.64",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {