linkque-cli-v2 1.1.4 → 1.2.0

package/linkquejs.js

@@ -19550,6 +19550,30 @@ var SEARCH_DATABASE_ID = "linkque";
 var SEARCH_TABLE_ID = "linkque_conversation_message_search";
 var CLIENT_CAPABILITY_DATABASE_ID = "linkque";
 var CLIENT_CAPABILITY_TABLE_ID = "linkque_client_cap_invocations";
+var A2UI_ACTION_DATABASE_ID = "linkque";
+var A2UI_ACTION_TABLE_ID = "linkque_a2ui_action_invocations";
+var A2UI_ACTION_TABLE_COLUMNS = [
+  ...["ownerId", "agentId", "threadId", "actionId", "cardRef", "cardRevision", "surfaceId", "componentId"].map((key) => ({
+    key,
+    type: "varchar",
+    required: true,
+    array: false,
+    size: 128,
+    default: null
+  })),
+  { key: "cardInstanceId", type: "varchar", required: true, array: false, size: 256, default: null },
+  { key: "status", type: "varchar", required: true, array: false, size: 32, default: null },
+  { key: "actionContext", type: "text", required: true, array: false, size: 0, default: null },
+  { key: "tradeNO", type: "varchar", required: false, array: false, size: 64, default: null },
+  { key: "callback", type: "text", required: false, array: false, size: 0, default: null },
+  { key: "verification", type: "text", required: false, array: false, size: 0, default: null },
+  { key: "createdAt", type: "varchar", required: true, array: false, size: 32, default: null },
+  { key: "expiresAt", type: "varchar", required: true, array: false, size: 32, default: null }
+];
+var A2UI_ACTION_TABLE_INDEXES = [
+  { key: "thread_status", type: "key", columns: ["threadId", "status"], orders: ["asc", "asc"] },
+  { key: "expires_at", type: "key", columns: ["expiresAt"], orders: ["asc"] }
+];
 var CLIENT_CAPABILITY_TABLE_COLUMNS = [
   ...["ownerId", "agentId", "threadId", "runId", "toolCallId"].map((key) => ({
     key,
@@ -20148,6 +20172,8 @@ var FUNCTION_DEFS = [
         value: CLIENT_CAPABILITY_DATABASE_ID
       },
       { key: "CLIENT_CAPABILITY_TABLE_ID", value: CLIENT_CAPABILITY_TABLE_ID },
+      { key: "A2UI_ACTION_DATABASE_ID", value: A2UI_ACTION_DATABASE_ID },
+      { key: "A2UI_ACTION_TABLE_ID", value: A2UI_ACTION_TABLE_ID },
       { key: "RUN_CHUNK_SIZE", value: "10" },
       { key: "RUN_CANCEL_POLL_INTERVAL_MS", value: "500" },
       // linkquegw 出站地址:线上套(无 x-linkque-env 头时生效)。
@@ -20198,6 +20224,8 @@ var FUNCTION_DEFS = [
         value: CLIENT_CAPABILITY_DATABASE_ID
       },
       { key: "CLIENT_CAPABILITY_TABLE_ID", value: CLIENT_CAPABILITY_TABLE_ID },
+      { key: "A2UI_ACTION_DATABASE_ID", value: A2UI_ACTION_DATABASE_ID },
+      { key: "A2UI_ACTION_TABLE_ID", value: A2UI_ACTION_TABLE_ID },
       {
         key: "LINKQUEGW_MCP_SIGN_ENDPOINT",
         value: LINKQUEGW_MCP_SIGN_ENDPOINT
@@ -20273,6 +20301,16 @@ var TABLES = [
     permissions: [],
     columns: CLIENT_CAPABILITY_TABLE_COLUMNS,
     indexes: CLIENT_CAPABILITY_TABLE_INDEXES
+  },
+  {
+    $id: A2UI_ACTION_TABLE_ID,
+    databaseId: A2UI_ACTION_DATABASE_ID,
+    name: A2UI_ACTION_TABLE_ID,
+    enabled: true,
+    rowSecurity: true,
+    permissions: [],
+    columns: A2UI_ACTION_TABLE_COLUMNS,
+    indexes: A2UI_ACTION_TABLE_INDEXES
   }
 ];
 var buildAppwriteConfigTemplate = (envOverrides = {}) => ({
@@ -21040,6 +21078,7 @@ var AGENT_LOG = ".linkque/logs/agent.log";
 var HEALTH_PATH = "/healthz";
 var RUNS_PATH = "/runs";
 var HOME_DATA_PATH = "/home-data";
+var A2UI_ACTION_PATH = "/a2ui-action";
 var AGENT_RUNTIME_PROTOCOL = "conversation-runs-v2";
 var API_KEY_ENV = "LINKQUE_AGENT_API_KEY";
 var stopped = (health) => ({
@@ -21307,6 +21346,7 @@ var spawnAgentOwner = (cwd, config2, port, apiKey, statePath) => {
       cwd,
       healthPath: HEALTH_PATH,
       homeDataPath: HOME_DATA_PATH,
+      a2uiActionPath: A2UI_ACTION_PATH,
       logPath: import_path15.default.join(cwd, AGENT_LOG),
       port,
       runsPath: RUNS_PATH,
@@ -25304,6 +25344,7 @@ function analyzeA2UIBindings(protocol) {
     const listRoots = inferListRoots(components, issues);
     for (const component of components) {
       const context = {
+        surfaceId,
         component,
         listRoot: listRoots.get(component.id),
         occurrences,
@@ -25317,6 +25358,7 @@ function analyzeA2UIBindings(protocol) {
           issues.push(issue2(`card.surfaces.${surfaceId}.components.${component.id}.children.path`, "INVALID_BINDING_PATH", `Invalid list path ${children.path}`));
         } else {
           occurrences.push({
+            surfaceId,
             componentId: component.id,
             componentName: component.component,
             propertyPath: "children.path",
@@ -25335,6 +25377,16 @@ function analyzeA2UIBindings(protocol) {
     issues
   };
 }
+function collectReferencedA2UICardBusinessFieldIds(protocol, fields) {
+  const businessFields = fields.filter((field) => field.source === "business").slice().sort((left, right) => right.path.length - left.path.length);
+  const result = /* @__PURE__ */ new Set();
+  for (const occurrence of analyzeA2UIBindings(protocol).occurrences) {
+    const field = businessFields.find((candidate) => occurrence.canonicalPath === candidate.path || occurrence.canonicalPath.startsWith(`${candidate.path}/*/`) || occurrence.canonicalPath.startsWith(`${candidate.path}/`));
+    if (field)
+      result.add(field.fieldId);
+  }
+  return result;
+}
 function visitValue(value, propertyPath, context) {
   if (propertyPath === "action.local.path" && typeof value === "string") {
     addOccurrence(value, propertyPath, "local", context);
@@ -25366,6 +25418,7 @@ function addOccurrence(rawPath, propertyPath, usage, context) {
     return;
   }
   context.occurrences.push({
+    surfaceId: context.surfaceId,
     componentId: context.component.id,
     componentName: context.component.component,
     propertyPath,
@@ -26051,12 +26104,15 @@ function validateA2UICardBindings(input, options = {}) {
     readyCandidates.set(candidateKey(candidate.resourceId, candidate.tool.toolName), candidate.tool);
   }
   const bindingByField = new Map(bindings.map((binding) => [binding.fieldId, binding]));
+  const requiredFields = collectReferencedA2UICardBusinessFieldIds(input.draft.card, input.draft.manifest.fields.filter((field) => field.required));
   for (const field of input.draft.manifest.fields) {
     if (field.source !== "business")
       continue;
     if (selectedFields && !selectedFields.has(field.fieldId))
       continue;
     const binding = bindingByField.get(field.fieldId);
+    if (!selectedFields && !requiredFields.has(field.fieldId) && !binding)
+      continue;
     if (!binding) {
       issues.push(issue2(`fields.${field.fieldId}`, "CARD_BINDING_INCOMPLETE", `business field ${field.fieldId} has not been bound`));
       continue;
@@ -26300,6 +26356,192 @@ function candidateKey(resourceId, toolName) {
   return `${resourceId}\0${toolName}`;
 }
 
+// ../agent-a2ui-card-contract/dist/esm/payment-action.js
+var A2UI_PAYMENT_ACTION_NAME = "payment.trade-pay";
+var A2UI_PAYMENT_CALLBACK_MAX_BYTES = 16 * 1024;
+function getA2UICardActionBindingIssues(value, path22 = "actionBindings") {
+  if (!Array.isArray(value)) {
+    return [issue2(path22, "INVALID_ACTION_BINDINGS", "actionBindings must be an array")];
+  }
+  const issues = [];
+  const actionIds = /* @__PURE__ */ new Set();
+  value.forEach((candidate, index) => {
+    const itemPath = `${path22}[${index}]`;
+    if (!isPlainRecord(candidate)) {
+      issues.push(issue2(itemPath, "INVALID_ACTION_BINDING", "action binding must be an object"));
+      return;
+    }
+    if (!isSafeIdentifier(candidate.actionId)) {
+      issues.push(issue2(`${itemPath}.actionId`, "INVALID_ACTION_ID", "actionId is invalid"));
+    } else if (actionIds.has(candidate.actionId)) {
+      issues.push(issue2(`${itemPath}.actionId`, "DUPLICATE_ACTION_ID", "actionId must be unique"));
+    } else {
+      actionIds.add(candidate.actionId);
+    }
+    if (candidate.kind !== "payment") {
+      issues.push(issue2(`${itemPath}.kind`, "INVALID_ACTION_KIND", "kind must be payment"));
+      return;
+    }
+    rejectExtraKeys(candidate, ["actionId", "kind", "createTrade", "queryTrade"], itemPath, issues);
+    validateToolBinding(candidate.createTrade, `${itemPath}.createTrade`, "create", issues);
+    validateToolBinding(candidate.queryTrade, `${itemPath}.queryTrade`, "query", issues);
+  });
+  return issues;
+}
+function getA2UIPaymentActionReferenceIssues(card, bindings, path22 = "a2uiTemplate.content") {
+  const issues = [];
+  const bindingIds = new Set(bindings.map((binding) => binding.actionId));
+  const referenced = /* @__PURE__ */ new Set();
+  card.forEach((instruction, instructionIndex) => {
+    const instructionRecord = instruction;
+    const update = isPlainRecord(instructionRecord.updateComponents) ? instructionRecord.updateComponents : void 0;
+    const components = update && Array.isArray(update.components) ? update.components : [];
+    components.forEach((component, componentIndex) => {
+      if (!isPlainRecord(component))
+        return;
+      collectPaymentActionReferences(component.action, `${path22}[${instructionIndex}].updateComponents.components[${componentIndex}].action`, referenced, issues);
+    });
+  });
+  for (const actionId of referenced) {
+    if (!bindingIds.has(actionId)) {
+      issues.push(issue2(path22, "PAYMENT_ACTION_BINDING_MISSING", `payment action ${actionId} has no action binding`));
+    }
+  }
+  for (const actionId of bindingIds) {
+    if (!referenced.has(actionId)) {
+      issues.push(issue2(path22, "PAYMENT_ACTION_UNUSED", `payment action binding ${actionId} is not referenced`));
+    }
+  }
+  return issues;
+}
+function validateToolBinding(value, path22, phase, issues) {
+  if (!isPlainRecord(value)) {
+    issues.push(issue2(path22, "INVALID_PAYMENT_TOOL", `${path22} must be an object`));
+    return;
+  }
+  rejectExtraKeys(value, phase === "create" ? ["mcpResourceId", "toolName", "inputBindings", "tradeNoPath"] : ["mcpResourceId", "toolName", "inputBindings", "statusPath", "paidValues"], path22, issues);
+  if (!isSafeIdentifier(value.mcpResourceId)) {
+    issues.push(issue2(`${path22}.mcpResourceId`, "INVALID_MCP_RESOURCE_ID", "mcpResourceId is invalid"));
+  }
+  if (typeof value.toolName !== "string" || !value.toolName.trim()) {
+    issues.push(issue2(`${path22}.toolName`, "INVALID_TOOL_NAME", "toolName is required"));
+  }
+  validateInputBindings2(value.inputBindings, `${path22}.inputBindings`, phase, issues);
+  if (phase === "create") {
+    if (!isSafeJsonPointer(value.tradeNoPath)) {
+      issues.push(issue2(`${path22}.tradeNoPath`, "INVALID_TRADE_NO_PATH", "tradeNoPath must be an absolute JSON Pointer"));
+    }
+    return;
+  }
+  if (!isSafeJsonPointer(value.statusPath)) {
+    issues.push(issue2(`${path22}.statusPath`, "INVALID_PAYMENT_STATUS_PATH", "statusPath must be an absolute JSON Pointer"));
+  }
+  if (!Array.isArray(value.inputBindings) || !value.inputBindings.some((binding) => isPlainRecord(binding) && isPlainRecord(binding.source) && binding.source.kind === "trade-no")) {
+    issues.push(issue2(`${path22}.inputBindings`, "PAYMENT_TRADE_NO_BINDING_MISSING", "queryTrade must map tradeNO"));
+  }
+  if (!Array.isArray(value.paidValues) || value.paidValues.length === 0 || value.paidValues.some((entry) => !isJsonPrimitive(entry))) {
+    issues.push(issue2(`${path22}.paidValues`, "INVALID_PAID_VALUES", "paidValues must contain JSON primitives"));
+  }
+}
+function collectPaymentActionReferences(value, path22, referenced, issues) {
+  if (!isPlainRecord(value))
+    return;
+  if (isPlainRecord(value.client) && value.client.name === A2UI_PAYMENT_ACTION_NAME) {
+    const context = value.client.context;
+    if (!isPlainRecord(context) || !isSafeIdentifier(context.actionId)) {
+      issues.push(issue2(path22, "INVALID_PAYMENT_ACTION", "payment action requires a safe actionId"));
+      return;
+    }
+    rejectExtraKeys(context, ["actionId", "actionContext"], `${path22}.client.context`, issues);
+    if (!isPlainRecord(context.actionContext)) {
+      issues.push(issue2(path22, "INVALID_PAYMENT_ACTION", "payment action requires an object actionContext"));
+    }
+    referenced.add(context.actionId);
+    return;
+  }
+  if (!isPlainRecord(value.select))
+    return;
+  if (Array.isArray(value.select.cases)) {
+    value.select.cases.forEach((entry, index) => {
+      if (isPlainRecord(entry)) {
+        collectPaymentActionReferences(entry.action, `${path22}.select.cases[${index}].action`, referenced, issues);
+      }
+    });
+  }
+  collectPaymentActionReferences(value.select.default, `${path22}.select.default`, referenced, issues);
+}
+function validateInputBindings2(value, path22, phase, issues) {
+  if (!Array.isArray(value) || value.length > 128) {
+    issues.push(issue2(path22, "INVALID_PAYMENT_INPUT_BINDINGS", "inputBindings must be an array of at most 128 entries"));
+    return;
+  }
+  const targets = /* @__PURE__ */ new Set();
+  value.forEach((candidate, index) => {
+    const itemPath = `${path22}[${index}]`;
+    if (!isPlainRecord(candidate) || !isSafeJsonPointer(candidate.inputPath)) {
+      issues.push(issue2(itemPath, "INVALID_PAYMENT_INPUT_BINDING", "inputPath must be an absolute JSON Pointer"));
+      return;
+    }
+    rejectExtraKeys(candidate, ["inputPath", "source"], itemPath, issues);
+    if (targets.has(candidate.inputPath)) {
+      issues.push(issue2(`${itemPath}.inputPath`, "DUPLICATE_PAYMENT_INPUT_PATH", "inputPath must be unique"));
+    }
+    targets.add(candidate.inputPath);
+    validateInputSource(candidate.source, `${itemPath}.source`, phase, issues);
+  });
+}
+function validateInputSource(value, path22, phase, issues) {
+  if (!isPlainRecord(value) || typeof value.kind !== "string") {
+    issues.push(issue2(path22, "INVALID_PAYMENT_INPUT_SOURCE", "source must be an object"));
+    return;
+  }
+  if (value.kind === "action-context") {
+    rejectExtraKeys(value, ["kind", "path"], path22, issues);
+    if (!isSafeJsonPointer(value.path, true)) {
+      issues.push(issue2(`${path22}.path`, "INVALID_PAYMENT_SOURCE_PATH", "action context path must be a JSON Pointer"));
+    }
+    return;
+  }
+  if (value.kind === "runtime-context") {
+    rejectExtraKeys(value, ["kind", "key"], path22, issues);
+    if (!RUNTIME_CONTEXT_KEYS2.has(String(value.key))) {
+      issues.push(issue2(`${path22}.key`, "INVALID_RUNTIME_CONTEXT_KEY", "runtime context key is unsupported"));
+    }
+    return;
+  }
+  if (value.kind === "literal") {
+    rejectExtraKeys(value, ["kind", "value"], path22, issues);
+    if (!isJsonValue(value.value)) {
+      issues.push(issue2(`${path22}.value`, "INVALID_PAYMENT_LITERAL", "literal must be JSON"));
+    }
+    return;
+  }
+  if (phase === "query" && value.kind === "trade-no") {
+    rejectExtraKeys(value, ["kind"], path22, issues);
+    return;
+  }
+  if (phase === "query" && value.kind === "callback") {
+    rejectExtraKeys(value, ["kind", "path"], path22, issues);
+    if (!isSafeJsonPointer(value.path, true)) {
+      issues.push(issue2(`${path22}.path`, "INVALID_PAYMENT_CALLBACK_PATH", "callback path must be a JSON Pointer"));
+    }
+    return;
+  }
+  issues.push(issue2(path22, "INVALID_PAYMENT_INPUT_SOURCE", `${value.kind} is unavailable for ${phase}`));
+}
+function rejectExtraKeys(value, allowed, path22, issues) {
+  const allowedKeys = new Set(allowed);
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      issues.push(issue2(`${path22}.${key}`, "UNEXPECTED_ACTION_BINDING_FIELD", `${key} is not allowed`));
+    }
+  }
+}
+function isJsonPrimitive(value) {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+var RUNTIME_CONTEXT_KEYS2 = /* @__PURE__ */ new Set(["agentId", "tenantId", "threadId", "userId"]);
+
 // ../agent-a2ui-card-contract/dist/esm/validation.js
 var FIELD_TYPES = [
   "array",
@@ -26315,7 +26557,7 @@ var FIELD_SOURCES = [
   "runtime-context",
   "local"
 ];
-var RUNTIME_CONTEXT_KEYS2 = /* @__PURE__ */ new Set([
+var RUNTIME_CONTEXT_KEYS3 = /* @__PURE__ */ new Set([
   "agentId",
   "tenantId",
   "threadId",
@@ -26339,11 +26581,14 @@ function getA2UICardDraftBundleIssues(value) {
   }
   const issues = [];
   exactKeys(value, ["manifest", "card", "fixture"], "draft", issues);
-  validateManifest(value.manifest, "draft.manifest", issues);
+  const manifest = validateManifest(value.manifest, "draft.manifest", issues);
   const card = validateProtocol(value.card, "draft.card", issues);
   if (card) {
     const analysis = analyzeA2UIBindings(card);
     issues.push(...analysis.issues);
+    if (manifest?.schemaVersion === "3") {
+      issues.push(...getA2UIPaymentActionReferenceIssues(card, manifest.actionBindings ?? [], "draft.card"));
+    }
   }
   return issues;
 }
@@ -26394,9 +26639,9 @@ function getA2UICardResourceConfigIssues(value) {
   validateLooseJsonSchema(value.presentationInputSchema, "config.presentationInputSchema", issues);
   const fields = validateFields(value.fields, "config.fields", issues);
   const resolver = validateResolver(value.resolver, "config.resolver", issues);
-  validateTemplate(value.a2uiTemplate, fields, issues);
+  const card = validateTemplate(value.a2uiTemplate, fields, issues);
   if (fields && resolver)
-    validateResolverCoverage(fields, resolver, issues);
+    validateResolverCoverage(fields, resolver, issues, card);
   return issues;
 }
 function getA2UICardResourceConfigV3Issues(value) {
@@ -26411,6 +26656,7 @@ function getA2UICardResourceConfigV3Issues(value) {
     "fields",
     "dataSources",
     "bindings",
+    "actionBindings",
     "a2uiTemplate"
   ], "config", issues);
   if (value.schemaVersion !== A2UI_CARD_SCHEMA_VERSION) {
@@ -26429,9 +26675,14 @@ function getA2UICardResourceConfigV3Issues(value) {
   }
   const dataSources = validateDataSources(value.dataSources, "config.dataSources", issues);
   const bindings = validateV3OutputBindings(value.bindings, "config.bindings", issues);
-  validateTemplate(value.a2uiTemplate, fields, issues);
+  const card = validateTemplate(value.a2uiTemplate, fields, issues);
+  const actionBindings = value.actionBindings === void 0 ? [] : value.actionBindings;
+  issues.push(...getA2UICardActionBindingIssues(actionBindings, "config.actionBindings"));
+  if (card && Array.isArray(actionBindings)) {
+    issues.push(...getA2UIPaymentActionReferenceIssues(card, actionBindings, "config.a2uiTemplate.content"));
+  }
   if (fields && dataSources && bindings) {
-    validateV3Coverage(fields, dataSources, bindings, issues);
+    validateV3Coverage(fields, dataSources, bindings, issues, { card });
   }
   return issues;
 }
@@ -26545,7 +26796,8 @@ function validateV3Coverage(fields, dataSources, bindings, issues, options = {})
     bound.add(binding.fieldId);
   });
   if (options.requireComplete !== false) {
-    for (const fieldId of businessFields) {
+    const requiredFields = options.card ? collectReferencedA2UICardBusinessFieldIds(options.card, fields.filter((field) => field.required)) : new Set(fields.filter((field) => field.source === "business" && field.required).map((field) => field.fieldId));
+    for (const fieldId of requiredFields) {
       if (bound.has(fieldId))
         continue;
       issues.push(issue2("config.bindings", "CARD_BINDING_INCOMPLETE", `business field ${fieldId} is not bound`));
@@ -26634,7 +26886,8 @@ function validateManifest(value, path22, issues) {
       "whenToUse",
       "whenNotToUse",
       "fields",
-      "bindings"
+      "bindings",
+      "actionBindings"
     ], path22, issues);
     if (!isSafeIdentifier(value.draftId)) {
       issues.push(issue2(`${path22}.draftId`, "INVALID_DRAFT_ID", "draftId is invalid"));
@@ -26654,6 +26907,9 @@ function validateManifest(value, path22, issues) {
     if (value.bindings !== void 0) {
       validateV3BindingSelections(value.bindings, `${path22}.bindings`, fields2, issues);
     }
+    if (value.actionBindings !== void 0) {
+      issues.push(...getA2UICardActionBindingIssues(value.actionBindings, `${path22}.actionBindings`));
+    }
     return fields2 ? value : void 0;
   }
   exactKeys(value, [
@@ -26761,7 +27017,7 @@ function validateFieldSource(candidate, itemPath, issues) {
     issues.push(issue2(`${itemPath}.sourcePath`, "UNEXPECTED_FIELD_SOURCE_PATH", "sourcePath is only allowed for invocation fields"));
   }
   if (candidate.source === "runtime-context") {
-    if (!RUNTIME_CONTEXT_KEYS2.has(candidate.runtimeContextKey)) {
+    if (!RUNTIME_CONTEXT_KEYS3.has(candidate.runtimeContextKey)) {
       issues.push(issue2(`${itemPath}.runtimeContextKey`, "INVALID_RUNTIME_CONTEXT", "runtime-context fields require an allowed runtimeContextKey"));
     }
   } else if (candidate.runtimeContextKey !== void 0) {
@@ -26813,11 +27069,11 @@ function validateResolverCalls(value, path22, issues) {
       issues.push(issue2(`${itemPath}.mcpResourceId`, "INVALID_MCP_RESOURCE_ID", "mcpResourceId is invalid"));
     }
     requiredString(candidate.toolName, `${itemPath}.toolName`, issues);
-    validateInputBindings2(candidate.inputBindings, `${itemPath}.inputBindings`, issues);
+    validateInputBindings3(candidate.inputBindings, `${itemPath}.inputBindings`, issues);
   });
   return value;
 }
-function validateInputBindings2(value, path22, issues) {
+function validateInputBindings3(value, path22, issues) {
   if (!Array.isArray(value)) {
     issues.push(issue2(path22, "INVALID_INPUT_BINDINGS", "inputBindings must be an array"));
     return void 0;
@@ -26837,11 +27093,11 @@ function validateInputBindings2(value, path22, issues) {
     } else {
       paths.add(candidate.inputPath);
     }
-    validateInputSource(candidate.source, `${itemPath}.source`, issues);
+    validateInputSource2(candidate.source, `${itemPath}.source`, issues);
   });
   return value;
 }
-function validateInputSource(value, path22, issues) {
+function validateInputSource2(value, path22, issues) {
   if (!isPlainRecord(value)) {
     issues.push(issue2(path22, "INVALID_INPUT_SOURCE", "source must be an object"));
     return;
@@ -26855,7 +27111,7 @@ function validateInputSource(value, path22, issues) {
   }
   if (value.kind === "runtime-context") {
     exactKeys(value, ["kind", "key"], path22, issues);
-    if (!RUNTIME_CONTEXT_KEYS2.has(value.key)) {
+    if (!RUNTIME_CONTEXT_KEYS3.has(value.key)) {
       issues.push(issue2(`${path22}.key`, "INVALID_RUNTIME_CONTEXT", "runtime context key is invalid"));
     }
     return;
@@ -26983,13 +27239,13 @@ function validateInstructionShape(instruction, path22, issues) {
 function validateTemplate(value, fields, issues) {
   if (!isPlainRecord(value)) {
     issues.push(issue2("config.a2uiTemplate", "INVALID_A2UI_TEMPLATE", "a2uiTemplate must be an object"));
-    return;
+    return void 0;
   }
   exactKeys(value, ["argsSchema", "content"], "config.a2uiTemplate", issues);
   validateLooseJsonSchema(value.argsSchema, "config.a2uiTemplate.argsSchema", issues);
   if (typeof value.content !== "string") {
     issues.push(issue2("config.a2uiTemplate.content", "INVALID_A2UI_CONTENT", "a2uiTemplate.content must be serialized A2UI JSON"));
-    return;
+    return void 0;
   }
   try {
     const card = validateProtocol(JSON.parse(value.content), "config.a2uiTemplate.content", issues);
@@ -26997,9 +27253,11 @@ function validateTemplate(value, fields, issues) {
       const analysis = analyzeA2UIBindings(card);
       issues.push(...analysis.issues);
     }
+    return card;
   } catch {
     issues.push(issue2("config.a2uiTemplate.content", "INVALID_A2UI_CONTENT", "a2uiTemplate.content must contain valid JSON"));
   }
+  return void 0;
 }
 function validateLooseJsonSchema(value, path22, issues) {
   const schemaIssues = getJsonSchemaIssues(value, path22, {
@@ -27008,7 +27266,7 @@ function validateLooseJsonSchema(value, path22, issues) {
   issues.push(...schemaIssues);
   return schemaIssues.length === 0;
 }
-function validateResolverCoverage(fields, resolver, issues) {
+function validateResolverCoverage(fields, resolver, issues, card) {
   const businessFields = new Set(fields.filter((field) => field.source === "business").map((field) => field.fieldId));
   const bound = /* @__PURE__ */ new Set();
   resolver.outputBindings.forEach((binding, index) => {
@@ -27017,7 +27275,8 @@ function validateResolverCoverage(fields, resolver, issues) {
     }
     bound.add(binding.fieldId);
   });
-  for (const fieldId of businessFields) {
+  const requiredFields = card ? collectReferencedA2UICardBusinessFieldIds(card, fields.filter((field) => field.required)) : new Set(fields.filter((field) => field.source === "business" && field.required).map((field) => field.fieldId));
+  for (const fieldId of requiredFields) {
     if (!bound.has(fieldId)) {
       issues.push(issue2("config.resolver.outputBindings", "CARD_BINDING_INCOMPLETE", `business field ${fieldId} is not bound`));
     }
@@ -27065,6 +27324,7 @@ function compileA2UICardResource(input) {
   }
   const fieldById = new Map(draft.manifest.fields.map((field) => [field.fieldId, field]));
   const selectionByField = /* @__PURE__ */ new Map();
+  const requiredFields = collectReferencedA2UICardBusinessFieldIds(draft.card, draft.manifest.fields.filter((field) => field.required));
   for (const selection of input.bindings) {
     const field = fieldById.get(selection.fieldId);
     if (!field || field.source !== "business") {
@@ -27078,9 +27338,9 @@ function compileA2UICardResource(input) {
     }
     selectionByField.set(selection.fieldId, cloneSelection(selection));
   }
-  for (const field of draft.manifest.fields) {
-    if (field.source === "business" && !selectionByField.has(field.fieldId)) {
-      throw new A2UICardCompileError("CARD_BINDING_INCOMPLETE", `Business field ${field.fieldId} has not been bound`);
+  for (const fieldId of requiredFields) {
+    if (!selectionByField.has(fieldId)) {
+      throw new A2UICardCompileError("CARD_BINDING_INCOMPLETE", `Required referenced business field ${fieldId} has not been bound`);
     }
   }
   const resolver = compileResolver([...selectionByField.values()]);
@@ -27172,6 +27432,7 @@ function compileV3Resource(draft, revision, bindings, tools) {
   const sourceById = /* @__PURE__ */ new Map();
   const outputBindings = [];
   const boundFields = /* @__PURE__ */ new Set();
+  const requiredFields = collectReferencedA2UICardBusinessFieldIds(draft.card, draft.manifest.fields.filter((field) => field.required));
   for (const binding of bindings) {
     const field = fieldById.get(binding.fieldId);
     if (!field || field.source !== "business" || boundFields.has(binding.fieldId)) {
@@ -27199,9 +27460,9 @@ function compileV3Resource(draft, revision, bindings, tools) {
       transform: binding.transform
     });
   }
-  for (const field of draft.manifest.fields) {
-    if (field.source === "business" && !boundFields.has(field.fieldId)) {
-      throw new A2UICardCompileError("CARD_BINDING_INCOMPLETE", `Business field ${field.fieldId} has not been bound`);
+  for (const fieldId of requiredFields) {
+    if (!boundFields.has(fieldId)) {
+      throw new A2UICardCompileError("CARD_BINDING_INCOMPLETE", `Required referenced business field ${fieldId} has not been bound`);
     }
   }
   const resource = {
@@ -27214,6 +27475,9 @@ function compileV3Resource(draft, revision, bindings, tools) {
     fields: draft.manifest.fields,
     dataSources: [...sourceById.values()].sort((left, right) => left.sourceId.localeCompare(right.sourceId)),
     bindings: outputBindings.sort((left, right) => left.fieldId.localeCompare(right.fieldId)),
+    ...draft.manifest.actionBindings?.length ? {
+      actionBindings: JSON.parse(JSON.stringify(draft.manifest.actionBindings))
+    } : {},
     a2uiTemplate: {
       argsSchema: createA2UICardViewModelSchema(draft.manifest.fields),
       content: stableJsonStringify(draft.card)
@@ -27404,9 +27668,6 @@ function createA2UICardDraftStructureChecksum(draft) {
   delete cloned.manifest.bindings;
   return sha256Hex(stableJsonStringify(cloned));
 }
-function createA2UICardMcpConfigChecksum(resources) {
-  return sha256Hex(stableJsonStringify(resources));
-}
 function createA2UICardRevision(draftChecksum2, bindings) {
   const digest = sha256Hex(`${draftChecksum2}
 ${stableJsonStringify(bindings)}`);
@@ -27485,6 +27746,410 @@ var SHA256_CONSTANTS = [
   3329325298
 ];
 
+// ../agent-a2ui-card-contract/dist/esm/authoring-model.js
+var INTERNAL_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "id",
+  "component",
+  "surfaceId",
+  "version",
+  "child",
+  "children"
+]);
+var MERCHANT_CONTENT_KEYS = /* @__PURE__ */ new Set([
+  "caption",
+  "description",
+  "label",
+  "placeholder",
+  "subtitle",
+  "text",
+  "title"
+]);
+var DEFAULT_AUTHORING_PROJECTION = {
+  directTargets: "content"
+};
+var COMPONENT_AUTHORING_PROJECTIONS = {
+  Image: {
+    directTargets: "image-source",
+    fieldProperties: ["src"],
+    groupLabel: "\u56FE\u7247"
+  }
+};
+function extractA2UICardAuthoringModel(bundle, options = {}) {
+  const analysis = analyzeA2UIBindings(bundle.card);
+  const bindingByField = new Map((bundle.manifest.bindings ?? []).map((binding) => [
+    binding.fieldId,
+    binding
+  ]));
+  const fields = bundle.manifest.fields.filter((field) => field.source === "business");
+  const registered = options.registeredComponents ? new Set(options.registeredComponents) : void 0;
+  const occurrencesByComponent = groupBindingOccurrences(analysis.occurrences);
+  const allFieldOccurrenceTargets = [];
+  const groups = [];
+  let order = 0;
+  for (const { surfaceId, component } of orderedComponents(bundle)) {
+    const occurrenceId = createA2UICardAuthoringOccurrenceId(surfaceId, component.id);
+    const targets = [];
+    if (!registered || registered.has(component.component)) {
+      const projection = componentAuthoringProjection(component);
+      const componentOccurrences = occurrencesByComponent.get(componentKey(surfaceId, component.id)) ?? [];
+      discoverComponentTargets(component, occurrenceId, projection, targets);
+      allFieldOccurrenceTargets.push(...fieldTargets(component, occurrenceId, fields, componentOccurrences, false));
+      targets.push(...fieldTargets(component, occurrenceId, fields, componentOccurrences, true));
+      targets.push(...actionTargets(component, occurrenceId, bundle.manifest.schemaVersion === "3" ? bundle.manifest.actionBindings : void 0));
+    }
+    if (targets.length === 0) {
+      targets.push({
+        kind: "agent-only",
+        targetId: createA2UICardAuthoringTargetId(occurrenceId, "agent-only"),
+        occurrenceId,
+        label: "\u901A\u8FC7 Coding Agent \u4FEE\u6539",
+        reason: registered && !registered.has(component.component) ? "\u7EC4\u4EF6\u672A\u5728\u5F53\u524D Catalog \u6CE8\u518C" : "\u6CA1\u6709\u53EF\u5B89\u5168\u76F4\u63A5\u7F16\u8F91\u7684\u4E1A\u52A1\u5B57\u6BB5"
+      });
+    }
+    groups.push({
+      occurrenceId,
+      surfaceId,
+      componentId: component.id,
+      componentName: component.component,
+      order: order++,
+      label: componentAuthoringProjection(component).groupLabel ?? componentLabel(component),
+      targets: deduplicateTargets(targets),
+      agentOnly: targets.every((target) => target.kind === "agent-only")
+    });
+  }
+  const fieldStates = fields.map((field) => {
+    const occurrences = allFieldOccurrenceTargets.filter((target) => target.fieldId === field.fieldId);
+    const binding = bindingByField.get(field.fieldId);
+    return {
+      field,
+      ...binding ? { binding: cloneBinding(binding) } : {},
+      occurrences,
+      usageCount: new Set(occurrences.map((target) => `${target.occurrenceId}\0${target.propertyPath}`)).size,
+      status: occurrences.length === 0 ? "unused" : binding ? "bound" : field.required ? "unbound-required" : "unbound-optional"
+    };
+  });
+  const diagnostics = getA2UICardAuthoringDiagnostics(bundle, {
+    groups,
+    fields: fieldStates
+  });
+  return {
+    draftId: bundle.manifest.draftId,
+    resourceId: bundle.manifest.resourceId,
+    groups,
+    fields: fieldStates,
+    diagnostics
+  };
+}
+function componentAuthoringProjection(component) {
+  return COMPONENT_AUTHORING_PROJECTIONS[component.component] ?? DEFAULT_AUTHORING_PROJECTION;
+}
+function discoverComponentTargets(component, occurrenceId, projection, targets) {
+  if (projection.directTargets === "content") {
+    discoverTargets(component, occurrenceId, "", targets);
+    return;
+  }
+  if (typeof component.src !== "string")
+    return;
+  targets.push({
+    kind: "image",
+    targetId: createA2UICardAuthoringTargetId(occurrenceId, "src"),
+    occurrenceId,
+    propertyPath: "src",
+    label: "\u56FE\u7247\u5730\u5740",
+    value: component.src,
+    role: "src"
+  });
+}
+function getA2UICardAuthoringDiagnostics(bundle, partial) {
+  const diagnostics = getA2UICardDraftBundleIssues(bundle).map((entry) => ({
+    ...entry,
+    severity: "hard-error"
+  }));
+  const model = partial ?? extractA2UICardAuthoringModel(bundle);
+  for (const field of model.fields) {
+    if (field.status === "unbound-required") {
+      diagnostics.push({
+        code: "REQUIRED_BINDING_MISSING",
+        path: `manifest.fields.${field.field.fieldId}`,
+        message: `\u5FC5\u586B\u5B57\u6BB5\u201C${field.field.label}\u201D\u5C1A\u672A\u7ED1\u5B9A`,
+        severity: "hard-error",
+        fieldId: field.field.fieldId
+      });
+    }
+  }
+  for (const group of model.groups) {
+    const component = findComponent(bundle, group.surfaceId, group.componentId);
+    const action = isPlainRecord(component?.action) ? component.action : void 0;
+    const client = action && isPlainRecord(action.client) ? action.client : void 0;
+    if (client?.name === "ui.page.open") {
+      const context = isPlainRecord(client.context) ? client.context : void 0;
+      if (typeof context?.url === "string" && !isSafePageUrl(context.url)) {
+        diagnostics.push({
+          code: "UNSAFE_PAGE_URL",
+          path: `${group.occurrenceId}.action.client.context.url`,
+          message: "\u9875\u9762\u5730\u5740\u5FC5\u987B\u662F\u5B89\u5168\u7684 http(s) \u5730\u5740\u6216\u7AD9\u5185\u7EDD\u5BF9\u8DEF\u5F84",
+          severity: "hard-error",
+          occurrenceId: group.occurrenceId
+        });
+      }
+    } else if (client && typeof client.name === "string" && !["ui.overlay.close", "ui.surface.open"].includes(client.name)) {
+      diagnostics.push({
+        code: "UNREGISTERED_CLIENT_ACTION",
+        path: `${group.occurrenceId}.action.client.name`,
+        message: `\u672A\u6CE8\u518C\u7684 Client Action\uFF1A${client.name}`,
+        severity: "hard-error",
+        occurrenceId: group.occurrenceId
+      });
+    }
+  }
+  return deduplicateDiagnostics(diagnostics);
+}
+function validateA2UICardForPublish(bundle) {
+  return getA2UICardAuthoringDiagnostics(bundle).filter((diagnostic) => diagnostic.severity === "hard-error");
+}
+function createA2UICardAuthoringOccurrenceId(surfaceId, componentId) {
+  return `${encodeURIComponent(surfaceId)}:${encodeURIComponent(componentId)}`;
+}
+function createA2UICardAuthoringTargetId(occurrenceId, propertyPath) {
+  return `${occurrenceId}:${encodeURIComponent(propertyPath)}`;
+}
+function isSafePageUrl(url) {
+  const trimmed = url.trim();
+  if (trimmed.length === 0 || trimmed.length > 2e3)
+    return false;
+  const token = /\{\{([^{}]+)\}\}/gu;
+  let tokenCount = 0;
+  for (const match of trimmed.matchAll(token)) {
+    tokenCount++;
+    if (tokenCount > 32)
+      return false;
+    const path22 = match[1]?.trim() ?? "";
+    if (!(path22 === "/" || path22.startsWith("/") || path22.startsWith("./")) || path22.split("/").some((part) => ["..", "__proto__", "constructor", "prototype"].includes(part))) {
+      return false;
+    }
+  }
+  const candidate = trimmed.replace(token, "value");
+  if (candidate.includes("{{") || candidate.includes("}}"))
+    return false;
+  try {
+    return ["https:", "alipays:"].includes(new URL(candidate).protocol);
+  } catch {
+    return false;
+  }
+}
+function orderedComponents(bundle) {
+  const result = [];
+  for (const message of bundle.card) {
+    for (const instruction of message.datas) {
+      if (!("updateComponents" in instruction))
+        continue;
+      for (const component of instruction.updateComponents.components) {
+        result.push({
+          surfaceId: instruction.updateComponents.surfaceId,
+          component
+        });
+      }
+    }
+  }
+  return result;
+}
+function discoverTargets(value, occurrenceId, propertyPath, targets) {
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => discoverTargets(entry, occurrenceId, appendPath(propertyPath, String(index)), targets));
+    return;
+  }
+  if (!isPlainRecord(value))
+    return;
+  if (typeof value.path === "string")
+    return;
+  for (const [key, entry] of Object.entries(value)) {
+    const nextPath = appendPath(propertyPath, key);
+    if (INTERNAL_KEYS.has(key) || key === "action")
+      continue;
+    if (Array.isArray(entry) || isPlainRecord(entry)) {
+      discoverTargets(entry, occurrenceId, nextPath, targets);
+      continue;
+    }
+    if (!isJsonValue(entry))
+      continue;
+    if (typeof entry !== "string" || !MERCHANT_CONTENT_KEYS.has(key))
+      continue;
+    targets.push({
+      kind: "literal",
+      targetId: createA2UICardAuthoringTargetId(occurrenceId, nextPath),
+      occurrenceId,
+      propertyPath: nextPath,
+      label: propertyLabel(nextPath),
+      value: entry
+    });
+  }
+}
+function actionTargets(component, occurrenceId, actionBindings) {
+  if (!isPlainRecord(component.action))
+    return [];
+  const action = component.action;
+  const event = isPlainRecord(action.event) ? action.event : void 0;
+  if (event) {
+    const message = event["x2-user-message"];
+    if (typeof message === "string" && typeof event.name === "string") {
+      return [
+        {
+          kind: "agent-event",
+          targetId: createA2UICardAuthoringTargetId(occurrenceId, "action"),
+          occurrenceId,
+          propertyPath: "action",
+          label: "\u70B9\u51FB\u540E",
+          message,
+          eventName: event.name,
+          hasContext: isPlainRecord(event.context)
+        }
+      ];
+    }
+    return [agentOnlyAction(occurrenceId, "\u52A8\u6001\u6216\u590D\u6742\u4E8B\u4EF6\u901A\u8FC7\u667A\u80FD\u4F53\u4FEE\u6539")];
+  }
+  const client = isPlainRecord(action.client) ? action.client : void 0;
+  if (client?.name === "ui.page.open") {
+    const context = isPlainRecord(client.context) ? client.context : void 0;
+    const url = context?.url;
+    return [
+      {
+        kind: "page-open",
+        targetId: createA2UICardAuthoringTargetId(occurrenceId, "action"),
+        occurrenceId,
+        propertyPath: "action",
+        label: "\u6253\u5F00\u9875\u9762",
+        ...typeof url === "string" ? { url } : {},
+        dynamic: isPlainRecord(url) && typeof url.path === "string"
+      }
+    ];
+  }
+  if (client?.name === "payment.trade-pay") {
+    const context = isPlainRecord(client.context) ? client.context : void 0;
+    const actionId = typeof context?.actionId === "string" ? context.actionId : "";
+    const actionContext = isPlainRecord(context?.actionContext) ? context.actionContext : {};
+    const binding = actionBindings?.find((candidate) => candidate.kind === "payment" && candidate.actionId === actionId);
+    return [{
+      kind: "payment",
+      targetId: createA2UICardAuthoringTargetId(occurrenceId, "action"),
+      occurrenceId,
+      propertyPath: "action",
+      label: "\u652F\u4ED8",
+      actionId,
+      actionContext,
+      ...binding ? { binding } : {},
+      configured: Boolean(actionId && binding)
+    }];
+  }
+  return [agentOnlyAction(occurrenceId, "\u8BE5\u884C\u4E3A\u53EA\u80FD\u901A\u8FC7 Coding Agent \u4FEE\u6539")];
+}
+function fieldTargets(component, occurrenceId, fields, occurrences, projectedOnly) {
+  const projection = componentAuthoringProjection(component);
+  const ordered = [...fields].sort((left, right) => right.path.length - left.path.length);
+  return occurrences.flatMap((occurrence) => {
+    if (projectedOnly && !isProjectedFieldOccurrence(occurrence.propertyPath, projection)) {
+      return [];
+    }
+    const field = ordered.find((candidate) => occurrence.canonicalPath === candidate.path || occurrence.canonicalPath.startsWith(`${candidate.path}/*/`) || occurrence.canonicalPath.startsWith(`${candidate.path}/`));
+    if (!field)
+      return [];
+    const suffix = occurrence.canonicalPath.slice(field.path.length).replace(/^\/\*/u, "");
+    const targetPath = suffix ? suffix.startsWith("/") ? suffix : `/${suffix}` : void 0;
+    return [
+      {
+        kind: "field-occurrence",
+        targetId: createA2UICardAuthoringTargetId(occurrenceId, occurrence.propertyPath),
+        occurrenceId,
+        propertyPath: occurrence.propertyPath,
+        label: fieldOccurrenceLabel(targetPath, occurrence.propertyPath),
+        fieldId: field.fieldId,
+        ...targetPath ? { targetPath } : {}
+      }
+    ];
+  });
+}
+function isProjectedFieldOccurrence(propertyPath, projection) {
+  if (propertyPath === "action" || propertyPath.startsWith("action.")) {
+    return false;
+  }
+  return projection.fieldProperties === void 0 || projection.fieldProperties.includes(propertyPath);
+}
+function fieldOccurrenceLabel(targetPath, propertyPath) {
+  if (!targetPath)
+    return propertyLabel(propertyPath);
+  const segment = targetPath.split("/").filter(Boolean).at(-1);
+  return segment ? decodeJsonPointerSegment(segment) : propertyLabel(propertyPath);
+}
+function decodeJsonPointerSegment(segment) {
+  return segment.replace(/~1/gu, "/").replace(/~0/gu, "~");
+}
+function groupBindingOccurrences(occurrences) {
+  const result = /* @__PURE__ */ new Map();
+  for (const occurrence of occurrences) {
+    if (!occurrence.surfaceId)
+      continue;
+    const key = componentKey(occurrence.surfaceId, occurrence.componentId);
+    const entries = result.get(key) ?? [];
+    entries.push(occurrence);
+    result.set(key, entries);
+  }
+  return result;
+}
+function findComponent(bundle, surfaceId, componentId) {
+  return orderedComponents(bundle).find((entry) => entry.surfaceId === surfaceId && entry.component.id === componentId)?.component;
+}
+function agentOnlyAction(occurrenceId, reason) {
+  return {
+    kind: "agent-only",
+    targetId: createA2UICardAuthoringTargetId(occurrenceId, "action"),
+    occurrenceId,
+    propertyPath: "action",
+    label: "\u901A\u8FC7 Coding Agent \u4FEE\u6539\u884C\u4E3A",
+    reason
+  };
+}
+function componentLabel(component) {
+  const candidate = component.label ?? component.title ?? component.text;
+  return typeof candidate === "string" && candidate.trim() ? candidate : component.component;
+}
+function propertyLabel(propertyPath) {
+  const key = propertyPath.split(".").at(-1) ?? propertyPath;
+  const labels = {
+    text: "\u6587\u6848",
+    title: "\u6807\u9898",
+    subtitle: "\u526F\u6807\u9898",
+    label: "\u6807\u7B7E",
+    description: "\u8BF4\u660E",
+    value: "\u5185\u5BB9",
+    alt: "\u56FE\u7247\u8BF4\u660E"
+  };
+  return labels[key] ?? key;
+}
+function appendPath(base, segment) {
+  return base ? `${base}.${segment}` : segment;
+}
+function componentKey(surfaceId, componentId) {
+  return `${surfaceId}\0${componentId}`;
+}
+function deduplicateTargets(targets) {
+  return [
+    ...new Map(targets.map((target) => [target.targetId, target])).values()
+  ];
+}
+function deduplicateDiagnostics(diagnostics) {
+  return [
+    ...new Map(diagnostics.map((entry) => [
+      `${entry.code}\0${entry.path}\0${entry.fieldId ?? ""}`,
+      entry
+    ])).values()
+  ];
+}
+function cloneBinding(binding) {
+  return JSON.parse(JSON.stringify(binding));
+}
+
 // src/commands/card/index.ts
 var DRAFT_ROOT = ".card-drafts";
 var AGENT_CONFIG_PATH = "agent_config.json";
@@ -27614,36 +28279,20 @@ async function validateCardBindingsFromDisk(cwd, draftId, fieldId) {
   const directory = draftDirectory(cwd, draftId);
   const [bundle, contextValue, configValue] = await Promise.all([
     readBundle(directory, draftId),
-    readRequiredJson(import_path22.default.join(directory, "binding-context.json")),
+    readOptionalJson(import_path22.default.join(directory, "binding-context.json")),
     readRequiredJson(import_path22.default.join(cwd, AGENT_CONFIG_PATH))
   ]);
-  const contextResult = parseA2UICardBindingContext(contextValue);
-  if (!contextResult.success) {
-    throw new LinkqueCliError(
-      "CARD_BINDING_CONTEXT_INVALID",
-      contextResult.issues.map((entry) => entry.message).join("; ")
-    );
-  }
-  const context = contextResult.data;
+  const context = parseOptionalBindingContext(contextValue);
   const draftStructureChecksum = createA2UICardDraftStructureChecksum(bundle);
   const config2 = parseAgentConfig(configValue);
   const mcpResources = normalizedMcpResources(config2);
-  if (context.mcpConfigChecksum !== createA2UICardMcpConfigChecksum(mcpResources)) {
-    throw new LinkqueCliError(
-      "CARD_BINDING_CONTEXT_STALE",
-      "MCP \u914D\u7F6E\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u53D1\u8D77 AI \u8F85\u52A9\u7ED1\u5B9A"
-    );
-  }
-  const issues = validateA2UICardBindings(
-    {
-      draft: bundle,
-      context,
-      mountedMcpResourceIds: new Set(
-        mcpResources.map((resource) => String(resource.resourceId))
-      )
-    },
-    fieldId ? { fieldIds: /* @__PURE__ */ new Set([fieldId]) } : void 0
+  const mountedMcpResourceIds = new Set(
+    mcpResources.map((resource) => String(resource.resourceId))
   );
+  const issues = context ? validateA2UICardBindings(
+    { draft: bundle, context, mountedMcpResourceIds },
+    fieldId ? { fieldIds: /* @__PURE__ */ new Set([fieldId]) } : void 0
+  ) : validateBindingsWithoutContext(bundle, mountedMcpResourceIds, fieldId);
   if (issues.length > 0) {
     throw new LinkqueCliError(
       "CARD_BINDING_VALIDATION_FAILED",
@@ -27674,15 +28323,9 @@ async function finalizeCardWhileLocked(cwd, draftId, expectedDraftChecksum) {
   }
   const directory = draftDirectory(cwd, draftId);
   const bundle = await readBundle(directory, draftId);
-  const contextResult = parseA2UICardBindingContext(
-    await readRequiredJson(import_path22.default.join(directory, "binding-context.json"))
+  const context = parseOptionalBindingContext(
+    await readOptionalJson(import_path22.default.join(directory, "binding-context.json"))
   );
-  if (!contextResult.success) {
-    throw new LinkqueCliError(
-      "CARD_BINDING_CONTEXT_INVALID",
-      contextResult.issues.map((entry) => entry.message).join("; ")
-    );
-  }
   const configPath = import_path22.default.join(cwd, AGENT_CONFIG_PATH);
   const oldConfigBytes = await (0, import_promises16.readFile)(configPath);
   const config2 = parseAgentConfig(
@@ -27716,7 +28359,7 @@ async function finalizeCardWhileLocked(cwd, draftId, expectedDraftChecksum) {
     // V3，让 Agent 直接按真实 MCP inputSchema 决定参数；不再把 presentation input
     // 或 inputBindings 固化进 CARD。
     ...bindings.length > 0 ? { targetSchemaVersion: "3" } : {},
-    tools: contextResult.data.candidates.flatMap(
+    tools: (context?.candidates ?? []).flatMap(
       (candidate) => candidate.status === "ready" ? [candidate.tool] : []
     )
   });
@@ -28043,6 +28686,47 @@ function normalizedMcpResources(config2) {
     (left, right) => stableJsonStringify(left).localeCompare(stableJsonStringify(right))
   );
 }
+function parseOptionalBindingContext(value) {
+  if (value === void 0) return void 0;
+  const result = parseA2UICardBindingContext(value);
+  if (!result.success) {
+    throw new LinkqueCliError(
+      "CARD_BINDING_CONTEXT_INVALID",
+      result.issues.map((entry) => entry.message).join("; ")
+    );
+  }
+  return result.data;
+}
+function validateBindingsWithoutContext(bundle, mountedMcpResourceIds, fieldId) {
+  const selectedFields = fieldId ? /* @__PURE__ */ new Set([fieldId]) : void 0;
+  const bindings = (bundle.manifest.bindings ?? []).filter(
+    (binding) => !selectedFields || selectedFields.has(binding.fieldId)
+  );
+  const issues = getA2UICardBindingSelectionIssues(
+    bindings,
+    "draft.manifest.bindings",
+    bundle.manifest.fields
+  );
+  for (const binding of bindings) {
+    if (!mountedMcpResourceIds.has(binding.mcpResourceId)) {
+      issues.push({
+        code: "MCP_TOOL_UNAVAILABLE",
+        message: `MCP resource ${binding.mcpResourceId} is not mounted`,
+        path: `draft.manifest.bindings.${binding.fieldId}`
+      });
+    }
+  }
+  if (!selectedFields) {
+    issues.push(
+      ...validateA2UICardForPublish(bundle).map((diagnostic) => ({
+        code: diagnostic.code,
+        message: diagnostic.message,
+        path: diagnostic.path
+      }))
+    );
+  }
+  return issues;
+}
 function isJsonObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }