@daeda/mcp-pro 0.1.43 → 0.1.44

package/dist/index.js

@@ -9383,6 +9383,7 @@ var PipelineStageMetadataSchema = z33.object({
 var PipelineStageDefinitionSchema = z33.object({
   label: z33.string().min(1),
   display_order: z33.number().int(),
+  ref: z33.string().min(1).optional(),
   metadata: PipelineStageMetadataSchema.optional()
 });
 var PipelineDefinitionSchema = z33.object({
@@ -9401,7 +9402,7 @@ var fields7 = [
   { name: "object_type", type: "string", required: true, description: "CRM object type (deals, tickets, or custom object ID)" },
   { name: "label", type: "string", required: true, description: "Pipeline name as displayed in HubSpot" },
   { name: "display_order", type: "number", required: true, description: "Pipeline display order among all pipelines" },
-  { name: "stages", type: "array", required: true, description: "Pipeline stages (at least one required)", itemShape: "{ label: string, display_order: number, metadata?: { probability?: string, ticketState?: string } }" }
+  { name: "stages", type: "array", required: true, description: "Pipeline stages (at least one required)", itemShape: "{ label: string, display_order: number, ref?: string, metadata?: { probability?: string, ticketState?: string } }" }
 ];
 var createPipelineMeta = {
   type: "create_pipeline",
@@ -9417,9 +9418,9 @@ var createPipelineMeta = {
       label: "Enterprise Sales",
       display_order: 1,
       stages: [
-        { label: "Qualified", display_order: 0, metadata: { probability: "0.2" } },
-        { label: "Proposal Sent", display_order: 1, metadata: { probability: "0.5" } },
-        { label: "Closed Won", display_order: 2, metadata: { probability: "1.0" } }
+        { label: "Qualified", display_order: 0, ref: "stage.enterprise_sales.qualified", metadata: { probability: "0.2" } },
+        { label: "Proposal Sent", display_order: 1, ref: "stage.enterprise_sales.proposal_sent", metadata: { probability: "0.5" } },
+        { label: "Closed Won", display_order: 2, ref: "stage.enterprise_sales.closed_won", metadata: { probability: "1.0" } }
       ]
     }
   },
@@ -11695,7 +11696,7 @@ var AssociationSpecSchema = z70.object({
 }).passthrough();
 var StaticValueSchema = z70.object({
   type: z70.literal("STATIC_VALUE"),
-  staticValue: z70.string()
+  staticValue: StringOrPlanRefSchema
 }).passthrough();
 var ObjectPropertyValueSchema = z70.object({
   type: z70.literal("OBJECT_PROPERTY"),
@@ -11799,6 +11800,104 @@ var StaticBranchInputValueSchema = z70.union([
   ObjectPropertyValueSchema,
   FetchedObjectPropertyValueSchema
 ]);
+var hasSourcePattern = (sourceCode, pattern) => pattern.test(sourceCode);
+var collectLiteralOutputFieldKeys = (sourceCode) => {
+  const matches = [...sourceCode.matchAll(/outputFields\s*:\s*\{([\s\S]*?)\}/g)];
+  const keys = /* @__PURE__ */ new Set();
+  for (const match of matches) {
+    const body = match[1] ?? "";
+    for (const keyMatch of body.matchAll(/(?:^|[,{]\s*)(['"]?)([A-Za-z_$][\w$-]*)\1\s*:/g)) {
+      keys.add(keyMatch[2]);
+    }
+  }
+  return [...keys];
+};
+var validateCustomCodeSource = (value, ctx) => {
+  const sourceCode = value.sourceCode;
+  try {
+    new Function(sourceCode);
+  } catch (error) {
+    ctx.addIssue({
+      code: z70.ZodIssueCode.custom,
+      message: `sourceCode must be valid JavaScript: ${error instanceof Error ? error.message : "syntax error"}`,
+      path: ["sourceCode"]
+    });
+    return;
+  }
+  if (!hasSourcePattern(sourceCode, /\b(?:exports|module\.exports)\.main\s*=/)) {
+    ctx.addIssue({
+      code: z70.ZodIssueCode.custom,
+      message: "sourceCode must define exports.main or module.exports.main.",
+      path: ["sourceCode"]
+    });
+  }
+  const hasCallbackContract = hasSourcePattern(sourceCode, /\bcallback\s*\(/);
+  const hasReturnContract = hasSourcePattern(sourceCode, /\breturn\s+(?:await\s+)?\{[\s\S]*?outputFields\s*:/);
+  if (!hasCallbackContract && !hasReturnContract) {
+    ctx.addIssue({
+      code: z70.ZodIssueCode.custom,
+      message: "sourceCode must either call callback(...) or return an object containing outputFields.",
+      path: ["sourceCode"]
+    });
+  }
+  const literalOutputKeys = collectLiteralOutputFieldKeys(sourceCode);
+  const declaredOutputNames = new Set((value.outputFields ?? []).map((field) => field.name));
+  if (declaredOutputNames.size > 0) {
+    for (const field of value.outputFields ?? []) {
+      if (!hasSourcePattern(sourceCode, new RegExp(`\\b${field.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`))) {
+        ctx.addIssue({
+          code: z70.ZodIssueCode.custom,
+          message: `Declared output field '${field.name}' is not referenced in sourceCode.`,
+          path: ["outputFields"]
+        });
+      }
+    }
+  }
+  for (const literalKey of literalOutputKeys) {
+    if (!declaredOutputNames.has(literalKey)) {
+      ctx.addIssue({
+        code: z70.ZodIssueCode.custom,
+        message: `sourceCode emits outputFields.${literalKey} but it is not declared in outputFields.`,
+        path: ["outputFields"]
+      });
+    }
+  }
+  for (const [index, inputField] of (value.inputFields ?? []).entries()) {
+    if (!hasSourcePattern(sourceCode, new RegExp(`\\b${inputField.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`))) {
+      ctx.addIssue({
+        code: z70.ZodIssueCode.custom,
+        message: `Declared input field '${inputField.name}' is not referenced in sourceCode.`,
+        path: ["inputFields", index, "name"]
+      });
+    }
+  }
+  for (const [index, secretName] of (value.secretNames ?? []).entries()) {
+    if (!hasSourcePattern(sourceCode, new RegExp(`\\b${secretName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`))) {
+      ctx.addIssue({
+        code: z70.ZodIssueCode.custom,
+        message: `Declared secret '${secretName}' is not referenced in sourceCode.`,
+        path: ["secretNames", index]
+      });
+    }
+  }
+  const dangerousPatterns = [
+    { pattern: /\beval\s*\(/, message: "sourceCode must not use eval()." },
+    { pattern: /\bFunction\s*\(/, message: "sourceCode must not construct functions dynamically." },
+    { pattern: /\brequire\s*\(\s*['"]child_process['"]\s*\)/, message: "sourceCode must not import child_process." },
+    { pattern: /\bexec(?:Sync)?\s*\(/, message: "sourceCode must not execute shell commands." },
+    { pattern: /\bspawn\s*\(/, message: "sourceCode must not spawn subprocesses." },
+    { pattern: /\bfs\.(?:writeFile|writeFileSync|appendFile|appendFileSync)\s*\(/, message: "sourceCode must not write to the filesystem." }
+  ];
+  for (const { pattern, message } of dangerousPatterns) {
+    if (hasSourcePattern(sourceCode, pattern)) {
+      ctx.addIssue({
+        code: z70.ZodIssueCode.custom,
+        message,
+        path: ["sourceCode"]
+      });
+    }
+  }
+};
 var SingleConnectionActionBaseSchema = z70.object({
   actionId: NonEmptyStringSchema,
   actionTypeVersion: z70.number().int().optional(),
@@ -12072,6 +12171,7 @@ var CustomCodeActionSchema = z70.object({
       });
     }
   }
+  validateCustomCodeSource(value, ctx);
 });
 var WebhookActionSchema = z70.object({
   actionId: NonEmptyStringSchema,
@@ -12664,7 +12764,7 @@ var BUILT_IN_ACTION_TYPES = {
     connectionType: "SINGLE_CONNECTION",
     fields: [
       { name: "secretNames", type: "array", required: false, description: "Optional list of secret names exposed to the runtime." },
-      { name: "sourceCode", type: "string", required: true, description: "Custom code source body." },
+      { name: "sourceCode", type: "string", required: true, description: "Custom code source body. It must be valid JavaScript, define exports.main or module.exports.main, and either call callback(...) or return an object containing outputFields." },
       { name: "runtime", type: "string", required: true, description: "Execution runtime. Harvested corpus currently uses NODE20X." },
       { name: "inputFields", type: "array", required: false, description: "Optional named inputs passed into the custom code runtime. Harvested input variants include OBJECT_PROPERTY, FIELD_DATA, ENROLLMENT_EVENT_PROPERTY, and FETCHED_OBJECT_PROPERTY." },
       { name: "outputFields", type: "array", required: false, description: "Optional declared output fields produced by the custom code action. Output types include NUMBER, DATE, STRING, ENUMERATION, DATETIME, and BOOLEAN. ENUMERATION outputs must include an options array." }
@@ -14619,6 +14719,22 @@ var KNOWN_GUARDRAILS_BY_ACTION_TYPE_ID = {
     {
       code: "ENUM_OUTPUT_OPTIONS_REQUIRED",
       message: "CUSTOM_CODE outputFields with type ENUMERATION must include a non-empty options array."
+    },
+    {
+      code: "EXPORTS_MAIN_REQUIRED",
+      message: "sourceCode must define exports.main or module.exports.main."
+    },
+    {
+      code: "CALLBACK_OR_RETURN_CONTRACT",
+      message: "sourceCode must either call callback(...) or return an object containing outputFields."
+    },
+    {
+      code: "DECLARED_IO_MUST_BE_REFERENCED",
+      message: "Declared inputFields, outputFields, and secretNames should all be referenced in sourceCode."
+    },
+    {
+      code: "DANGEROUS_CONSTRUCTS_REJECTED",
+      message: "sourceCode must not use eval, dynamic Function construction, child_process, shell execution, or filesystem writes."
     }
   ],
   WEBHOOK: [
@@ -18928,7 +19044,7 @@ var projectCreatedPipeline = (ctx, objectType, pipeline2) => {
     label: pipeline2.label,
     displayOrder: pipeline2.displayOrder,
     stages: pipeline2.stages.map((stage, index) => ({
-      id: `created-stage:${index + 1}`,
+      id: stage.id ?? `created-stage:${index + 1}`,
       label: stage.label,
       displayOrder: stage.displayOrder,
       metadata: { ...stage.metadata ?? {} }
@@ -20512,6 +20628,7 @@ var HIGH_STAGE_LIMIT_OBJECTS = /* @__PURE__ */ new Set(["deals", "tickets"]);
 var validateCreatePipeline = (op, index, _ctx) => {
   const issues = [];
   const stageLabels = /* @__PURE__ */ new Set();
+  const stageRefs = /* @__PURE__ */ new Set();
   for (const stage of op.pipeline.stages) {
     if (stageLabels.has(stage.label)) {
       issues.push({
@@ -20522,6 +20639,17 @@ var validateCreatePipeline = (op, index, _ctx) => {
       });
     }
     stageLabels.add(stage.label);
+    if (stage.ref) {
+      if (stageRefs.has(stage.ref)) {
+        issues.push({
+          severity: "error",
+          operation_index: index,
+          code: "DUPLICATE_STAGE_REF",
+          message: `Stage ref '${stage.ref}' is duplicated within the pipeline definition`
+        });
+      }
+      stageRefs.add(stage.ref);
+    }
   }
   if (OBJECTS_WITH_PROBABILITY.has(op.object_type)) {
     for (const stage of op.pipeline.stages) {
@@ -20630,19 +20758,31 @@ var createPipelineHandler = {
   validate: validateCreatePipeline,
   validateEffectful: validateCreatePipelineEffectful,
   preCheck: preCheckCreatePipeline,
-  declarePlanRefs: (op, index, ctx) => declarePlanRef(ctx, {
-    ref: op.ref,
-    sourceOperationIndex: index,
-    kind: "pipeline",
-    primitive: "string",
-    projectedValue: `plan-ref:pipeline:${index + 1}`,
-    objectType: op.object_type
-  }),
+  declarePlanRefs: (op, index, ctx) => [
+    ...declarePlanRef(ctx, {
+      ref: op.ref,
+      sourceOperationIndex: index,
+      kind: "pipeline",
+      primitive: "string",
+      projectedValue: `plan-ref:pipeline:${index + 1}`,
+      objectType: op.object_type
+    }),
+    ...declareIndexedPlanRefs(ctx, {
+      items: op.pipeline.stages,
+      sourceOperationIndex: index,
+      kind: "pipeline_stage",
+      primitive: "string",
+      getRef: (stage) => stage.ref,
+      getProjectedValue: (_stage, itemIndex) => makeSyntheticStringRefValue("pipeline_stage", index, itemIndex),
+      getObjectType: () => op.object_type
+    })
+  ],
   projectValidationState: (op, index, ctx) => projectCreatedPipeline(ctx, op.object_type, {
     id: op.ref ? `plan-ref:pipeline:${index + 1}` : void 0,
     label: op.pipeline.label,
     displayOrder: op.pipeline.display_order,
-    stages: op.pipeline.stages.map((stage) => ({
+    stages: op.pipeline.stages.map((stage, stageIndex) => ({
+      id: stage.ref ? makeSyntheticStringRefValue("pipeline_stage", index, stageIndex) : void 0,
       label: stage.label,
       displayOrder: stage.display_order,
       metadata: stage.metadata
@@ -20671,11 +20811,22 @@ var createPipelineHandler = {
       type: "create_pipeline",
       status: "success",
       records_affected: 1,
-      affected_ids: [result.id]
+      affected_ids: [result.id],
+      outputs: [
+        ...collectSingleOutputRef(op.ref, "pipeline", "string", result.id, op.object_type),
+        ...collectIndexedOutputRefs({
+          items: op.pipeline.stages,
+          values: result.stages.map((stage) => stage.id),
+          kind: "pipeline_stage",
+          primitive: "string",
+          getRef: (stage) => stage.ref,
+          getObjectType: () => op.object_type
+        })
+      ]
     })),
     catchAllToFailed("create_pipeline", index)
   ),
-  collectOutputRefs: (op, _index, result) => collectSingleOutputRef(op.ref, "pipeline", "string", result.affected_ids?.[0], op.object_type),
+  collectOutputRefs: () => [],
   postCheck: (op, index, result) => {
     if (result.status !== "success") return Effect77.succeed([]);
     return pipe59(
@@ -25291,6 +25442,12 @@ var ENUMERATION_INVALID_OPERATORS = /* @__PURE__ */ new Set([
   "IS_EQUAL_TO",
   "IS_NOT_EQUAL_TO"
 ]);
+var ALL_PROPERTY_EXISTENCE_OPERATORS = /* @__PURE__ */ new Set([
+  "IS_KNOWN",
+  "IS_UNKNOWN",
+  "IS_BLANK",
+  "IS_NOT_BLANK"
+]);
 var isCompatibleEnrollmentOperationType = (operationType, expectedOperationType, propertyType) => operationType === expectedOperationType || operationType === "ALL_PROPERTY" || operationType === "TIME_RANGED" && (propertyType === "date" || propertyType === "datetime");
 var collectPropertyFiltersFromBranches = (branches, parentObjectTypeId, parentEventTypeId) => {
   const refs = [];
@@ -25424,6 +25581,15 @@ var validateWorkflowEnrollmentMetadata = (params) => {
       });
       continue;
     }
+    if (propertyDefinition.type === "bool" && filterRef.operationType === "ALL_PROPERTY" && filterRef.operator !== void 0 && !ALL_PROPERTY_EXISTENCE_OPERATORS.has(filterRef.operator)) {
+      add({
+        severity: "error",
+        operation_index: operationIndex,
+        code: "INVALID_ENROLLMENT_FILTER_OPERATION_TYPE",
+        message: `Workflow enrollment filter property '${filterRef.property}' is boolean but uses operator '${filterRef.operator}' with operationType 'ALL_PROPERTY'. Use operationType 'BOOL' for true/false checks, or keep 'ALL_PROPERTY' only for existence operators ${Array.from(ALL_PROPERTY_EXISTENCE_OPERATORS).join(", ")}.`
+      });
+      continue;
+    }
     if (isCompatibleEnrollmentOperationType(filterRef.operationType, expectedOperationType, propertyDefinition.type)) {
       if (propertyDefinition.type === "enumeration" && filterRef.operator !== void 0 && ENUMERATION_INVALID_OPERATORS.has(filterRef.operator)) {
         add({
@@ -25467,6 +25633,12 @@ var ENUMERATION_INVALID_OPERATORS2 = /* @__PURE__ */ new Set([
   "IS_EQUAL_TO",
   "IS_NOT_EQUAL_TO"
 ]);
+var ALL_PROPERTY_EXISTENCE_OPERATORS2 = /* @__PURE__ */ new Set([
+  "IS_KNOWN",
+  "IS_UNKNOWN",
+  "IS_BLANK",
+  "IS_NOT_BLANK"
+]);
 var isCompatibleOperationType = (operationType, expectedOperationType, propertyType) => operationType === expectedOperationType || operationType === "ALL_PROPERTY" || operationType === "TIME_RANGED" && (propertyType === "date" || propertyType === "datetime");
 var validateListBranchFilterNode = (params) => {
   const { actionId, node, path: path6, operationIndex } = params;
@@ -25746,6 +25918,15 @@ var validateWorkflowListBranchMetadata = (params) => {
       });
       continue;
     }
+    if (propertyDefinition.type === "bool" && propertyRef.operationType === "ALL_PROPERTY" && propertyRef.operator !== void 0 && !ALL_PROPERTY_EXISTENCE_OPERATORS2.has(propertyRef.operator)) {
+      add({
+        severity: "error",
+        operation_index: operationIndex,
+        code: "WORKFLOW_LIST_BRANCH_INVALID_FILTER_OPERATION_TYPE",
+        message: `Action '${propertyRef.actionId}' LIST_BRANCH property '${propertyRef.property}' is boolean but uses operator '${propertyRef.operator}' with operationType 'ALL_PROPERTY'. Use operationType 'BOOL' for true/false checks, or keep 'ALL_PROPERTY' only for existence operators ${Array.from(ALL_PROPERTY_EXISTENCE_OPERATORS2).join(", ")}.`
+      });
+      continue;
+    }
     if (!isCompatibleOperationType(propertyRef.operationType, expectedOperationType, propertyDefinition.type)) {
       add({
         severity: "error",
@@ -26471,6 +26652,86 @@ var NUMBER_STRING_FIELD_KINDS = {
   labelToApply: ["association_label"],
   labelToRemove: ["association_label"]
 };
+var LEGACY_PIPELINE_TEMPLATE_PATTERN = /^\s*\{\{\s*pipeline\.[^}]+\}\}\s*$/;
+var WORKFLOW_PROPERTY_TARGET_KINDS = {
+  pipeline: ["pipeline"],
+  dealstage: ["pipeline_stage"],
+  hs_pipeline_stage: ["pipeline_stage"]
+};
+var getWorkflowPropertyTargetKinds = (targetProperty) => targetProperty ? WORKFLOW_PROPERTY_TARGET_KINDS[targetProperty] : void 0;
+var isLegacyPipelineTemplate = (value) => typeof value === "string" && LEGACY_PIPELINE_TEMPLATE_PATTERN.test(value);
+var resolveWorkflowValueSpecForValidation = (valueSpec, params) => {
+  const kinds = getWorkflowPropertyTargetKinds(params.targetProperty);
+  if (!kinds || !valueSpec || typeof valueSpec !== "object") return void 0;
+  const record = valueSpec;
+  const rawStaticValue = record.staticValue;
+  if (isLegacyPipelineTemplate(rawStaticValue)) {
+    return {
+      value: valueSpec,
+      issues: [{
+        severity: "error",
+        operation_index: params.operationIndex,
+        code: "WORKFLOW_LEGACY_PIPELINE_TEMPLATE_UNSUPPORTED",
+        message: `${params.path}.staticValue uses legacy pipeline template syntax; use a typed plan ref instead`
+      }]
+    };
+  }
+  if (!(typeof rawStaticValue === "string" || isPlanRefValue(rawStaticValue))) return void 0;
+  const result = resolveStringFieldForValidation(rawStaticValue, {
+    ctx: params.ctx,
+    operationIndex: params.operationIndex,
+    fieldLabel: `${params.path}.staticValue`,
+    kinds
+  });
+  if (!result.ok) {
+    return {
+      value: valueSpec,
+      issues: result.issues
+    };
+  }
+  return {
+    value: {
+      ...record,
+      staticValue: result.value
+    },
+    issues: []
+  };
+};
+var resolveWorkflowValueSpecForExecution = (valueSpec, params) => {
+  const kinds = getWorkflowPropertyTargetKinds(params.targetProperty);
+  if (!kinds || !valueSpec || typeof valueSpec !== "object") return void 0;
+  const record = valueSpec;
+  const rawStaticValue = record.staticValue;
+  if (isLegacyPipelineTemplate(rawStaticValue)) {
+    return {
+      ok: false,
+      result: {
+        index: params.operationIndex,
+        type: params.operationType,
+        status: "skipped",
+        records_affected: 0,
+        error_code: "WORKFLOW_LEGACY_PIPELINE_TEMPLATE_UNSUPPORTED",
+        error: `${params.path}.staticValue uses legacy pipeline template syntax; use a typed plan ref instead`
+      }
+    };
+  }
+  if (!(typeof rawStaticValue === "string" || isPlanRefValue(rawStaticValue))) return void 0;
+  const result = resolveStringFieldForExecution(rawStaticValue, {
+    ctx: params.ctx,
+    operationIndex: params.operationIndex,
+    operationType: params.operationType,
+    fieldLabel: `${params.path}.staticValue`,
+    kinds
+  });
+  if (!result.ok) return result;
+  return {
+    ok: true,
+    value: {
+      ...record,
+      staticValue: result.value
+    }
+  };
+};
 var resolveNestedForValidation = (value, params) => {
   if (Array.isArray(value)) {
     const issues2 = [];
@@ -26490,6 +26751,30 @@ var resolveNestedForValidation = (value, params) => {
   const record = value;
   const issues = [];
   const next = {};
+  if (typeof record.targetProperty === "string" && "value" in record) {
+    const resolvedValueSpec = resolveWorkflowValueSpecForValidation(record.value, {
+      ctx: params.ctx,
+      operationIndex: params.operationIndex,
+      path: params.path ? `${params.path}.value` : "value",
+      targetProperty: record.targetProperty
+    });
+    if (resolvedValueSpec) {
+      issues.push(...resolvedValueSpec.issues);
+      next.targetProperty = record.targetProperty;
+      next.value = resolvedValueSpec.value;
+      for (const [key, raw] of Object.entries(record)) {
+        if (key === "targetProperty" || key === "value") continue;
+        const path6 = params.path ? `${params.path}.${key}` : key;
+        const nested = resolveNestedForValidation(raw, {
+          ...params,
+          path: path6
+        });
+        issues.push(...nested.issues);
+        next[key] = nested.value;
+      }
+      return { value: next, issues };
+    }
+  }
   for (const [key, raw] of Object.entries(record)) {
     const path6 = params.path ? `${params.path}.${key}` : key;
     if (key in STRING_FIELD_KINDS && (typeof raw === "string" || isPlanRefValue(raw))) {
@@ -26553,6 +26838,31 @@ var resolveNestedForExecution = (value, params) => {
   }
   const record = value;
   const next = {};
+  if (typeof record.targetProperty === "string" && "value" in record) {
+    const resolvedValueSpec = resolveWorkflowValueSpecForExecution(record.value, {
+      ctx: params.ctx,
+      operationIndex: params.operationIndex,
+      operationType: params.operationType,
+      path: params.path ? `${params.path}.value` : "value",
+      targetProperty: record.targetProperty
+    });
+    if (resolvedValueSpec) {
+      if (!resolvedValueSpec.ok) return resolvedValueSpec;
+      next.targetProperty = record.targetProperty;
+      next.value = resolvedValueSpec.value;
+      for (const [key, raw] of Object.entries(record)) {
+        if (key === "targetProperty" || key === "value") continue;
+        const path6 = params.path ? `${params.path}.${key}` : key;
+        const nested = resolveNestedForExecution(raw, {
+          ...params,
+          path: path6
+        });
+        if (!nested.ok) return nested;
+        next[key] = nested.value;
+      }
+      return { ok: true, value: next };
+    }
+  }
   for (const [key, raw] of Object.entries(record)) {
     const path6 = params.path ? `${params.path}.${key}` : key;
     if (key in STRING_FIELD_KINDS && (typeof raw === "string" || isPlanRefValue(raw))) {
@@ -29170,7 +29480,11 @@ var buildDispatcher = (handlers, options2) => {
                           (result) => pipe118(
                             collectOperationOutputRefs(resolved.op, index, result),
                             Effect138.map((outputs) => {
-                              const nextResult = outputs.length > 0 ? { ...result, outputs } : result;
+                              const mergedOutputs = [
+                                ...result.outputs ?? [],
+                                ...outputs
+                              ];
+                              const nextResult = mergedOutputs.length > 0 ? { ...result, outputs: mergedOutputs } : result;
                               if (nextResult.outputs) {
                                 for (const output of nextResult.outputs) {
                                   state.ctx.outputsByRef.set(output.ref, output);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daeda/mcp-pro",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "description": "MCP server for HubSpot CRM — sync, query, and manage your portal data",
   "type": "module",
   "bin": {