@signaliz/sdk 1.0.12 → 1.0.14

package/dist/mcp-config.js

@@ -1222,6 +1222,13 @@ var DEFAULT_CAMPAIGN_BUILDER_BUILT_INS = [
   "email_verification",
   "signals"
 ];
+var CAMPAIGN_BUILDER_BUILT_IN_ROUTE_IDS = {
+  lead_generation: "signaliz-lead-generation",
+  local_leads: "signaliz-local-leads",
+  email_finding: "signaliz-email-finding",
+  email_verification: "signaliz-email-verification",
+  signals: "signaliz-signals"
+};
 var CAMPAIGN_BUILDER_OPERATING_PLAYBOOKS = [
   {
     slug: "cache-first-large-list",
@@ -1710,6 +1717,17 @@ var CampaignBuilderAgent = class {
     }
     return plan;
   }
+  async readiness(request, options = {}) {
+    const plan = await this.createPlan(request, options);
+    return createCampaignBuilderReadiness(plan);
+  }
+  async proof(request, options = {}) {
+    const plan = await this.createPlan(request, options);
+    const result = await this.dryRunPlan(plan, {
+      idempotencyKey: options.idempotencyKey
+    });
+    return createCampaignBuilderProofReceipt(plan, result);
+  }
   async commitPlan(plan, options = {}) {
     const writeMode = options.confirm === true && options.dryRun === false;
     if (writeMode && !options.approvedBy) {
@@ -2070,6 +2088,157 @@ function createCampaignBuilderAgentPlan(request, context = {}) {
     warnings: context.warnings ?? []
   };
 }
+function createCampaignBuilderReadiness(plan) {
+  const lanes = plan.routes.map((route) => createCampaignBuilderReadinessLane(route, plan));
+  const builtInLanes = lanes.filter((lane) => lane.builtIn);
+  const customRoutes = lanes.filter((lane) => lane.customRoute);
+  const strategyMemory = asRecord(plan.strategyMemoryStatus);
+  const deliveryRisk = asRecord(plan.buildRequest.deliveryRisk);
+  const deliveryRiskBlockers = arrayOfStrings(deliveryRisk.blockers) ?? [];
+  const deliveryRiskValue = asRecord(deliveryRisk.risk);
+  const deliveryRiskLevel = stringValue(deliveryRiskValue.risk_level ?? deliveryRiskValue.riskLevel);
+  const memoryReady = !plan.strategyMemoryStatus || strategyMemory.ready !== false;
+  const kernelPlanReady = Object.keys(asRecord(plan.kernelPlan)).length > 0;
+  const deliveryRiskReady = !plan.buildRequest.deliveryRisk || deliveryRiskBlockers.length === 0 && !["high", "critical", "blocked"].includes(String(deliveryRiskLevel ?? "").toLowerCase());
+  const builtInsReady = builtInLanes.length > 0 && builtInLanes.every((lane) => lane.ready);
+  const customRoutesReady = customRoutes.every((lane) => lane.ready);
+  const approvalGatesReady = plan.approvals.length > 0;
+  const gates = [
+    {
+      id: "campaign_plan_created",
+      label: "Campaign plan created",
+      passed: Boolean(plan.planId && plan.mcpFlow.length > 0),
+      detail: plan.planId ? `Plan ${plan.planId} has ${plan.mcpFlow.length} MCP step(s).` : "No campaign-builder plan was created."
+    },
+    {
+      id: "built_in_lanes_ready",
+      label: "Built-in lanes ready",
+      passed: builtInsReady,
+      detail: `${builtInLanes.filter((lane) => lane.ready).length}/${builtInLanes.length} Signaliz built-in lane(s) are present.`
+    },
+    {
+      id: "strategy_memory_ready",
+      label: "Strategy memory ready",
+      passed: memoryReady,
+      detail: plan.strategyMemoryStatus ? "Strategy memory readiness was checked." : "Strategy memory readiness was not requested."
+    },
+    {
+      id: "kernel_plan_attached",
+      label: "Kernel plan attached",
+      passed: kernelPlanReady,
+      detail: kernelPlanReady ? "Kernel planner evidence is attached." : "Kernel planner evidence is not attached."
+    },
+    {
+      id: "delivery_risk_clear",
+      label: "Delivery risk clear",
+      passed: deliveryRiskReady,
+      detail: plan.buildRequest.deliveryRisk ? `Delivery risk is ${deliveryRiskLevel || "available"} with ${deliveryRiskBlockers.length} blocker(s).` : "Delivery risk preflight was not requested."
+    },
+    {
+      id: "custom_routes_prepared",
+      label: "Custom routes prepared",
+      passed: customRoutesReady,
+      detail: customRoutes.length === 0 ? "No BYO routes were requested." : `${customRoutes.filter((lane) => lane.ready).length}/${customRoutes.length} BYO route(s) have read-only setup steps.`
+    },
+    {
+      id: "approval_gates_present",
+      label: "Approval gates present",
+      passed: approvalGatesReady,
+      detail: approvalGatesReady ? `${plan.approvals.length} approval gate(s) are attached.` : "No approval gates are attached."
+    }
+  ];
+  const blockers = [
+    ...gates.filter((gate) => !gate.passed).map((gate) => gate.detail),
+    ...lanes.flatMap((lane) => lane.blockers)
+  ];
+  const score = gates.length === 0 ? 0 : Math.round(gates.filter((gate) => gate.passed).length / gates.length * 100);
+  const ready = blockers.length === 0;
+  return {
+    plan,
+    lanes,
+    gates,
+    summary: {
+      ready,
+      score,
+      targetCount: plan.targetCount,
+      estimatedCredits: plan.estimatedCredits,
+      builtInLanesReady: builtInLanes.filter((lane) => lane.ready).length,
+      builtInLanesTotal: builtInLanes.length,
+      customRoutesReady: customRoutes.filter((lane) => lane.ready).length,
+      customRoutesTotal: customRoutes.length,
+      approvalGateCount: plan.approvals.length,
+      blockers,
+      warnings: plan.warnings
+    },
+    nextActions: campaignReadinessNextActions(plan, ready, customRoutes.length)
+  };
+}
+function createCampaignBuilderProofReceipt(plan, result) {
+  const strategyMemory = asRecord(plan.strategyMemoryStatus);
+  const dryRunResult = asRecord(result);
+  const memoryReady = plan.strategyMemoryStatus ? strategyMemory.ready !== false : false;
+  const dryRunCompleted = dryRunResult.dryRun === true || dryRunResult.dry_run === true || dryRunResult.status === "dry_run";
+  const noLaunch = dryRunCompleted && !dryRunResult.campaignBuildId && !dryRunResult.campaign_build_id;
+  const gates = [
+    {
+      id: "strategy_memory_ready",
+      passed: memoryReady,
+      ready: strategyMemory.ready ?? null,
+      blocker_count: Array.isArray(strategyMemory.blockers) ? strategyMemory.blockers.length : 0
+    },
+    {
+      id: "campaign_plan_ready",
+      passed: Boolean(plan.planId && plan.mcpFlow.length > 0),
+      plan_id: plan.planId,
+      flow_steps: plan.mcpFlow.length
+    },
+    {
+      id: "approval_gates_present",
+      passed: plan.approvals.length > 0,
+      approval_types: plan.approvals.map((approval) => approval.type)
+    },
+    {
+      id: "dry_run_completed",
+      passed: dryRunCompleted,
+      status: dryRunResult.status ?? null,
+      current_phase: dryRunResult.currentPhase ?? dryRunResult.current_phase ?? null
+    },
+    {
+      id: "no_spendful_launch",
+      passed: noLaunch,
+      campaign_build_id: dryRunResult.campaignBuildId ?? dryRunResult.campaign_build_id ?? null
+    }
+  ];
+  return {
+    receipt_version: "campaign-agent-proof.v1",
+    source: "signaliz.campaignBuilderAgent.proof",
+    success: gates.every((gate) => gate.passed),
+    safety: {
+      spendful_tools_called: false,
+      external_writes_called: false,
+      sender_loads_called: false,
+      email_sends_called: false,
+      dry_run_only: true
+    },
+    campaign: {
+      plan_id: plan.planId,
+      campaign_name: plan.campaignName,
+      strategy_template: campaignBuilderProofStrategyTemplate(plan),
+      target_count: plan.targetCount,
+      estimated_credits: plan.estimatedCredits,
+      operating_playbooks: plan.operatingPlaybooks.map((playbook) => playbook.slug)
+    },
+    gates,
+    strategy_memory_status: summarizeCampaignBuilderProofStrategyMemory(strategyMemory),
+    dry_run_result: summarizeCampaignBuilderProofDryRun(dryRunResult),
+    recommended_next_actions: [
+      "Review the plan, approvals, and dry-run result.",
+      "Use campaign-agent commit-plan --confirm-write only after review.",
+      "Use campaign-agent build-approved only with --confirm-launch, approval identity, approval types, and spend limit.",
+      "When an approved build reaches pending_approval, review rows and approve delivery through the Campaigns SDK."
+    ]
+  };
+}
 function getMissingCampaignBuilderApprovals(plan, approval) {
   if (approval.planId !== plan.planId) {
     return plan.approvals;
@@ -3346,6 +3515,137 @@ function campaignReviewRowHasCopy(row) {
     stringValue(data.subject) || stringValue(data.subject_line) || stringValue(data.subjectLine) || stringValue(data.opener) || stringValue(data.body) || stringValue(data.cta) || stringValue(copy.subject) || stringValue(copy.body) || stringValue(rawCopy.subject) || stringValue(rawCopy.body)
   );
 }
+function createCampaignBuilderReadinessLane(route, plan) {
+  const builtIn = campaignBuilderBuiltInForRoute(route);
+  const customRoute = route.provider !== "signaliz" && route.provider !== "csv" && builtIn === void 0;
+  const prepareStep = plan.mcpFlow.find(
+    (step) => step.tool === "gtm_provider_recipe_prepare" && step.arguments.provider_id === route.provider
+  );
+  const activateStep = plan.mcpFlow.find(
+    (step) => step.tool === "gtm_provider_route_activate" && step.arguments.provider_id === route.provider
+  );
+  const readOnlySetup = !customRoute || prepareStep?.readOnly === true && activateStep?.readOnly === true && activateStep.arguments.dry_run === true && activateStep.arguments.confirm === false;
+  const blockers = [
+    customRoute && !prepareStep ? `${route.label ?? route.provider} is missing provider recipe setup.` : void 0,
+    customRoute && !activateStep ? `${route.label ?? route.provider} is missing provider route dry-run setup.` : void 0,
+    customRoute && !readOnlySetup ? `${route.label ?? route.provider} route setup must stay read-only before approval.` : void 0,
+    route.mode === "required" && !route.toolName && customRoute ? `${route.label ?? route.provider} is required but has no tool name.` : void 0
+  ].filter((item) => Boolean(item));
+  return {
+    id: route.id ?? `${route.provider}-${route.layer}`,
+    label: route.label ?? readinessLaneLabel(route, builtIn),
+    layer: route.layer,
+    gtmLayers: gtmLayersForRoute(route),
+    provider: route.provider,
+    toolName: route.toolName,
+    mode: route.mode ?? "if_available",
+    builtIn,
+    approvalRequired: route.approvalRequired === true || plan.approvals.some((approval) => approval.routeId === route.id),
+    customRoute,
+    readOnlySetup,
+    ready: blockers.length === 0,
+    blockers,
+    nextAction: customRoute ? `Review ${route.provider} route setup before launch approval.` : void 0
+  };
+}
+function campaignBuilderBuiltInForRoute(route) {
+  return Object.entries(CAMPAIGN_BUILDER_BUILT_IN_ROUTE_IDS).find(([, routeId]) => route.id === routeId)?.[0];
+}
+function readinessLaneLabel(route, builtIn) {
+  if (builtIn) {
+    const labels = {
+      lead_generation: "Signaliz lead generation",
+      local_leads: "Signaliz local leads",
+      email_finding: "Signaliz email finding",
+      email_verification: "Signaliz email verification",
+      signals: "Signaliz signals"
+    };
+    return labels[builtIn];
+  }
+  return `${route.provider} ${route.layer}`;
+}
+function campaignReadinessNextActions(plan, ready, customRouteCount) {
+  const requestHint = "--request-file campaign-request.json";
+  if (ready) {
+    return [
+      `signaliz campaign-agent proof ${requestHint} --json`,
+      `signaliz campaign-agent commit-plan ${requestHint} --json`,
+      `signaliz campaign-agent build-approved ${requestHint} --confirm-launch --approve-all --approved-by operator@example.com --spend-limit ${plan.estimatedCredits}`
+    ];
+  }
+  const actions = [
+    plan.strategyMemoryStatus && asRecord(plan.strategyMemoryStatus).ready === false ? "signaliz gtm strategy-memory --strategy-template <strategy_template> --include-samples --json" : void 0,
+    customRouteCount > 0 ? "Review BYO provider recipe and route dry-run steps in the readiness packet." : void 0,
+    `signaliz campaign-agent plan ${requestHint} --json`
+  ];
+  return actions.filter((item) => Boolean(item));
+}
+function campaignBuilderProofStrategyTemplate(plan) {
+  const buildRequest = asRecord(plan.buildRequest);
+  const strategyMemory = asRecord(plan.strategyMemoryStatus);
+  const statusTemplate = strategyMemory.strategy_template ?? strategyMemory.strategyTemplate;
+  const statusTemplateRecord = asRecord(statusTemplate);
+  const flowTemplate = plan.mcpFlow.map((step) => asRecord(step.arguments).strategy_template ?? asRecord(step.arguments).strategyTemplate).find((value) => typeof value === "string" && value.trim());
+  return firstNonEmptyString(
+    buildRequest.strategyTemplate,
+    buildRequest.strategy_template,
+    statusTemplate,
+    statusTemplateRecord.slug,
+    statusTemplateRecord.id,
+    flowTemplate
+  );
+}
+function summarizeCampaignBuilderProofStrategyMemory(strategyMemory) {
+  if (Object.keys(strategyMemory).length === 0) return { ready: false };
+  const template = strategyMemory.strategy_template ?? strategyMemory.strategyTemplate;
+  const templateRecord = asRecord(template);
+  const coverage = asRecord(strategyMemory.coverage);
+  const rawSourceGroups = Array.isArray(strategyMemory.source_groups) ? strategyMemory.source_groups : Array.isArray(strategyMemory.sourceGroups) ? strategyMemory.sourceGroups : [];
+  const sourceGroups = rawSourceGroups.map((group) => {
+    const sourceGroup = asRecord(group);
+    return {
+      id: sourceGroup.id ?? null,
+      required: sourceGroup.required ?? null,
+      ready: sourceGroup.ready ?? null,
+      counts: asRecord(sourceGroup.counts)
+    };
+  });
+  return {
+    ready: strategyMemory.ready ?? null,
+    read_only: strategyMemory.read_only ?? strategyMemory.readOnly ?? null,
+    source_tool: firstNonEmptyString(strategyMemory.source_tool, strategyMemory.sourceTool),
+    strategy_template: {
+      slug: firstNonEmptyString(template, templateRecord.slug, templateRecord.id),
+      label: firstNonEmptyString(templateRecord.label)
+    },
+    coverage: {
+      required_groups_ready: coverage.required_groups_ready ?? coverage.requiredGroupsReady ?? null,
+      required_groups_total: coverage.required_groups_total ?? coverage.requiredGroupsTotal ?? null,
+      source_groups_ready: coverage.source_groups_ready ?? coverage.sourceGroupsReady ?? null,
+      source_groups_total: coverage.source_groups_total ?? coverage.sourceGroupsTotal ?? null,
+      knowledge_docs: coverage.knowledge_docs ?? coverage.knowledgeDocs ?? null,
+      memories: coverage.memories ?? null
+    },
+    source_groups: sourceGroups,
+    blocker_count: Array.isArray(strategyMemory.blockers) ? strategyMemory.blockers.length : 0,
+    warning_count: Array.isArray(strategyMemory.warnings) ? strategyMemory.warnings.length : 0
+  };
+}
+function summarizeCampaignBuilderProofDryRun(dryRunResult) {
+  return {
+    dryRun: dryRunResult.dryRun ?? dryRunResult.dry_run ?? null,
+    status: dryRunResult.status ?? null,
+    currentPhase: dryRunResult.currentPhase ?? dryRunResult.current_phase ?? null,
+    campaignBuildId: dryRunResult.campaignBuildId ?? dryRunResult.campaign_build_id ?? null,
+    plannedTargetCount: dryRunResult.plannedTargetCount ?? dryRunResult.planned_target_count ?? null
+  };
+}
+function firstNonEmptyString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return null;
+}
 function diagnosticMessages2(value) {
   if (!Array.isArray(value)) return [];
   return value.map((item) => {

package/dist/mcp-config.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   Signaliz
-} from "./chunk-XJQ6KGNQ.mjs";
+} from "./chunk-EVFQETTN.mjs";
 
 // src/mcp-config.ts
 import * as fs from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaliz/sdk",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "Signaliz SDK — GTM Kernel, Nango routes, MCP, and enrichment for AI agents",
   "main": "dist/index.js",
   "module": "dist/index.mjs",