linkque-cli-v2 1.0.7 → 1.1.0

package/linkquejs.js

@@ -25449,6 +25449,20 @@ function getJsonSchemaIssues(value, path22 = "schema", options = {}) {
   validateSchemaNode(value, path22, issues, options);
   return issues;
 }
+var OPAQUE_OBJECT_SCHEMA = {
+  type: "object",
+  additionalProperties: true
+};
+function normalizeMcpOutputSchema(value) {
+  if (!isPlainRecord(value) || getJsonSchemaIssues(value).length > 0) {
+    return { schema: { ...OPAQUE_OBJECT_SCHEMA }, mode: "opaque" };
+  }
+  const schema = cloneJsonValue(value);
+  if (schema.type === "object" && (!isPlainRecord(schema.properties) || Object.keys(schema.properties).length === 0) && !isPlainRecord(schema.additionalProperties)) {
+    return { schema: { ...OPAQUE_OBJECT_SCHEMA }, mode: "opaque" };
+  }
+  return { schema, mode: "declared" };
+}
 function normalizeTargetJsonSchema(schema) {
   const cloned = JSON.parse(JSON.stringify(schema));
   normalizeObjectDefaults(cloned);
@@ -25901,7 +25915,7 @@ function parseA2UICardBindingContext(value) {
   const issues = getA2UICardBindingContextIssues(value);
   return issues.length > 0 ? { success: false, issues } : {
     success: true,
-    data: JSON.parse(JSON.stringify(value)),
+    data: normalizeBindingContext(value),
     issues: []
   };
 }
@@ -26048,11 +26062,7 @@ function validateA2UICardBindings(input, options = {}) {
       issues.push(issue2(`fields.${field.fieldId}`, "MCP_TOOL_UNAVAILABLE", `MCP tool ${binding.toolName} is absent from binding context`));
       continue;
     }
-    const transform = validateA2UICardTransform(binding.transform, {
-      fieldId: field.fieldId,
-      sourceSchema: tool.outputSchema,
-      targetSchema: field.valueSchema
-    });
+    const transform = validateA2UICardTransform(binding.transform);
     issues.push(...transform.issues.map((entry) => ({
       ...entry,
       path: `fields.${field.fieldId}.${entry.path}`
@@ -26123,6 +26133,7 @@ function validateTool(value, path22, resourceId, issues) {
     "description",
     "inputSchema",
     "outputSchema",
+    "outputSchemaMode",
     "annotations"
   ], path22, issues);
   if (value.resourceId !== resourceId) {
@@ -26132,11 +26143,28 @@ function validateTool(value, path22, resourceId, issues) {
     issues.push(issue2(`${path22}.toolName`, "CARD_BINDING_CONTEXT_INVALID", "toolName is required"));
   }
   issues.push(...getJsonSchemaIssues(value.inputSchema, `${path22}.inputSchema`));
-  issues.push(...getJsonSchemaIssues(value.outputSchema, `${path22}.outputSchema`));
-  if (isPlainRecord(value.annotations) && value.annotations.readOnlyHint === false) {
-    issues.push(issue2(`${path22}.annotations`, "CARD_BINDING_CONTEXT_INVALID", "tool explicitly declares readOnlyHint=false"));
+  if (value.outputSchemaMode !== void 0 && value.outputSchemaMode !== "declared" && value.outputSchemaMode !== "opaque") {
+    issues.push(issue2(`${path22}.outputSchemaMode`, "CARD_BINDING_CONTEXT_INVALID", "outputSchemaMode must be declared or opaque"));
   }
 }
+function normalizeBindingContext(context) {
+  const cloned = JSON.parse(JSON.stringify(context));
+  cloned.candidates = cloned.candidates.map((candidate) => {
+    if (candidate.status !== "ready")
+      return candidate;
+    const normalized = normalizeMcpOutputSchema(candidate.tool.outputSchema);
+    const mode2 = normalized.mode === "opaque" || candidate.tool.outputSchemaMode === "opaque" ? "opaque" : "declared";
+    return {
+      ...candidate,
+      tool: {
+        ...candidate.tool,
+        outputSchema: normalized.schema,
+        outputSchemaMode: mode2
+      }
+    };
+  });
+  return cloned;
+}
 function validatePreferences(value, path22, issues) {
   if (value === void 0)
     return;
@@ -27150,7 +27178,7 @@ function compileV3Resource(draft, revision, bindings, tools) {
       purpose: binding.purpose,
       required: binding.required,
       ...binding.dependsOn?.length ? { dependsOn: [...binding.dependsOn] } : {},
-      outputSchema: tool?.outputSchema ?? {}
+      outputSchema: normalizeMcpOutputSchema(tool?.outputSchema).schema
     };
     const previous = sourceById.get(source.sourceId);
     if (previous && stableJsonStringify(previous) !== stableJsonStringify(source)) {
@@ -27600,7 +27628,10 @@ async function validateCardBindingsFromDisk(cwd, draftId, expectedContextChecksu
   }
   const context = contextResult.data;
   const actualContextChecksum = createA2UICardBindingContextChecksum(context);
-  if (actualContextChecksum !== expectedContextChecksum) {
+  const legacyContextChecksum = createA2UICardBindingContextChecksum(
+    contextValue
+  );
+  if (actualContextChecksum !== expectedContextChecksum && legacyContextChecksum !== expectedContextChecksum) {
     throw new LinkqueCliError(
       "CARD_BINDING_CONTEXT_STALE",
       "\u7ED1\u5B9A\u4E0A\u4E0B\u6587\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u53D1\u8D77 AI \u8F85\u52A9\u7ED1\u5B9A"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkque-cli-v2",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "description": "Public Linkque CLI bundle for sandbox debugging",
   "bin": {
     "linkquejs": "linkquejs.js"

package/vendor/linkque-agent-appwrite-integrate/dist/esm/{chunk-FJ2BZPIM.js → chunk-MN4S5EF5.js}

@@ -1385,7 +1385,7 @@ var require_errors = __commonJS({
       message: ({ keyword }) => (0, codegen_1.str)`must pass "${keyword}" keyword validation`
     };
     exports.keyword$DataError = {
-      message: ({ keyword, schemaType }) => schemaType ? (0, codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)` : (0, codegen_1.str)`"${keyword}" keyword is invalid ($data)`
+      message: ({ keyword, schemaType: schemaType2 }) => schemaType2 ? (0, codegen_1.str)`"${keyword}" keyword must be ${schemaType2} ($data)` : (0, codegen_1.str)`"${keyword}" keyword is invalid ($data)`
     };
     function reportError(cxt, error = exports.keywordError, errorPaths, overrideAllErrors) {
       const { it } = cxt;
@@ -2044,8 +2044,8 @@ var require_keyword = __commonJS({
         throw new Error(`keyword "${keyword}" failed to compile`);
       return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_1.stringify)(result) });
     }
-    function validSchemaType(schema, schemaType, allowUndefined = false) {
-      return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st || allowUndefined && typeof schema == "undefined");
+    function validSchemaType(schema, schemaType2, allowUndefined = false) {
+      return !schemaType2.length || schemaType2.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st || allowUndefined && typeof schema == "undefined");
     }
     exports.validSchemaType = validSchemaType;
     function validateKeywordUsage({ schema, opts, self, errSchemaPath }, def, keyword) {
@@ -2823,11 +2823,11 @@ var require_validate = __commonJS({
       check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) {
         if (!this.$data)
           return;
-        const { gen, schemaCode, schemaType, def } = this;
+        const { gen, schemaCode, schemaType: schemaType2, def } = this;
         gen.if((0, codegen_1.or)((0, codegen_1._)`${schemaCode} === undefined`, $dataValid));
         if (valid !== codegen_1.nil)
           gen.assign(valid, true);
-        if (schemaType.length || def.validateSchema) {
+        if (schemaType2.length || def.validateSchema) {
           gen.elseIf(this.invalid$data());
           this.$dataError();
           if (valid !== codegen_1.nil)
@@ -2836,13 +2836,13 @@ var require_validate = __commonJS({
         gen.else();
       }
       invalid$data() {
-        const { gen, schemaCode, schemaType, def, it } = this;
+        const { gen, schemaCode, schemaType: schemaType2, def, it } = this;
         return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema());
         function wrong$DataType() {
-          if (schemaType.length) {
+          if (schemaType2.length) {
             if (!(schemaCode instanceof codegen_1.Name))
               throw new Error("ajv implementation error");
-            const st = Array.isArray(schemaType) ? schemaType : [schemaType];
+            const st = Array.isArray(schemaType2) ? schemaType2 : [schemaType2];
             return (0, codegen_1._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`;
           }
           return codegen_1.nil;
@@ -16666,6 +16666,9 @@ function isJsonValue(value) {
     return value.every(isJsonValue);
   return isPlainRecord(value) && Object.values(value).every(isJsonValue);
 }
+function cloneJsonValue(value) {
+  return isJsonValue(value) ? JSON.parse(JSON.stringify(value)) : void 0;
+}
 function cloneJsonObject(value) {
   if (!isPlainRecord(value) || !isJsonValue(value))
     return void 0;
@@ -17978,7 +17981,7 @@ function optionalString(value, path2, issues) {
 
 // ../agent-a2ui-card-contract/dist/esm/resolver.js
 var A2UICardResolverError = class extends Error {
-  constructor(code, message, fieldId) {
+  constructor(code, message, fieldId, expectedType, actualType) {
     super(message);
     Object.defineProperty(this, "code", {
       enumerable: true,
@@ -17992,9 +17995,23 @@ var A2UICardResolverError = class extends Error {
       writable: true,
       value: void 0
     });
+    Object.defineProperty(this, "expectedType", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "actualType", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
     this.name = "A2UICardResolverError";
     this.code = code;
     this.fieldId = fieldId;
+    this.expectedType = expectedType;
+    this.actualType = actualType;
   }
 };
 async function executeA2UICardResolver(input) {
@@ -18014,8 +18031,8 @@ async function executeA2UICardResolver(input) {
     if (!tool) {
       throw new A2UICardResolverError("MCP_TOOL_UNAVAILABLE", `MCP tool ${call.mcpResourceId}/${call.toolName} is unavailable`, fieldId);
     }
-    if (!tool.readOnly || !tool.outputSchema) {
-      throw new A2UICardResolverError("MCP_SCHEMA_UNSUPPORTED", `MCP tool ${call.mcpResourceId}/${call.toolName} is not a read-only structured tool`, fieldId);
+    if (!tool.outputSchema) {
+      throw new A2UICardResolverError("MCP_SCHEMA_UNSUPPORTED", `MCP tool ${call.mcpResourceId}/${call.toolName} has no output schema`, fieldId);
     }
     const args = {};
     for (const binding of call.inputBindings) {
@@ -18042,7 +18059,7 @@ async function executeA2UICardResolver(input) {
   for (const binding of input.resolver.outputBindings) {
     const field = fieldById.get(binding.fieldId);
     const result = results.get(binding.callId);
-    if (!field || !result) {
+    if (!field || result === void 0) {
       throw new A2UICardResolverError("CARD_BINDING_INVALID", `Output binding ${binding.fieldId} is invalid`, binding.fieldId);
     }
     let value;
@@ -18078,7 +18095,7 @@ async function executeA2UICardResolver(input) {
     }
     const value = readJsonPointer(viewModel, field.path);
     if (field.required && value === void 0) {
-      throw new A2UICardResolverError("CARD_REQUIRED_FIELD_MISSING", `Required card field ${field.fieldId} is missing`, field.fieldId);
+      throw new A2UICardResolverError("CARD_REQUIRED_FIELD_MISSING", `Required card field ${field.fieldId} is missing`, field.fieldId, field.type, "missing");
     }
     if (value !== void 0) {
       assertSchemaValue(field.valueSchema, value, "CARD_MAPPING_SCHEMA_MISMATCH", `card field ${field.fieldId}`, field.fieldId);
@@ -18118,8 +18135,8 @@ function normalizeOptionalNulls(value, schema, required) {
 }
 async function executeTool(tool, args, signal, fieldId) {
   const response = await tool.call(args, signal);
-  const structured = cloneJsonObject(response.structuredContent);
-  if (!structured) {
+  const structured = cloneJsonValue(response.structuredContent);
+  if (structured === void 0) {
     throw new A2UICardResolverError("MCP_STRUCTURED_CONTENT_REQUIRED", `MCP tool ${tool.resourceId}/${tool.toolName} did not return structuredContent`, fieldId);
   }
   return structured;
@@ -18133,9 +18150,19 @@ function toolKey(resourceId, toolName) {
 function assertSchemaValue(schema, value, code, label, fieldId) {
   const issues = validateJsonSchemaValue2(schema, value);
   if (issues.length > 0) {
-    throw new A2UICardResolverError(code, `${label} does not match schema at ${issues[0].path}: ${issues[0].message}`, fieldId);
+    throw new A2UICardResolverError(code, `${label} does not match schema at ${issues[0].path}: ${issues[0].message}`, fieldId, schemaType(schema), valueType2(value));
   }
 }
+function schemaType(schema) {
+  return typeof schema.type === "string" ? schema.type : "unknown";
+}
+function valueType2(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  return typeof value === "object" ? "object" : typeof value;
+}
 
 // ../linkque-agent-runtime/dist/esm/core/mcpNaming.js
 import { createHash } from "node:crypto";
@@ -18172,7 +18199,7 @@ async function executeCardPresentation(resource, registry, runtimeContext, args,
       if (!handle) {
         throw new Error(`MCP tool ${call.mcpResourceId}/${call.toolName} is unavailable`);
       }
-      const inputSchema = isJsonObject(handle.inputSchema) ? handle.inputSchema : FALLBACK_OBJECT_SCHEMA;
+      const inputSchema = normalizeMcpInputSchema(handle.inputSchema);
       return {
         resourceId: call.mcpResourceId,
         toolName: call.toolName,
@@ -18182,9 +18209,6 @@ async function executeCardPresentation(resource, registry, runtimeContext, args,
         // ViewModel Schema 校验。
         inputSchema,
         outputSchema: isJsonObject(handle.outputSchema) ? handle.outputSchema : FALLBACK_OBJECT_SCHEMA,
-        // 未声明 readOnlyHint 是旧 MCP 的常见情况；只拒绝明确声明
-        // readOnlyHint=false 的工具。
-        readOnly: handle.readOnly !== false,
         call: async (input, callSignal) => {
           const result = await handle.execute(supplementMcpInput(input, invocation, config.presentationInputSchema, inputSchema), callSignal);
           return { structuredContent: readStructuredContent(result) };
@@ -18233,29 +18257,46 @@ async function executeCardPresentationFromSources(resource, runtimeContext, sour
       transform: binding.transform
     }))
   };
-  const viewModel = await executeA2UICardResolver({
-    resolver,
-    fields: config.fields,
-    presentationInputSchema: {
-      type: "object",
-      properties: {},
-      additionalProperties: false
-    },
-    argsSchema: config.a2uiTemplate.argsSchema,
-    invocation: {},
-    runtimeContext,
-    tools: config.dataSources.filter((source) => sourceResults.has(source.sourceId)).map((source) => ({
-      resourceId: source.mcpResourceId,
-      toolName: source.toolName,
-      inputSchema: FALLBACK_OBJECT_SCHEMA,
-      outputSchema: source.outputSchema ?? FALLBACK_OBJECT_SCHEMA,
-      readOnly: true,
-      call: async () => ({
-        structuredContent: sourceResults.get(source.sourceId)
-      })
-    })),
-    signal
-  });
+  let viewModel;
+  try {
+    viewModel = await executeA2UICardResolver({
+      resolver,
+      fields: config.fields,
+      presentationInputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      argsSchema: config.a2uiTemplate.argsSchema,
+      invocation: {},
+      runtimeContext,
+      tools: config.dataSources.filter((source) => sourceResults.has(source.sourceId)).map((source) => ({
+        resourceId: source.mcpResourceId,
+        toolName: source.toolName,
+        inputSchema: FALLBACK_OBJECT_SCHEMA,
+        outputSchema: source.outputSchema ?? FALLBACK_OBJECT_SCHEMA,
+        call: async () => ({
+          structuredContent: sourceResults.get(source.sourceId)
+        })
+      })),
+      signal
+    });
+  } catch (error) {
+    if (error instanceof A2UICardResolverError) {
+      const binding = config.bindings.find((candidate) => candidate.fieldId === error.fieldId);
+      const field = config.fields.find((candidate) => candidate.fieldId === error.fieldId);
+      throw new CardMappingError({
+        code: error.code,
+        cardId: resource.resourceId,
+        fieldId: error.fieldId ?? "unknown",
+        sourceId: binding?.sourceId ?? "unknown",
+        expectedType: error.expectedType ?? field?.type ?? "unknown",
+        actualType: error.actualType ?? "unknown",
+        retryable: false
+      });
+    }
+    throw error;
+  }
   return createPresentationResult(resource, config, viewModel);
 }
 function createPresentationResult(resource, config, viewModel) {
@@ -18349,23 +18390,44 @@ function compatibleSchemaTypes(source, target) {
 function readStructuredContent(result) {
   if (!isJsonObject(result))
     return void 0;
-  if (isJsonObject(result.structuredContent)) {
-    return JSON.parse(JSON.stringify(result.structuredContent));
+  if (Object.hasOwn(result, "structuredContent") && isJsonValue(result.structuredContent)) {
+    return cloneJsonValue(result.structuredContent);
   }
-  if (!Array.isArray(result.content) || result.content.length !== 1) {
+  if (!Array.isArray(result.content) || result.content.length === 0) {
     return void 0;
   }
-  const [content] = result.content;
-  if (!isJsonObject(content) || content.type !== "text" || typeof content.text !== "string") {
-    return void 0;
+  const texts = [];
+  for (const content of result.content) {
+    if (!isJsonObject(content) || content.type !== "text" || typeof content.text !== "string")
+      return void 0;
+    texts.push(content.text);
   }
+  if (texts.length > 1)
+    return texts.join("\n");
   try {
-    const parsed = JSON.parse(content.text);
-    return isJsonObject(parsed) ? JSON.parse(JSON.stringify(parsed)) : void 0;
+    const parsed = JSON.parse(texts[0]);
+    return isJsonValue(parsed) ? cloneJsonValue(parsed) : texts[0];
   } catch {
-    return void 0;
+    return texts[0];
   }
 }
+function normalizeMcpInputSchema(value) {
+  if (!isJsonObject(value) || getJsonSchemaIssues2(value).length > 0) {
+    return { ...FALLBACK_OBJECT_SCHEMA };
+  }
+  if (value.type === "object" && (!isJsonObject(value.properties) || Object.keys(value.properties).length === 0))
+    return { ...FALLBACK_OBJECT_SCHEMA };
+  return JSON.parse(JSON.stringify(value));
+}
+var CardMappingError = class extends Error {
+  details;
+  retryable = false;
+  constructor(details) {
+    super(JSON.stringify(details));
+    this.name = "CardMappingError";
+    this.details = details;
+  }
+};
 function isJsonObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -18473,11 +18535,9 @@ var McpProxyTool = class {
     const tool = entry.tools.find((t) => t.name === toolName);
     if (!tool)
       return void 0;
-    const annotations = tool.annotations;
     return {
       inputSchema: tool.inputSchema,
       outputSchema: tool.outputSchema,
-      readOnly: annotations?.readOnlyHint,
       execute: (args, sig) => entry.server.callTool(tool.name, args, sig)
     };
   }
@@ -19690,6 +19750,7 @@ function wrapToolWithHooks(tool, dispatcher, commonParams, now = Date.now) {
 
 // ../linkque-agent-runtime/dist/esm/core/hook/noopHookExecutor.js
 var NoopHookExecutor = class {
+  name = "NoopHookExecutor";
   execute(_resource, _context, _options) {
     return Promise.resolve({
       ok: true,
@@ -19808,6 +19869,7 @@ function buildLinkquegwEventBody(context) {
   };
 }
 var LinkquegwEventHookExecutor = class {
+  name = EHookExecutorName.LinkquegwEventHookExecutor;
   baseUrl;
   getAuthHeaders;
   fetchImpl;
@@ -30194,10 +30256,10 @@ function coerceWithJsonSchema(value, schema) {
     nextValue = coerceWithUnionSchema(nextValue, schema.oneOf);
   }
   const schemaTypes = getSchemaTypes(schema);
-  const matchesUnionMember = schemaTypes.length > 1 && schemaTypes.some((schemaType) => matchesJsonType(nextValue, schemaType));
+  const matchesUnionMember = schemaTypes.length > 1 && schemaTypes.some((schemaType2) => matchesJsonType(nextValue, schemaType2));
   if (schemaTypes.length > 0 && !matchesUnionMember) {
-    for (const schemaType of schemaTypes) {
-      const candidate = coercePrimitiveByType(nextValue, schemaType);
+    for (const schemaType2 of schemaTypes) {
+      const candidate = coercePrimitiveByType(nextValue, schemaType2);
       if (candidate !== nextValue) {
         nextValue = candidate;
         break;
@@ -52217,10 +52279,6 @@ ${currentTurn}`;
 }
 
 // ../linkque-agent-runtime/dist/esm/core/cardRenderMcpServer.js
-var FALLBACK_SOURCE_INPUT_SCHEMA = {
-  type: "object",
-  additionalProperties: true
-};
 var CardRenderMcpServer = class {
   resources;
   registry;
@@ -52322,7 +52380,7 @@ Select this card first, then call its card_source tools and card_finish tool.`,
           resourceId: resource.resourceId,
           label: source.purpose,
           description: `Use after selecting ${name}. ${source.purpose}. Choose all MCP arguments from the conversation and prior source results.`,
-          inputSchema: discoveredHandle?.inputSchema ?? FALLBACK_SOURCE_INPUT_SCHEMA,
+          inputSchema: normalizeMcpInputSchema(discoveredHandle?.inputSchema),
           outputSchema: discoveredHandle?.outputSchema ?? source.outputSchema,
           execute: async (args, signal) => {
             if (!state2.selected || this.activeCardId !== resource.resourceId)
@@ -52333,12 +52391,21 @@ Select this card first, then call its card_source tools and card_finish tool.`,
             const handle = discoveredHandle ?? await this.registry.resolve(source.mcpResourceId, source.toolName, signal);
             if (!handle)
               throw new Error(`MCP tool ${source.mcpResourceId}/${source.toolName} is unavailable`);
-            if (handle.readOnly === false)
-              throw new Error(`Card data source ${source.mcpResourceId}/${source.toolName} must be read-only`);
             const result = await handle.execute(args, signal);
             const structured = readStructuredContent(result);
-            if (!structured)
-              throw new Error(`MCP tool ${source.mcpResourceId}/${source.toolName} did not return structured content`);
+            if (structured === void 0) {
+              const binding = config.bindings.find((candidate) => candidate.sourceId === source.sourceId);
+              const field = config.fields.find((candidate) => candidate.fieldId === binding?.fieldId);
+              throw new CardMappingError({
+                code: "MCP_RESULT_UNSUPPORTED",
+                cardId: resource.resourceId,
+                fieldId: binding?.fieldId ?? "unknown",
+                sourceId: source.sourceId,
+                expectedType: field?.type ?? "json",
+                actualType: "mixed-or-empty-content",
+                retryable: false
+              });
+            }
             state2.results.set(source.sourceId, structured);
             return structured;
           }
@@ -52563,6 +52630,92 @@ var NoopKnowledgeSearchPort = class {
   }
 };
 
+// ../linkque-agent-runtime/dist/esm/core/agentRuntimePlugin.js
+var validatePlugins = (plugins) => {
+  const names = /* @__PURE__ */ new Set();
+  for (const plugin of plugins) {
+    const name = plugin.name.trim();
+    if (!name) {
+      throw new Error("Agent runtime \u63D2\u4EF6 name \u4E0D\u80FD\u4E3A\u7A7A");
+    }
+    if (names.has(name)) {
+      throw new Error(`Agent runtime \u63D2\u4EF6 name \u91CD\u590D: ${name}`);
+    }
+    names.add(name);
+  }
+  return plugins;
+};
+function assertAgentConfigRoot(value, pluginName) {
+  if (typeof value !== "object" || value === null || !("agent" in value)) {
+    throw new Error(`Agent runtime \u63D2\u4EF6 ${pluginName} \u7684 modifyAgentConfig \u8FD4\u56DE\u4E86\u65E0\u6548\u914D\u7F6E`);
+  }
+}
+var applyAgentRuntimePluginConfig = (agentConfig, plugins = []) => {
+  const validatedPlugins = validatePlugins(plugins);
+  const modifiers = validatedPlugins.filter((plugin) => plugin.modifyAgentConfig !== void 0);
+  if (modifiers.length === 0)
+    return agentConfig;
+  let current = structuredClone(agentConfig);
+  for (const plugin of modifiers) {
+    try {
+      const modified = plugin.modifyAgentConfig?.(current);
+      if (modified !== void 0) {
+        assertAgentConfigRoot(modified, plugin.name);
+        current = modified;
+      }
+      current = structuredClone(current);
+    } catch (error) {
+      throw new Error(`Agent runtime \u63D2\u4EF6 ${plugin.name} \u4FEE\u6539 Agent Config \u5931\u8D25`, { cause: error });
+    }
+  }
+  return current;
+};
+var MergedHookExecutorHandler = class {
+  executorByName;
+  constructor(executorByName) {
+    this.executorByName = executorByName;
+  }
+  async execute(resource, context, options) {
+    const executor = this.executorByName.get(resource.config.executorName);
+    if (executor)
+      return executor.execute(resource, context, options);
+    return {
+      ok: true,
+      skipped: true,
+      code: "PLUGIN_EXECUTOR_NOT_FOUND",
+      message: `\u672A\u627E\u5230 name=${resource.config.executorName} \u7684 hook executor`
+    };
+  }
+};
+var resolveAgentRuntimeHookExecutor = (plugins = [], portHookExecutorList = [], debugLog) => {
+  const entries = validatePlugins(plugins).flatMap((plugin) => (plugin.hookExecutorList ?? []).map((executor, index2) => ({
+    executor,
+    source: `plugin:${plugin.name}[${index2}]`
+  })));
+  entries.push(...portHookExecutorList.map((executor, index2) => ({
+    executor,
+    source: `ports.hookExecutorList[${index2}]`
+  })));
+  if (entries.length === 0)
+    return void 0;
+  const merged = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const name = entry.executor.name;
+    if (!name.trim())
+      throw new Error(`Hook executor name \u4E0D\u80FD\u4E3A\u7A7A: ${entry.source}`);
+    const previous = merged.get(name);
+    if (previous) {
+      try {
+        debugLog?.(`[hook-executor-merge] name=${name} \u51B2\u7A81: ${previous.source} \u88AB ${entry.source} \u8986\u76D6`, EDebugLogScope.HOOK);
+      } catch {
+      }
+    }
+    merged.set(name, entry);
+  }
+  const executorByName = new Map([...merged].map(([name, entry]) => [name, entry.executor]));
+  return new MergedHookExecutorHandler(executorByName);
+};
+
 // ../linkque-agent-runtime/dist/esm/core/agentRuntime.js
 var DEFAULT_HARNESS_PROMPT = `# Harness \u8FD0\u884C\u89C4\u7EA6
 
@@ -52625,13 +52778,14 @@ var AgentRuntime = class _AgentRuntime {
    * 本 constructor 供单测/noop 调试或需要完全自定义默认的场景。
    */
   constructor(ports = {}) {
+    const mergedHookExecutor = resolveAgentRuntimeHookExecutor(ports.plugins, ports.hookExecutorList, ports.debugLog);
     this.agentLoop = ports.agentLoop ?? new PiAgentLoop(void 0, ports.linkqueBaseUrl);
     this.followUpQuestionGenerator = ports.followUpQuestionGenerator ?? new PiFollowUpQuestionGenerator(ports.linkqueBaseUrl);
     this.sessionManager = ports.sessionManager ?? new InMemorySessionManager();
     this.skillLoader = ports.skillLoader ?? new NoopSkillLoader();
     this.mcpServerProvider = ports.mcpServerProvider ?? new NoopMcpServerProvider();
     this.knowledgeSearchPort = ports.knowledgeSearchPort ?? new NoopKnowledgeSearchPort();
-    this.hookExecutor = ports.hookExecutor ?? new NoopHookExecutor();
+    this.hookExecutor = mergedHookExecutor ?? new NoopHookExecutor();
     this.hookMetricsSink = ports.hookMetricsSink;
     this.portsDebugLog = ports.debugLog;
   }
@@ -52647,31 +52801,32 @@ var AgentRuntime = class _AgentRuntime {
    * @param ports     可选端口覆盖(任一缺省走默认适配器)
    */
   static create(protocol, ports) {
-    const model = protocol.agent.model;
-    const skillResources = protocol.agent.resources.filter((r) => r.resourceType === EResourceType.SKILL);
-    const mcpResources = protocol.agent.resources.filter((r) => r.resourceType === EResourceType.MCP);
-    const mcpToolResources = protocol.agent.resources.filter((r) => r.resourceType === EResourceType.MCP_TOOL);
-    const cardResources = protocol.agent.resources.filter((r) => r.resourceType === EResourceType.CARD);
-    const knowledgeResources = protocol.agent.resources.filter((r) => r.resourceType === EResourceType.KNOWLEDGE);
-    const followUpQuestionGenerationEnabled = protocol.agent.resources.filter((resource) => resource.resourceType === EResourceType.FOLLOW_UP_QUESTIONS).some((resource) => resource.config.enable === true);
-    const mcpServerSpecs = aggregateMcpServers([...mcpResources, ...mcpToolResources], protocol.agentId);
     const portsArg = ports ?? {};
+    const agentConfig = applyAgentRuntimePluginConfig(protocol, portsArg.plugins);
+    const model = agentConfig.agent.model;
+    const skillResources = agentConfig.agent.resources.filter((r) => r.resourceType === EResourceType.SKILL);
+    const mcpResources = agentConfig.agent.resources.filter((r) => r.resourceType === EResourceType.MCP);
+    const mcpToolResources = agentConfig.agent.resources.filter((r) => r.resourceType === EResourceType.MCP_TOOL);
+    const cardResources = agentConfig.agent.resources.filter((r) => r.resourceType === EResourceType.CARD);
+    const knowledgeResources = agentConfig.agent.resources.filter((r) => r.resourceType === EResourceType.KNOWLEDGE);
+    const followUpQuestionGenerationEnabled = agentConfig.agent.resources.filter((resource) => resource.resourceType === EResourceType.FOLLOW_UP_QUESTIONS).some((resource) => resource.config.enable === true);
+    const mcpServerSpecs = aggregateMcpServers([...mcpResources, ...mcpToolResources], agentConfig.agentId);
     const innerProvider = portsArg.mcpServerProvider ?? new NoopMcpServerProvider();
     const rt = new _AgentRuntime({
       ...portsArg,
       mcpServerProvider: new CardRenderMcpServerProvider(innerProvider)
     });
-    rt.defaultSystemPrompt = protocol.agent.systemPrompt.content;
-    rt.defaultHarnessPrompt = protocol.agent.harness ? protocol.agent.harness.systemPrompt : DEFAULT_HARNESS_PROMPT;
+    rt.defaultSystemPrompt = agentConfig.agent.systemPrompt.content;
+    rt.defaultHarnessPrompt = agentConfig.agent.harness ? agentConfig.agent.harness.systemPrompt : DEFAULT_HARNESS_PROMPT;
     rt.defaultModel = model.defaultModel || void 0;
     rt.defaultThinkingLevel = model.callParams?.thinkingLevel;
     rt.skillResources = skillResources;
     rt.mcpServerSpecs = mcpServerSpecs;
     rt.cardResources = cardResources;
     rt.knowledgeResources = knowledgeResources;
-    rt.agentId = protocol.agentId;
+    rt.agentId = agentConfig.agentId;
     rt.followUpQuestionGenerationEnabled = followUpQuestionGenerationEnabled;
-    rt.hookResources = normalizeHookResources(protocol.agent.resources.filter((r) => r.resourceType === EResourceType.HOOK));
+    rt.hookResources = normalizeHookResources(agentConfig.agent.resources.filter((r) => r.resourceType === EResourceType.HOOK));
     return rt;
   }
   async prepareFollowUpQuestionContext(sessionId, history = []) {
@@ -60279,6 +60434,9 @@ function setBakedProtocol(protocol) {
 
 export {
   EResourceType,
+  EResourceProviderType,
+  EHookStage,
+  EHookExecutorName,
   executeHomeData,
   FOLLOW_UP_CONTEXT_MAX_HISTORY_RUNS,
   LinkquegwEventHookExecutor,