@signaliz/sdk 1.0.1 → 1.0.4

package/dist/chunk-EVZZQTWE.mjs

@@ -0,0 +1,4714 @@
+// src/errors.ts
+var SignalizError = class extends Error {
+  constructor(data) {
+    super(data.message);
+    this.name = "SignalizError";
+    this.code = data.code;
+    this.errorType = data.errorType;
+    this.retryAfter = data.retryAfter;
+    this.details = data.details;
+  }
+  get isRetryable() {
+    return this.errorType === "rate_limited" || this.errorType === "timeout" || this.errorType === "provider_error";
+  }
+};
+function parseError(status, body) {
+  if (body?.error && typeof body.error === "object") {
+    return new SignalizError({
+      code: body.error.code || `HTTP_${status}`,
+      message: body.error.message || `Request failed with status ${status}`,
+      errorType: mapErrorType(body.error.code, status),
+      retryAfter: body.error.retry_after,
+      details: body.error.details
+    });
+  }
+  return new SignalizError({
+    code: `HTTP_${status}`,
+    message: body?.message || body?.error || `Request failed with status ${status}`,
+    errorType: mapErrorType(void 0, status)
+  });
+}
+function mapErrorType(code, status) {
+  if (code === "RATE_LIMITED" || status === 429) return "rate_limited";
+  if (code === "VALIDATION_ERROR" || status === 400) return "validation";
+  if (code === "NOT_FOUND" || status === 404) return "not_found";
+  if (code === "AUTH_EXPIRED" || status === 401) return "auth_expired";
+  if (code === "INSUFFICIENT_CREDITS" || status === 402) return "insufficient_credits";
+  if (code === "TIMEOUT" || status === 504) return "timeout";
+  if (status >= 500) return "provider_error";
+  return "unknown";
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.signaliz.com/functions/v1";
+var DEFAULT_TIMEOUT = 12e4;
+var DEFAULT_MAX_RETRIES = 3;
+var HttpClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl?.replace(/\/$/, "") || DEFAULT_BASE_URL;
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.apiKey = config.apiKey;
+    this.clientId = config.clientId;
+    this.clientSecret = config.clientSecret;
+    if (!this.apiKey && !(this.clientId && this.clientSecret)) {
+      throw new Error("Signaliz: provide either apiKey or clientId + clientSecret");
+    }
+  }
+  async request(functionName, body, method = "POST") {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      let timer;
+      try {
+        const token = await this.getToken();
+        const url = new URL(`${this.baseUrl}/${functionName}`);
+        if (method === "GET") {
+          for (const [key, value] of Object.entries(body)) {
+            if (value === void 0 || value === null) continue;
+            url.searchParams.set(key, String(value));
+          }
+        }
+        const controller = new AbortController();
+        timer = setTimeout(() => controller.abort(), this.timeout);
+        const init = {
+          method,
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
+          signal: controller.signal
+        };
+        if (method === "POST") {
+          init.body = JSON.stringify(body);
+        }
+        const res = await fetch(url, init);
+        if (!res.ok) {
+          const errBody = await res.json().catch(() => ({}));
+          const err = parseError(res.status, errBody);
+          if (err.isRetryable && attempt < this.maxRetries) {
+            const wait = err.retryAfter ? err.retryAfter * 1e3 : Math.min(1e3 * Math.pow(2, attempt), 1e4);
+            await sleep(wait);
+            lastError = err;
+            continue;
+          }
+          throw err;
+        }
+        return await res.json();
+      } catch (e) {
+        if (e instanceof SignalizError) throw e;
+        if (e.name === "AbortError") {
+          const timeout = new SignalizError({
+            code: "TIMEOUT",
+            message: `Request timed out after ${this.timeout}ms`,
+            errorType: "timeout"
+          });
+          if (attempt < this.maxRetries) {
+            lastError = timeout;
+            await sleep(1e3 * Math.pow(2, attempt));
+            continue;
+          }
+          throw timeout;
+        }
+        lastError = e;
+        if (attempt < this.maxRetries) {
+          await sleep(1e3 * Math.pow(2, attempt));
+          continue;
+        }
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+    }
+    throw lastError || new Error("Request failed after retries");
+  }
+  /** Convenience wrapper for POST-based edge function calls */
+  async post(functionName, body) {
+    return this.request(functionName, body, "POST");
+  }
+  /** Convenience wrapper for GET-based edge function calls with query params */
+  async get(functionName, query = {}) {
+    return this.request(functionName, query, "GET");
+  }
+  /** JSON-RPC call to the MCP server */
+  async mcp(method, params = {}) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      let timer;
+      try {
+        const token = await this.getToken();
+        const url = `${this.baseUrl}/signaliz-mcp`;
+        const controller = new AbortController();
+        timer = setTimeout(() => controller.abort(), this.timeout);
+        const res = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: Date.now(),
+            method,
+            params: normalizeMcpParams(method, params)
+          }),
+          signal: controller.signal
+        });
+        const text = await res.text();
+        const data = safeJson(text);
+        if (!res.ok) {
+          const err = parseError(res.status, data ?? { message: text });
+          if (err.isRetryable && attempt < this.maxRetries) {
+            lastError = err;
+            await sleep(err.retryAfter ? err.retryAfter * 1e3 : Math.min(1e3 * Math.pow(2, attempt), 1e4));
+            continue;
+          }
+          throw err;
+        }
+        if (!data) {
+          throw new SignalizError({
+            code: "INVALID_JSON",
+            message: "MCP response was not valid JSON",
+            errorType: "provider_error",
+            details: { responseText: text.slice(0, 500) }
+          });
+        }
+        const responseError = isRecord(data) && isRecord(data.error) ? data.error : null;
+        if (responseError) {
+          const err = new SignalizError({
+            code: firstString(responseError.code, isRecord(responseError.data) ? responseError.data.error_code : void 0) || "MCP_ERROR",
+            message: firstString(responseError.message) || "MCP request failed",
+            errorType: mapMcpErrorType(responseError),
+            retryAfter: isRecord(responseError.data) && typeof responseError.data.retry_after === "number" ? responseError.data.retry_after : void 0,
+            details: isRecord(responseError.data) ? responseError.data : void 0
+          });
+          if (err.isRetryable && attempt < this.maxRetries) {
+            lastError = err;
+            await sleep(err.retryAfter ? err.retryAfter * 1e3 : Math.min(1e3 * Math.pow(2, attempt), 1e4));
+            continue;
+          }
+          throw err;
+        }
+        return unwrapMcpResponse(data);
+      } catch (e) {
+        if (e instanceof SignalizError && !e.isRetryable) throw e;
+        if (e.name === "AbortError") {
+          lastError = new SignalizError({
+            code: "TIMEOUT",
+            message: `MCP request timed out after ${this.timeout}ms`,
+            errorType: "timeout"
+          });
+        } else {
+          lastError = e;
+        }
+        if (attempt < this.maxRetries) {
+          await sleep(Math.min(1e3 * Math.pow(2, attempt), 1e4));
+          continue;
+        }
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+    }
+    throw lastError || new Error("MCP request failed after retries");
+  }
+  async getToken() {
+    if (this.apiKey) return this.apiKey;
+    if (this.accessToken) return this.accessToken;
+    const res = await fetch("https://api.signaliz.com/token", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        grant_type: "client_credentials",
+        client_id: this.clientId,
+        client_secret: this.clientSecret
+      })
+    });
+    if (!res.ok) {
+      throw new SignalizError({
+        code: "AUTH_FAILED",
+        message: "Failed to obtain access token",
+        errorType: "auth_expired"
+      });
+    }
+    const data = await res.json();
+    this.accessToken = data.access_token;
+    return this.accessToken;
+  }
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function safeJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function normalizeMcpParams(method, params) {
+  if (method !== "tools/call") return params;
+  const args = params.arguments;
+  if (!args || typeof args !== "object" || Array.isArray(args)) return params;
+  return {
+    ...params,
+    arguments: {
+      output_format: "json",
+      ...args
+    }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function firstString(...values) {
+  const value = values.find((item) => typeof item === "string" && item.length > 0);
+  return typeof value === "string" ? value : void 0;
+}
+function firstPayloadError(payload) {
+  const errors = payload.errors;
+  const first = Array.isArray(errors) ? errors[0] : void 0;
+  return isRecord(first) ? first : {};
+}
+function unwrapMcpResponse(data) {
+  const result = isRecord(data) ? data.result : void 0;
+  if (isRecord(result) && result.structuredContent !== void 0) {
+    return unwrapMcpPayload(result.structuredContent);
+  }
+  const content = isRecord(result) ? result.content : void 0;
+  const firstContent = Array.isArray(content) ? content[0] : void 0;
+  const text = isRecord(firstContent) ? firstContent.text : void 0;
+  if (typeof text === "string") {
+    const parsed = safeJson(text);
+    return unwrapMcpPayload(parsed ?? text);
+  }
+  return unwrapMcpPayload(result);
+}
+function unwrapMcpPayload(payload) {
+  if (isRecord(payload)) {
+    if (payload.ok === true && Object.prototype.hasOwnProperty.call(payload, "result")) {
+      return payload.result;
+    }
+    if (payload.ok === false) {
+      const first = firstPayloadError(payload);
+      const code = firstString(first.code, payload.error_code, payload.code) || (payload.approval_required ? "APPROVAL_REQUIRED" : "MCP_ERROR");
+      throw new SignalizError({
+        code,
+        message: firstString(first.message, payload.message, payload.summary, payload.error) || "MCP request failed",
+        errorType: mapErrorTypeFromCode(code),
+        details: {
+          ...payload,
+          ...isRecord(first.details) ? first.details : {}
+        }
+      });
+    }
+    if (payload.success === true && Object.prototype.hasOwnProperty.call(payload, "data")) {
+      return payload.data;
+    }
+    if (payload.success === false) {
+      const first = firstPayloadError(payload);
+      const code = firstString(first.code, payload.error_code) || (payload.approval_required ? "APPROVAL_REQUIRED" : "MCP_ERROR");
+      throw new SignalizError({
+        code,
+        message: firstString(first.message, payload.message, payload.summary) || "MCP request failed",
+        errorType: mapErrorTypeFromCode(code),
+        details: {
+          ...payload,
+          ...isRecord(first.details) ? first.details : {}
+        }
+      });
+    }
+  }
+  return payload;
+}
+function mapMcpErrorType(error) {
+  const errorRecord = isRecord(error) ? error : {};
+  const data = isRecord(errorRecord.data) ? errorRecord.data : {};
+  const code = String(data.error_code || errorRecord.code || "");
+  const message = String(errorRecord.message || "").toLowerCase();
+  if (code === "429" || message.includes("rate limit")) return "rate_limited";
+  if (code === "401" || code === "AUTH_001" || message.includes("auth")) return "auth_expired";
+  if (code === "400" || code === "-32602" || message.includes("invalid")) return "validation";
+  if (code === "404" || message.includes("not found")) return "not_found";
+  if (message.includes("timeout") || message.includes("timed out")) return "timeout";
+  return "unknown";
+}
+function mapErrorTypeFromCode(code) {
+  if (!code) return "unknown";
+  if (code === "RATE_LIMITED") return "rate_limited";
+  if (code === "INVALID_ARGUMENT" || code === "VALIDATION_ERROR" || code === "VALIDATION_001" || code === "APPROVAL_REQUIRED" || code === "WEBHOOK_APPROVAL_REQUIRED" || code === "TARGET_LIMIT_EXCEEDED") return "validation";
+  if (code === "AUTH_REQUIRED" || code === "AUTH_001") return "auth_expired";
+  if (code === "QUOTA_EXCEEDED") return "insufficient_credits";
+  if (code === "BUILD_NOT_READY" || code === "ARTIFACT_NOT_READY") return "not_found";
+  if (code === "BUILD_FAILED" || code === "INTERNAL_ERROR") return "provider_error";
+  return "unknown";
+}
+
+// src/resources/emails.ts
+var Emails = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Find and verify an email address for a person at a company */
+  async find(params) {
+    const body = {
+      company_domain: params.companyDomain
+    };
+    if (params.fullName) body.full_name = params.fullName;
+    if (params.firstName) body.first_name = params.firstName;
+    if (params.lastName) body.last_name = params.lastName;
+    if (params.linkedinUrl) body.linkedin_url = params.linkedinUrl;
+    if (params.companyName) body.company_name = params.companyName;
+    const data = await this.client.mcp("tools/call", {
+      name: "find_emails_with_verification",
+      arguments: body
+    });
+    return {
+      email: data.email,
+      firstName: data.first_name,
+      lastName: data.last_name,
+      confidence: data.confidence ?? data.confidence_score ?? 0,
+      verificationStatus: data.verification_status ?? "unknown",
+      providerUsed: data.provider_used ?? data.source ?? "unknown"
+    };
+  }
+  /** Verify a single email address */
+  async verify(email) {
+    const data = await this.client.mcp("tools/call", {
+      name: "verify_email",
+      arguments: { email }
+    });
+    return {
+      email: data.email ?? email,
+      isValid: data.is_valid ?? false,
+      isDeliverable: data.is_deliverable ?? false,
+      isCatchAll: data.is_catch_all ?? false,
+      provider: data.provider,
+      confidenceScore: data.confidence_score ?? 0,
+      verificationSource: data.verification_source
+    };
+  }
+  /** Submit up to 5,000 contacts for async find + verify processing. */
+  async findBatch(contacts) {
+    const data = await this.client.mcp("tools/call", {
+      name: "find_and_verify_emails",
+      arguments: {
+        contacts: contacts.map((contact) => ({
+          full_name: contact.fullName,
+          first_name: contact.firstName,
+          last_name: contact.lastName,
+          company_domain: contact.companyDomain,
+          linkedin_url: contact.linkedinUrl,
+          company_name: contact.companyName
+        }))
+      }
+    });
+    return mapBatchJob(data, "find_and_verify_emails");
+  }
+  /** Submit up to 5,000 email addresses for async verification. */
+  async verifyBatch(emails) {
+    const data = await this.client.mcp("tools/call", {
+      name: "verify_emails",
+      arguments: { emails }
+    });
+    return mapBatchJob(data, "verify_emails");
+  }
+  /** Poll a batch email job returned by findBatch or verifyBatch. */
+  async checkStatus(jobId, opts) {
+    return this.client.mcp("tools/call", {
+      name: "check_job_status",
+      arguments: {
+        job_id: jobId,
+        page: opts?.page,
+        page_size: opts?.pageSize,
+        include_partial_results: opts?.includePartialResults
+      }
+    });
+  }
+};
+function mapBatchJob(data, fallbackCapability) {
+  return {
+    jobId: data.job_id,
+    status: data.status,
+    capability: data.capability ?? fallbackCapability,
+    itemsTotal: data.items_total ?? data.total ?? 0,
+    message: data.message ?? "",
+    estimatedTimeSeconds: data.estimated_time_seconds,
+    skippedCount: data.skipped_count,
+    queuePosition: data.queue_position,
+    estimatedStartTime: data.estimated_start_time
+  };
+}
+
+// src/resources/signals.ts
+var Signals = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Enrich a company with actionable signals (V1) */
+  async enrich(params) {
+    const args = {
+      company_name: params.companyName
+    };
+    if (params.domain) args.domain = params.domain;
+    if (params.researchPrompt) args.research_prompt = params.researchPrompt;
+    if (params.signalTypes) args.signal_types = params.signalTypes;
+    const data = await this.client.mcp("tools/call", {
+      name: "enrich_company_signals",
+      arguments: args
+    });
+    return {
+      companyName: data.company_name ?? params.companyName,
+      signals: (data.signals ?? []).map((s) => ({
+        title: s.title,
+        signalType: s.signal_type,
+        confidenceScore: s.confidence_score ?? 0,
+        detectedAt: s.detected_at ?? "",
+        url: s.url,
+        content: s.content ?? ""
+      })),
+      totalSignals: data.total_signals ?? data.signals?.length ?? 0,
+      fromCache: data.from_cache ?? false
+    };
+  }
+  /** Enrich a company with actionable signals (V2 — clean response + online mode) */
+  async enrichV2(params) {
+    const args = {};
+    if (params.companyName) args.company_name = params.companyName;
+    if (params.domain) args.domain = params.domain;
+    if (params.companyDomain) args.company_domain = params.companyDomain;
+    if (params.researchPrompt) args.research_prompt = params.researchPrompt;
+    if (params.signalTypes) args.signal_types = params.signalTypes;
+    if (params.online !== void 0) args.online = params.online;
+    if (params.targetSignalCount) args.target_signal_count = params.targetSignalCount;
+    if (params.lookbackDays) args.lookback_days = params.lookbackDays;
+    if (params.model) args.model = params.model;
+    if (params.enableDeepSearch) args.enable_deep_search = params.enableDeepSearch;
+    if (params.enableOutreachIntelligence) args.enable_outreach_intelligence = params.enableOutreachIntelligence;
+    if (params.enablePredictiveIntelligence) args.enable_predictive_intelligence = params.enablePredictiveIntelligence;
+    if (params.icpId) args.icp_id = params.icpId;
+    if (params.cacheTtlHours !== void 0) args.cache_ttl_hours = params.cacheTtlHours;
+    if (params.skipCache) args.skip_cache = params.skipCache;
+    const data = await this.client.post("company-signal-enrichment-v2", args);
+    return {
+      success: data.success ?? false,
+      company: {
+        name: data.company?.name ?? null,
+        domain: data.company?.domain ?? null
+      },
+      signals: (data.signals ?? []).map((s) => ({
+        id: s.id,
+        title: s.title,
+        type: s.type,
+        content: s.content ?? "",
+        date: s.date ?? null,
+        sourceUrl: s.source_url ?? null,
+        sourceType: s.source_type ?? "unknown",
+        confidence: s.confidence ?? null
+      })),
+      signalCount: data.signal_count ?? 0,
+      intelligence: data.intelligence ? {
+        executiveSummary: data.intelligence.executive_summary ?? null,
+        keyThemes: data.intelligence.key_themes ?? [],
+        relevanceScore: data.intelligence.relevance_score ?? null,
+        outreach: data.intelligence.outreach ? {
+          urgencyScore: data.intelligence.outreach.urgency_score ?? null,
+          bestTiming: data.intelligence.outreach.best_timing ?? null,
+          primaryAngle: data.intelligence.outreach.primary_angle ?? null,
+          ctas: data.intelligence.outreach.ctas ? {
+            soft: data.intelligence.outreach.ctas.soft,
+            direct: data.intelligence.outreach.ctas.direct,
+            valueFirst: data.intelligence.outreach.ctas.value_first
+          } : null,
+          conversationStarters: data.intelligence.outreach.conversation_starters ?? []
+        } : null,
+        predictions: (data.intelligence.predictions ?? []).map((p) => ({
+          prediction: p.prediction,
+          confidence: p.confidence,
+          targetPersona: p.target_persona ?? null,
+          recommendedAction: p.recommended_action ?? null
+        }))
+      } : null,
+      credits: {
+        charged: data.credits?.charged ?? 0,
+        billingType: data.credits?.billing_type ?? "unknown",
+        breakdown: {
+          signalCredits: data.credits?.breakdown?.signal_credits ?? 0,
+          modelCostUsd: data.credits?.breakdown?.model_cost_usd ?? 0,
+          modelCredits: data.credits?.breakdown?.model_credits ?? 0,
+          explanation: data.credits?.breakdown?.explanation ?? ""
+        }
+      },
+      metadata: {
+        version: data.metadata?.version ?? "",
+        model: data.metadata?.model ?? "",
+        online: data.metadata?.online ?? false,
+        processingTimeMs: data.metadata?.processing_time_ms ?? 0
+      }
+    };
+  }
+};
+
+// src/resources/systems.ts
+var Systems = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a new pipeline/system */
+  async create(params) {
+    const data = await this.client.mcp("tools/call", {
+      name: "create_system",
+      arguments: {
+        name: params.name,
+        description: params.description,
+        capabilities: params.capabilities,
+        field_mappings: params.fieldMappings
+      }
+    });
+    return {
+      id: data.system_id ?? data.id,
+      name: data.name ?? params.name,
+      status: data.status ?? "created",
+      nodeCount: data.node_count ?? params.capabilities.length,
+      createdAt: data.created_at ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /** Run a system with input data */
+  async run(systemId, params) {
+    const data = await this.client.mcp("tools/call", {
+      name: "run_system",
+      arguments: {
+        system_id: systemId,
+        input_data: params.data,
+        async: params.async ?? false
+      }
+    });
+    return {
+      runId: data.run_id ?? data.id,
+      status: data.status ?? "running",
+      totalRows: data.total_rows,
+      completedRows: data.completed_rows ?? 0,
+      creditsUsed: data.credits_used ?? 0
+    };
+  }
+  /** Get a system by ID */
+  async get(systemId) {
+    const data = await this.client.mcp("tools/call", {
+      name: "get_system",
+      arguments: { system_id: systemId }
+    });
+    return {
+      id: data.id ?? systemId,
+      name: data.name,
+      status: data.status,
+      nodeCount: data.node_count ?? 0,
+      createdAt: data.created_at
+    };
+  }
+  /** List all systems */
+  async list() {
+    const data = await this.client.mcp("tools/call", {
+      name: "list_systems",
+      arguments: {}
+    });
+    return (data.systems ?? data ?? []).map((s) => ({
+      id: s.id,
+      name: s.name,
+      status: s.status,
+      nodeCount: s.node_count ?? 0,
+      createdAt: s.created_at
+    }));
+  }
+};
+
+// src/resources/runs.ts
+var Runs = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get run status across Trigger, batch, and dataplane runs. */
+  async get(runId) {
+    const data = await this.client.mcp("tools/call", {
+      name: "get_run",
+      arguments: { run_id: runId }
+    });
+    return normalizeRunResult(data, runId);
+  }
+  /** Poll until a run completes. Returns final result. */
+  async waitForCompletion(runId, pollIntervalMs = 2e3) {
+    while (true) {
+      const run = await this.get(runId);
+      if (isTerminalRunStatus(run.status)) {
+        return run;
+      }
+      await new Promise((r) => setTimeout(r, pollIntervalMs));
+    }
+  }
+  /**
+   * Stream run progress as an async iterator.
+   * Usage: for await (const event of signaliz.runs.stream(runId)) { ... }
+   */
+  async *stream(runId, pollIntervalMs = 1500) {
+    let lastCompleted = -1;
+    while (true) {
+      const run = await this.get(runId);
+      const event = {
+        runId,
+        status: run.status,
+        completedRows: run.completedRows ?? 0,
+        totalRows: run.totalRows ?? 0,
+        creditsUsed: run.creditsUsed ?? 0
+      };
+      if (event.completedRows !== lastCompleted) {
+        lastCompleted = event.completedRows;
+        yield event;
+      }
+      if (isTerminalRunStatus(run.status)) {
+        return;
+      }
+      await new Promise((r) => setTimeout(r, pollIntervalMs));
+    }
+  }
+};
+function normalizeRunResult(data, fallbackRunId) {
+  const progress = data?.progress && typeof data.progress === "object" ? data.progress : {};
+  const status = String(data?.status ?? data?.trigger_status ?? "unknown").toLowerCase();
+  const totalRows = numberOrUndefined(
+    data?.total_rows ?? data?.totalRows ?? data?.items_total ?? progress.items_total ?? progress.total ?? data?.results_count
+  );
+  const completedRows = numberOrUndefined(
+    data?.completed_rows ?? data?.completedRows ?? progress.items_completed ?? progress.items_succeeded ?? progress.completed ?? data?.results_count
+  );
+  return {
+    runId: data?.run_id ?? data?.job_id ?? fallbackRunId,
+    status,
+    totalRows,
+    completedRows: completedRows ?? 0,
+    creditsUsed: numberOrUndefined(data?.credits_used ?? data?.creditsUsed ?? data?.credits_consumed) ?? 0,
+    completed: data?.completed ?? isTerminalRunStatus(status),
+    retryEligible: data?.retry_eligible,
+    triggerStatus: data?.trigger_status,
+    output: data?.output ?? data?.results ?? data?.results_preview,
+    error: data?.error ?? data?.error_message,
+    message: data?.message,
+    recoveryGuidance: data?.recovery_guidance,
+    raw: data
+  };
+}
+function numberOrUndefined(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : void 0;
+}
+function isTerminalRunStatus(status) {
+  return [
+    "completed",
+    "failed",
+    "cancelled",
+    "canceled",
+    "crashed",
+    "timed_out",
+    "interrupted",
+    "system_failure"
+  ].includes(String(status || "").toLowerCase());
+}
+
+// src/resources/http.ts
+var Http = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Proxy an HTTP request through Signaliz */
+  async request(params) {
+    const data = await this.client.mcp("tools/call", {
+      name: "http_request",
+      arguments: {
+        url: params.url,
+        method: params.method,
+        headers: params.headers,
+        body: params.body ? JSON.stringify(params.body) : void 0
+      }
+    });
+    return {
+      statusCode: data.status_code ?? data.statusCode ?? 200,
+      headers: data.headers ?? {},
+      body: data.body ?? data.response ?? data
+    };
+  }
+};
+
+// src/resources/campaigns.ts
+var Campaigns = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // ── First-class shorthand API ──────────────────────────────────────────────
+  /**
+   * Start an async Campaign Build.
+   * Returns immediately with a pollable campaign_build_id.
+   *
+   * ```ts
+   * const result = await signaliz.campaigns.build({ name: 'Q3 SaaS', prompt: '...' });
+   * console.log(result.campaignBuildId);
+   * ```
+   */
+  async build(request, options) {
+    return this.buildCampaign(request, options);
+  }
+  /** Scope an agency/client campaign into a markdown brief plus build_campaign dry-run args. */
+  async scope(request) {
+    return this.scopeCampaign(request);
+  }
+  /** Get a concise status snapshot — ideal for polling loops. */
+  async status(campaignBuildId) {
+    return this.getCampaignBuildStatus(campaignBuildId);
+  }
+  /** Get the full campaign build record including delivery details. */
+  async get(campaignBuildId) {
+    const data = await this.callMcp("get_campaign_build", {
+      campaign_build_id: campaignBuildId
+    });
+    return mapStatus(data);
+  }
+  /** Retrieve paginated rows from a completed build. */
+  async rows(campaignBuildId, options) {
+    return this.getCampaignBuildRows(campaignBuildId, options);
+  }
+  /** List all artifacts (CSV exports, etc.) for a build. */
+  async artifacts(campaignBuildId) {
+    return this.listCampaignBuildArtifacts(campaignBuildId);
+  }
+  /** Cancel a queued or running build. */
+  async cancel(campaignBuildId, reason) {
+    return this.cancelCampaignBuild(campaignBuildId, reason);
+  }
+  /**
+   * Poll until a campaign build reaches a terminal status.
+   *
+   * ```ts
+   * const final = await signaliz.campaigns.wait(buildId, {
+   *   onProgress: (s) => console.log(`${s.recordsProcessed}/${s.recordsTotal}`),
+   * });
+   * ```
+   */
+  async wait(campaignBuildId, options) {
+    return this.waitForCompletion(campaignBuildId, {
+      intervalMs: options?.intervalMs,
+      timeoutMs: options?.timeoutMs,
+      onStatus: options?.onProgress
+    });
+  }
+  // ── Full method names (kept for backward-compat) ───────────────────────────
+  async scopeCampaign(request) {
+    const data = await this.callMcp("scope_campaign", scopeArgs(request));
+    return mapScope(data);
+  }
+  async buildCampaign(request, options) {
+    const args = buildArgs(request);
+    if (options?.idempotencyKey) {
+      args.idempotency_key = options.idempotencyKey;
+    }
+    const data = await this.callMcp("build_campaign", args);
+    return {
+      campaignBuildId: data.campaign_build_id ?? null,
+      campaignId: data.campaign_id ?? null,
+      campaignObject: data.campaign_object ?? null,
+      status: data.dry_run ? "dry_run" : data.status ?? "queued",
+      currentPhase: data.dry_run ? "plan" : data.current_phase ?? "acquisition",
+      nextPollAfterSeconds: data.next_poll_after_seconds ?? 10,
+      message: data.message ?? data.summary ?? "",
+      dryRun: data.dry_run === true,
+      requestedTargetCount: data.requested_target_count,
+      plannedTargetCount: data.planned_target_count,
+      estimatedCredits: data.estimated_credits,
+      estimatedDurationSeconds: data.estimated_duration_seconds,
+      targetLimitApplied: data.target_limit_applied,
+      targetLimitReason: data.target_limit_reason,
+      maxSupportedTargetCount: data.max_supported_target_count,
+      brainContext: data.brain_context ?? {},
+      providerRoute: mapProviderRoute(data)
+    };
+  }
+  async getCampaignBuildStatus(campaignBuildId) {
+    const data = await this.callMcp("get_campaign_build_status", {
+      campaign_build_id: campaignBuildId
+    });
+    return mapStatus(data);
+  }
+  async listCampaignBuildArtifacts(campaignBuildId) {
+    const data = await this.callMcp("list_campaign_build_artifacts", {
+      campaign_build_id: campaignBuildId
+    });
+    return (data.artifacts ?? []).map(mapArtifact);
+  }
+  async getCampaignBuildRows(campaignBuildId, options) {
+    const args = { campaign_build_id: campaignBuildId };
+    if (options?.limit) args.page_size = options.limit;
+    if (options?.cursor) args.cursor = options.cursor;
+    const filters = {};
+    if (options?.segment) filters.segment = options.segment;
+    if (options?.rowStatus) filters.row_status = options.rowStatus;
+    if (options?.qualified !== void 0) filters.qualified = options.qualified;
+    if (Object.keys(filters).length > 0) args.filters = filters;
+    const data = await this.callMcp("get_campaign_build_rows", args);
+    return {
+      campaignBuildId: data.campaign_build_id,
+      rows: (data.rows ?? []).map((r, i) => ({
+        index: r.index ?? i,
+        status: r.status ?? r.row_status ?? "unknown",
+        qualified: r.qualified ?? true,
+        segment: r.segment ?? null,
+        data: r.data ?? r
+      })),
+      count: data.count ?? 0,
+      pageSize: data.page_size ?? 50,
+      nextCursor: data.next_cursor ?? null,
+      hasMore: data.has_more ?? false
+    };
+  }
+  async approveCampaignDelivery(campaignBuildId, destinationType, options) {
+    const args = {
+      campaign_build_id: campaignBuildId,
+      destination_type: destinationType
+    };
+    if (options?.destinationId) args.destination_id = options.destinationId;
+    if (options?.destinationConfig) args.destination_config = options.destinationConfig;
+    const data = await this.callMcp("approve_campaign_delivery", args);
+    return {
+      campaignBuildId: data.campaign_build_id,
+      destinationType: data.destination_type ?? destinationType,
+      status: data.status ?? "approved",
+      message: data.message ?? "",
+      deliveryId: data.delivery_id,
+      deliveryIds: data.delivery_ids,
+      approvedCount: data.approved_count
+    };
+  }
+  async cancelCampaignBuild(campaignBuildId, reason) {
+    const data = await this.callMcp("cancel_campaign_build", {
+      campaign_build_id: campaignBuildId,
+      reason: reason ?? "Canceled by user"
+    });
+    return {
+      campaignBuildId: data.campaign_build_id,
+      status: data.status ?? "canceled",
+      reason: data.reason ?? reason ?? "",
+      message: data.message ?? ""
+    };
+  }
+  async waitForCompletion(campaignBuildId, options) {
+    const interval = options?.intervalMs ?? 5e3;
+    const timeout = options?.timeoutMs ?? 6e5;
+    const start = Date.now();
+    while (true) {
+      const s = await this.getCampaignBuildStatus(campaignBuildId);
+      options?.onStatus?.(s);
+      if (["completed", "failed", "canceled"].includes(s.status)) {
+        return s;
+      }
+      if (Date.now() - start > timeout) {
+        throw new Error(`Campaign build ${campaignBuildId} timed out after ${timeout}ms (status: ${s.status})`);
+      }
+      await new Promise((r) => setTimeout(r, interval));
+    }
+  }
+  // ── Internal helpers ─────────────────────────────────────────────────────────
+  async callMcp(tool, args) {
+    return this.client.mcp("tools/call", { name: tool, arguments: args });
+  }
+};
+function mapStatus(data) {
+  return {
+    campaignBuildId: data.campaign_build_id,
+    campaignId: data.campaign_id ?? null,
+    campaignObject: data.campaign_object ?? null,
+    name: data.name,
+    status: data.status,
+    currentPhase: data.current_phase,
+    currentPhaseStatus: data.current_phase_status,
+    phases: data.phases ?? [],
+    recordsTotal: data.records_total ?? 0,
+    recordsProcessed: data.records_processed ?? 0,
+    recordsSucceeded: data.records_succeeded ?? 0,
+    recordsFailed: data.records_failed ?? 0,
+    warnings: data.warnings ?? [],
+    errors: data.errors ?? [],
+    artifactCount: data.artifact_count ?? 0,
+    providerRoute: mapProviderRoute(data),
+    nextAction: data.next_action ?? "",
+    createdAt: data.created_at,
+    updatedAt: data.updated_at,
+    completedAt: data.completed_at
+  };
+}
+function mapProviderRoute(data) {
+  const brainContext = recordOrNull(data?.brain_context);
+  const plan = recordOrNull(data?.provider_route_plan) ?? recordOrNull(brainContext?.provider_route_plan);
+  const summary = recordOrNull(data?.provider_route_summary) ?? recordOrNull(brainContext?.provider_route_summary) ?? recordOrNull(plan?.summary);
+  const blockers = stringArray(data?.provider_route_blockers ?? brainContext?.provider_route_blockers ?? plan?.blockers);
+  const warnings = stringArray(data?.provider_route_warnings ?? brainContext?.provider_route_warnings ?? plan?.warnings);
+  const ready = booleanOrNull(data?.provider_route_ready ?? brainContext?.provider_route_ready ?? plan?.ready);
+  const label = typeof data?.provider_route_label === "string" ? data.provider_route_label : typeof brainContext?.provider_route_label === "string" ? brainContext.provider_route_label : providerRouteLabel(summary, ready);
+  if (!plan && !summary && ready === null && blockers.length === 0 && warnings.length === 0 && !label) {
+    return null;
+  }
+  return {
+    plan,
+    summary,
+    ready,
+    label: label || "attached",
+    blockers,
+    warnings
+  };
+}
+function recordOrNull(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.map((item) => String(item || "").trim()).filter(Boolean) : [];
+}
+function booleanOrNull(value) {
+  return typeof value === "boolean" ? value : null;
+}
+function numberOrNull(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function providerRouteLabel(summary, ready) {
+  if (!summary) return ready === true ? "ready" : ready === false ? "blocked" : "";
+  const totalLayers = numberOrNull(summary.total_layers);
+  const readyLayers = numberOrNull(summary.ready_layers);
+  const customProviderLayers = numberOrNull(summary.custom_provider_layers);
+  const signalizDefaultLayers = numberOrNull(summary.signaliz_default_layers);
+  const fallbackLayers = numberOrNull(summary.fallback_layers);
+  const blockedLayers = numberOrNull(summary.blocked_layers);
+  return [
+    totalLayers === null || readyLayers === null ? ready === true ? "ready" : ready === false ? "blocked" : null : `${readyLayers}/${totalLayers} layers ready`,
+    customProviderLayers !== null ? `${customProviderLayers} custom` : null,
+    signalizDefaultLayers !== null ? `${signalizDefaultLayers} Signaliz default` : null,
+    fallbackLayers !== null ? `${fallbackLayers} fallback` : null,
+    blockedLayers !== null ? `${blockedLayers} blocked` : null
+  ].filter(Boolean).join(", ");
+}
+function mapArtifact(a) {
+  return {
+    id: a.id,
+    campaignBuildId: a.campaign_build_id,
+    artifactType: a.artifact_type,
+    destination: a.destination,
+    storagePath: a.storage_path,
+    signedUrl: a.signed_url,
+    rowCount: a.row_count ?? 0,
+    checksum: a.checksum,
+    metadata: a.metadata ?? {},
+    createdAt: a.created_at
+  };
+}
+function mapScope(data) {
+  return {
+    campaignScopeId: data.campaign_scope_id,
+    clientName: data.client_name,
+    campaignName: data.campaign_name,
+    approach: data.approach,
+    approachLabel: data.approach_label,
+    goal: data.goal,
+    targetCount: data.target_count,
+    icp: data.icp ?? {},
+    personas: data.personas ?? [],
+    sourceStrategy: data.source_strategy ?? [],
+    qualificationPlan: data.qualification_plan ?? [],
+    signalPlan: data.signal_plan ?? [],
+    copyPlan: data.copy_plan ?? {},
+    deliveryPlan: data.delivery_plan ?? {},
+    brainPreflight: data.brain_preflight ?? {},
+    recommendedSignalizTools: data.recommended_signaliz_tools ?? [],
+    buildCampaignArgs: data.build_campaign_args ?? {},
+    mcpFlow: data.mcp_flow ?? [],
+    missingInputs: data.missing_inputs ?? [],
+    estimatedCredits: data.estimated_credits ?? 0,
+    campaignMarkdown: data.campaign_markdown ?? ""
+  };
+}
+function scopeArgs(request) {
+  const args = {
+    prompt: request.prompt
+  };
+  if (request.clientName) args.client_name = request.clientName;
+  if (request.clientContext) args.client_context = request.clientContext;
+  if (request.campaignGoal) args.campaign_goal = request.campaignGoal;
+  if (request.targetCount) args.target_count = request.targetCount;
+  if (request.destinations) args.destinations = request.destinations;
+  if (request.knownAccounts) args.known_accounts = request.knownAccounts;
+  if (request.offers) args.offers = request.offers;
+  if (request.proofPoints) args.proof_points = request.proofPoints;
+  if (request.sourceDocs) args.source_docs = request.sourceDocs;
+  if (request.approvalPolicy) args.approval_policy = request.approvalPolicy;
+  return args;
+}
+function buildArgs(request) {
+  const args = {
+    name: request.name,
+    prompt: request.prompt
+  };
+  if (request.gtmCampaignId) args.gtm_campaign_id = request.gtmCampaignId;
+  if (request.description) args.description = request.description;
+  if (request.targetCount) args.target_count = request.targetCount;
+  if (request.dryRun !== void 0) args.dry_run = request.dryRun;
+  if (request.allowDownscale !== void 0) args.allow_downscale = request.allowDownscale;
+  if (request.confirmSpend !== void 0) args.confirm_spend = request.confirmSpend;
+  if (request.dedupKeys) args.dedup_keys = request.dedupKeys;
+  if (request.brainPreflight) args.brain_preflight = request.brainPreflight;
+  if (request.brainDefaults) args.brain_defaults = request.brainDefaults;
+  if (request.deliveryRisk) args.delivery_risk = request.deliveryRisk;
+  if (request.icp) {
+    args.icp = {
+      personas: request.icp.personas,
+      industries: request.icp.industries,
+      company_sizes: request.icp.companySizes,
+      geographies: request.icp.geographies,
+      keywords: request.icp.keywords,
+      exclusions: request.icp.exclusions,
+      require_verified_email: request.icp.requireVerifiedEmail
+    };
+  }
+  if (request.policy) {
+    args.policy = {
+      max_credits: request.policy.maxCredits,
+      verify_emails: request.policy.verifyEmails,
+      model: request.policy.model
+    };
+  }
+  if (request.signals) {
+    args.signals = {
+      enabled: request.signals.enabled,
+      types: request.signals.types,
+      custom_prompt: request.signals.customPrompt,
+      confidence_threshold: request.signals.confidenceThreshold,
+      lookback_days: request.signals.lookbackDays
+    };
+  }
+  if (request.qualification) {
+    args.qualification = {
+      enabled: request.qualification.enabled,
+      model: request.qualification.model
+    };
+  }
+  if (request.copy) {
+    args.copy = {
+      enabled: request.copy.enabled,
+      tone: request.copy.tone,
+      max_body_words: request.copy.maxBodyWords,
+      sender_context: request.copy.senderContext,
+      offer_context: request.copy.offerContext,
+      model: request.copy.model
+    };
+  }
+  if (request.delivery) {
+    args.delivery = {
+      enabled: request.delivery.enabled,
+      destination_type: request.delivery.destinationType,
+      approval_required: request.delivery.approvalRequired,
+      include_disqualified: request.delivery.includeDisqualified,
+      destination_config: request.delivery.destinationConfig
+    };
+  }
+  if (request.enhancers) {
+    const e = {};
+    if (request.enhancers.clay) {
+      e.clay = {
+        enabled: request.enhancers.clay.enabled,
+        mode: request.enhancers.clay.mode,
+        table_id: request.enhancers.clay.tableId,
+        enrichment_fields: request.enhancers.clay.enrichmentFields,
+        api_key_env: request.enhancers.clay.apiKeyEnv
+      };
+    }
+    if (request.enhancers.octave) {
+      e.octave = {
+        enabled: request.enhancers.octave.enabled,
+        mode: request.enhancers.octave.mode,
+        copy_agent_id: request.enhancers.octave.copyAgentId,
+        qualification_agent_id: request.enhancers.octave.qualificationAgentId,
+        api_key_env: request.enhancers.octave.apiKeyEnv
+      };
+    }
+    args.enhancers = e;
+  }
+  return args;
+}
+
+// src/resources/campaign-builder-agent.ts
+var DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS = {
+  requireVerifiedEmail: true,
+  dedupKeys: ["email", "linkedin_url", "company_domain"],
+  allowDownscale: true,
+  signals: {
+    enabled: true,
+    types: ["funding", "hiring", "technology", "news"],
+    confidenceThreshold: 0.7,
+    lookbackDays: 90
+  },
+  qualification: {
+    enabled: true
+  },
+  copy: {
+    enabled: true,
+    tone: "direct",
+    maxBodyWords: 125
+  },
+  delivery: {
+    enabled: true,
+    destinationType: "json",
+    approvalRequired: true
+  }
+};
+var CampaignBuilderAgent = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async createPlan(request, options = {}) {
+    const warnings = [];
+    const workspaceContext = request.workspaceContext ?? await this.getWorkspaceContext(warnings);
+    const scopeResult = options.scopeCampaign === false ? void 0 : await this.scopeCampaign(request, warnings);
+    if (options.discoverCapabilities !== false) {
+      await this.discoverPlannedRoutes(request, warnings);
+    }
+    return createCampaignBuilderAgentPlan(request, {
+      workspaceContext,
+      scopeBuildArgs: asRecord(scopeResult?.build_campaign_args ?? scopeResult?.buildCampaignArgs),
+      warnings
+    });
+  }
+  async dryRunPlan(plan, options) {
+    let args = buildCampaignArgs({
+      ...plan.buildRequest,
+      dryRun: true,
+      confirmSpend: false
+    });
+    if (plan.buildRequest.gtmCampaignId) {
+      const prepare = await this.callMcp(
+        "gtm_campaign_build_execution_prepare",
+        buildExecutionPrepareArgs(plan.buildRequest, true, false)
+      );
+      const blockers = arrayOfStrings(prepare?.blockers) ?? [];
+      if (prepare?.ready_to_launch === false || blockers.length > 0) {
+        throw new Error(`Campaign builder dry-run prepare is blocked: ${blockers.join(", ") || "not ready to dry run"}`);
+      }
+      const preparedArgs = asRecord(prepare?.build_campaign_arguments ?? prepare?.buildCampaignArguments);
+      if (Object.keys(preparedArgs).length > 0) {
+        args = {
+          ...preparedArgs,
+          dry_run: true,
+          confirm_spend: false
+        };
+      }
+    }
+    if (options?.idempotencyKey) args.idempotency_key = options.idempotencyKey;
+    const data = await this.callMcp("build_campaign", args);
+    return mapBuildResult(data, true);
+  }
+  async buildApprovedPlan(plan, approval, options) {
+    const missing = getMissingCampaignBuilderApprovals(plan, approval);
+    if (missing.length > 0) {
+      throw new Error(`Campaign builder approval is incomplete: ${missing.map((a) => a.label).join(", ")}`);
+    }
+    let args = buildCampaignArgs({
+      ...plan.buildRequest,
+      dryRun: false,
+      confirmSpend: true
+    });
+    if (plan.buildRequest.gtmCampaignId) {
+      const prepare = await this.callMcp(
+        "gtm_campaign_build_execution_prepare",
+        buildExecutionPrepareArgs(plan.buildRequest, false, true)
+      );
+      const blockers = arrayOfStrings(prepare?.blockers) ?? [];
+      if (prepare?.ready_to_launch === false || blockers.length > 0) {
+        throw new Error(`Campaign builder execution prepare is blocked: ${blockers.join(", ") || "not ready to launch"}`);
+      }
+      const preparedArgs = asRecord(prepare?.build_campaign_arguments ?? prepare?.buildCampaignArguments);
+      if (Object.keys(preparedArgs).length > 0) {
+        args = {
+          ...preparedArgs,
+          dry_run: false,
+          confirm_spend: true
+        };
+      }
+    }
+    args.required_approvals = plan.approvals.map((item) => item.id);
+    if (options?.idempotencyKey) args.idempotency_key = options.idempotencyKey;
+    const data = await this.callMcp("build_campaign", args);
+    return mapBuildResult(data, false);
+  }
+  async getWorkspaceContext(warnings) {
+    try {
+      const workspace = await this.callMcp("get_workspace", {});
+      return {
+        workspaceId: stringValue(workspace.workspace_id ?? workspace.id),
+        workspaceName: stringValue(workspace.workspace_name ?? workspace.name),
+        plan: stringValue(workspace.plan ?? workspace.plan_name),
+        creditsRemaining: numberOrUndefined2(workspace.credits_remaining ?? workspace.credit_balance ?? workspace.credits)
+      };
+    } catch (error) {
+      warnings.push(`Workspace context lookup failed: ${errorMessage(error)}`);
+      return {};
+    }
+  }
+  async scopeCampaign(request, warnings) {
+    try {
+      return await this.callMcp("scope_campaign", {
+        prompt: request.goal,
+        client_name: request.clientName,
+        client_context: request.clientContext,
+        campaign_goal: request.goal,
+        target_count: request.targetCount,
+        approval_policy: request.approvalPolicy?.requireHumanApproval ? "human_required" : "standard"
+      });
+    } catch (error) {
+      warnings.push(`Campaign scope lookup failed: ${errorMessage(error)}`);
+      return void 0;
+    }
+  }
+  async discoverPlannedRoutes(request, warnings) {
+    const providers = new Set(
+      [...request.integrations ?? [], ...routesFromCustomerTools(request.customerTools ?? [])].filter((route) => route.provider !== "signaliz").map((route) => route.provider)
+    );
+    for (const provider of providers) {
+      try {
+        await this.callMcp("discover_capabilities", {
+          query: `campaign builder ${provider} ${request.goal}`,
+          category: "campaign"
+        });
+      } catch (error) {
+        warnings.push(`Capability discovery for ${provider} failed: ${errorMessage(error)}`);
+      }
+    }
+  }
+  async callMcp(tool, args) {
+    return this.client.mcp("tools/call", { name: tool, arguments: compact(args) });
+  }
+};
+function createCampaignBuilderAgentPlan(request, context = {}) {
+  const defaults = mergeDefaults(request.signalizDefaults);
+  const targetCount = request.targetCount ?? numberOrUndefined2(context.scopeBuildArgs?.target_count) ?? 100;
+  const campaignName = request.campaignName ?? stringValue(context.scopeBuildArgs?.name) ?? titleFromGoal(request.goal);
+  const workspaceContext = context.workspaceContext ?? request.workspaceContext ?? {};
+  const memory = normalizeMemory(request);
+  const routes = normalizeRoutes(request);
+  const estimatedCredits = estimateCredits(request, defaults, targetCount);
+  const buildRequest = createBuildRequest(request, defaults, targetCount, campaignName, context.scopeBuildArgs, routes, memory, context.scopeBrainPreflight);
+  const brainPreflight = asRecord(buildRequest.brainPreflight);
+  const approvals = deriveApprovals(request, routes, memory, estimatedCredits, defaults.delivery?.approvalRequired !== false);
+  return {
+    planId: `cbp_${hashString(JSON.stringify({ goal: request.goal, campaignName, targetCount, routes }))}`,
+    campaignName,
+    goal: request.goal,
+    targetCount,
+    workspaceContext,
+    memory,
+    defaults: {
+      requireVerifiedEmail: defaults.requireVerifiedEmail,
+      dedupKeys: defaults.dedupKeys,
+      allowDownscale: defaults.allowDownscale
+    },
+    routes,
+    approvals,
+    buildRequest,
+    brainPreflight,
+    mcpFlow: createMcpFlow(request, buildRequest, routes, memory, approvals),
+    estimatedCredits,
+    warnings: context.warnings ?? []
+  };
+}
+function getMissingCampaignBuilderApprovals(plan, approval) {
+  if (approval.planId !== plan.planId) {
+    return plan.approvals;
+  }
+  const approvedTypes = new Set(approval.approvedTypes);
+  const approvedRoutes = new Set(approval.approvedRouteIds ?? []);
+  return plan.approvals.filter((required) => {
+    if (!required.blocking) return false;
+    if (!approvedTypes.has(required.type)) return true;
+    if (required.routeId && !approvedRoutes.has(required.routeId)) return true;
+    if (required.type === "spend" && required.estimatedCredits && approval.spendLimitCredits !== void 0) {
+      return approval.spendLimitCredits < required.estimatedCredits;
+    }
+    return false;
+  });
+}
+function createCampaignBuilderApproval(plan, input) {
+  return {
+    ...input,
+    planId: plan.planId,
+    approvedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function mergeDefaults(overrides) {
+  return {
+    ...DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS,
+    ...overrides,
+    signals: { ...DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS.signals, ...overrides?.signals },
+    qualification: { ...DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS.qualification, ...overrides?.qualification },
+    copy: { ...DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS.copy, ...overrides?.copy },
+    delivery: { ...DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS.delivery, ...overrides?.delivery }
+  };
+}
+function normalizeMemory(request) {
+  const configured = request.memory ?? {};
+  const queries = configured.queries && configured.queries.length > 0 ? configured.queries : [{
+    query: request.goal,
+    scopes: ["workspace", configured.useNetworkPatterns ? "network_patterns" : "operator_notes"],
+    topK: 8,
+    rationale: "Seed the campaign plan with prior ICP, angle, source, and reply-performance patterns."
+  }];
+  return {
+    enabled: configured.enabled !== false,
+    queries,
+    useWorkspaceHistory: configured.useWorkspaceHistory !== false,
+    useNetworkPatterns: configured.useNetworkPatterns === true,
+    privacyMode: configured.privacyMode ?? (configured.useNetworkPatterns ? "anonymized_patterns" : "workspace_only")
+  };
+}
+function normalizeRoutes(request) {
+  const routes = [
+    {
+      id: "signaliz-source",
+      layer: "source",
+      provider: "signaliz",
+      mode: "required",
+      toolName: "generate_leads",
+      rationale: "Use Signaliz fresh workspace acquisition as the default source of truth."
+    },
+    {
+      id: "signaliz-verify",
+      layer: "qualification",
+      provider: "signaliz",
+      mode: "required",
+      toolName: "find_and_verify_emails",
+      rationale: "Require verified contactability before sequence delivery."
+    },
+    {
+      id: "signaliz-signals",
+      layer: "enrichment",
+      provider: "signaliz",
+      mode: "if_available",
+      toolName: "enrich_company_signals",
+      rationale: "Attach current buying signals and evidence for qualification and copy."
+    }
+  ];
+  routes.push(...routesFromCustomerTools(request.customerTools ?? []));
+  routes.push(...request.integrations ?? []);
+  return routes.map((route, index) => ({
+    ...route,
+    id: route.id ?? `${route.provider}-${route.layer}-${index + 1}`,
+    mode: route.mode ?? "if_available"
+  }));
+}
+function routesFromCustomerTools(tools) {
+  return tools.flatMap(
+    (tool) => tool.useForLayers.map((layer) => ({
+      layer,
+      provider: tool.provider,
+      mode: tool.mode ?? "if_available",
+      mcpServerName: tool.mcpServerName,
+      label: tool.label,
+      approvalRequired: tool.approvalRequired,
+      gtmLayers: tool.gtmLayerCapabilities,
+      routingPolicy: tool.routingPolicy,
+      providerCapability: tool.providerCapability,
+      config: {
+        ...tool.config,
+        available_tools: tool.availableTools
+      },
+      rationale: `${tool.label ?? tool.provider} is customer-provided for ${layer}.`
+    }))
+  );
+}
+function createBuildRequest(request, defaults, targetCount, campaignName, scopeBuildArgs, routes = [], memory, scopeBrainPreflight) {
+  const buildRequest = {
+    name: campaignName,
+    prompt: request.goal,
+    description: buildDescription(request),
+    targetCount,
+    dryRun: true,
+    allowDownscale: defaults.allowDownscale,
+    confirmSpend: false,
+    dedupKeys: defaults.dedupKeys,
+    icp: {
+      ...request.icp,
+      geographies: request.icp?.geographies ?? request.constraints?.geographies,
+      exclusions: [...request.icp?.exclusions ?? [], ...request.constraints?.exclusions ?? []],
+      requireVerifiedEmail: request.icp?.requireVerifiedEmail ?? defaults.requireVerifiedEmail
+    },
+    policy: {
+      maxCredits: defaults.maxCredits,
+      verifyEmails: defaults.requireVerifiedEmail
+    },
+    signals: defaults.signals,
+    qualification: defaults.qualification,
+    copy: defaults.copy,
+    delivery: defaults.delivery,
+    enhancers: enhancerConfig(request)
+  };
+  const scoped = asRecord(scopeBuildArgs);
+  buildRequest.gtmCampaignId = request.gtmCampaignId ?? stringValue(scoped.gtm_campaign_id ?? scoped.gtmCampaignId);
+  if (typeof scoped.name === "string") buildRequest.name = scoped.name;
+  if (typeof scoped.prompt === "string") buildRequest.prompt = scoped.prompt;
+  if (typeof scoped.target_count === "number") buildRequest.targetCount = scoped.target_count;
+  const brainDefaults = asRecord(request.brainDefaults ?? scoped.brain_defaults ?? scoped.brainDefaults);
+  if (Object.keys(brainDefaults).length > 0) buildRequest.brainDefaults = brainDefaults;
+  const deliveryRisk = asRecord(request.deliveryRisk ?? scoped.delivery_risk ?? scoped.deliveryRisk);
+  if (Object.keys(deliveryRisk).length > 0) buildRequest.deliveryRisk = deliveryRisk;
+  const scopedBrainPreflight = asRecord(scoped.brain_preflight);
+  const providedBrainPreflight = Object.keys(scopedBrainPreflight).length > 0 ? scopedBrainPreflight : asRecord(scopeBrainPreflight);
+  buildRequest.brainPreflight = Object.keys(providedBrainPreflight).length > 0 ? providedBrainPreflight : createBrainPreflight(request, buildRequest, routes, memory ?? normalizeMemory(request));
+  return buildRequest;
+}
+function createBrainPreflight(request, buildRequest, routes, memory) {
+  const layers = uniqueStrings([
+    "icp",
+    "email_finding",
+    "email_verification",
+    ...routes.flatMap(gtmLayersForRoute),
+    buildRequest.delivery?.destinationType === "webhook" ? "destination_export" : void 0,
+    ["instantly", "smartlead", "heyreach"].some((provider) => routes.some((route) => route.provider === provider)) ? "sender" : void 0,
+    memory.enabled ? "feedback" : void 0
+  ]);
+  const providerChain = uniqueStrings(["signaliz", ...routes.map((route) => route.provider)]);
+  const targetIcp = compact({
+    personas: buildRequest.icp?.personas,
+    industries: buildRequest.icp?.industries,
+    company_sizes: buildRequest.icp?.companySizes,
+    geographies: buildRequest.icp?.geographies,
+    keywords: buildRequest.icp?.keywords,
+    exclusions: buildRequest.icp?.exclusions,
+    require_verified_email: buildRequest.icp?.requireVerifiedEmail
+  });
+  const learningArgs = compact({
+    campaign_brief: request.goal,
+    target_icp: targetIcp,
+    layers,
+    provider_chain: providerChain,
+    lead_source: providerChain[0] ?? "signaliz",
+    include_memory: memory.enabled,
+    include_network: memory.useNetworkPatterns,
+    write_mode: "dry_run",
+    limit: 25
+  });
+  const defaultsArgs = compact({
+    campaign_brief: request.goal,
+    target_icp: targetIcp,
+    layers,
+    include_global: memory.useNetworkPatterns,
+    include_memory: memory.enabled,
+    write_campaign: false,
+    limit: 25
+  });
+  const riskArgs = compact({
+    provider_chain: providerChain,
+    lead_source: providerChain[0] ?? "signaliz",
+    target_icp: targetIcp,
+    include_global: memory.useNetworkPatterns,
+    limit: 25
+  });
+  return {
+    required: true,
+    policy: "Run read-only GTM Brain preflight before build_campaign so learned defaults, memory, and deliverability risk stay attached to the build.",
+    layers,
+    target_icp: targetIcp,
+    provider_chain: providerChain,
+    lead_source: providerChain[0] ?? "signaliz",
+    tool_sequence: [
+      { tool: "gtm_brain_learning_cycle_plan", purpose: "Plan the Brain learning loop for this campaign.", arguments: learningArgs },
+      { tool: "gtm_brain_seed_defaults", purpose: "Seed campaign defaults from workspace memory and safe aggregate patterns.", arguments: defaultsArgs },
+      { tool: "gtm_brain_delivery_risk", purpose: "Check deliverability risk before launch or external writes.", arguments: riskArgs }
+    ]
+  };
+}
+function gtmLayersForBuilderLayer(layer) {
+  const map = {
+    workspace_context: ["customer_data"],
+    memory: ["feedback"],
+    source: ["find_company", "find_people", "lead_generation"],
+    enrichment: ["company_enrichment"],
+    qualification: ["qualification"],
+    copy: ["copy_enrichment"],
+    delivery: ["destination_export"],
+    feedback: ["feedback"],
+    approval: ["approval"]
+  };
+  return map[layer] ?? ["custom"];
+}
+function gtmLayersForRoute(route) {
+  const explicitLayers = uniqueStrings([
+    route.gtmLayer,
+    ...route.gtmLayers ?? [],
+    ...route.providerCapability?.layerCapabilities ?? []
+  ]);
+  return explicitLayers.length > 0 ? explicitLayers : gtmLayersForBuilderLayer(route.layer);
+}
+function enhancerConfig(request) {
+  const routes = [...request.integrations ?? [], ...routesFromCustomerTools(request.customerTools ?? [])];
+  const octave = routes.find((route) => route.provider === "octave");
+  const clay = routes.find((route) => route.provider === "clay_webhook");
+  if (!octave && !clay) return void 0;
+  return {
+    octave: octave ? {
+      enabled: octave.mode !== "disabled",
+      mode: octave.mode === "required" ? "required" : "if_available",
+      copyAgentId: stringValue(octave.config?.copy_agent_id ?? octave.config?.copyAgentId),
+      qualificationAgentId: stringValue(octave.config?.qualification_agent_id ?? octave.config?.qualificationAgentId)
+    } : void 0,
+    clay: clay ? {
+      enabled: clay.mode !== "disabled",
+      mode: clay.mode === "required" ? "required" : "if_available",
+      tableId: stringValue(clay.config?.table_id ?? clay.config?.tableId),
+      enrichmentFields: arrayOfStrings(clay.config?.enrichment_fields ?? clay.config?.enrichmentFields)
+    } : void 0
+  };
+}
+function deriveApprovals(request, routes, memory, estimatedCredits, deliveryApprovalRequired) {
+  const policy = request.approvalPolicy ?? {};
+  const requireFor = new Set(policy.requireApprovalFor ?? ["spend", "external_write", "customer_tool", "delivery", "launch"]);
+  const approvals = [];
+  if (memory.enabled && memory.useNetworkPatterns && requireFor.has("memory_retrieval")) {
+    approvals.push({
+      id: "approval-memory-network",
+      type: "memory_retrieval",
+      label: "Use anonymized network memory",
+      reason: "The plan will consult cross-workspace patterns instead of only private workspace history.",
+      blocking: true
+    });
+  }
+  if (estimatedCredits > (policy.maxCreditsWithoutApproval ?? 0) && requireFor.has("spend")) {
+    approvals.push({
+      id: "approval-spend",
+      type: "spend",
+      label: "Approve campaign spend",
+      reason: `Estimated campaign work may use up to ${estimatedCredits} credits.`,
+      blocking: true,
+      estimatedCredits
+    });
+  }
+  for (const route of routes) {
+    const isCustomerTool = route.provider !== "signaliz";
+    const isWriteLayer = route.layer === "delivery" || route.layer === "feedback";
+    if (isCustomerTool && route.approvalRequired !== false && requireFor.has("customer_tool")) {
+      approvals.push({
+        id: `approval-tool-${route.id}`,
+        type: "customer_tool",
+        label: `Use ${route.label ?? route.provider}`,
+        reason: route.rationale ?? `${route.provider} is part of the campaign plan.`,
+        blocking: route.mode === "required" || policy.requireHumanApproval === true,
+        routeId: route.id,
+        provider: route.provider
+      });
+    }
+    if (isWriteLayer && route.provider !== "csv" && requireFor.has("external_write")) {
+      approvals.push({
+        id: `approval-write-${route.id}`,
+        type: "external_write",
+        label: `Approve ${route.provider} write`,
+        reason: "External delivery, sync, sequencer, or feedback writes must be explicitly approved.",
+        blocking: true,
+        routeId: route.id,
+        provider: route.provider
+      });
+    }
+  }
+  if (deliveryApprovalRequired && requireFor.has("delivery")) {
+    approvals.push({
+      id: "approval-delivery",
+      type: "delivery",
+      label: "Approve delivery destination",
+      reason: "Delivery remains gated until the destination, field map, suppression rules, and send limits are reviewed.",
+      blocking: true
+    });
+  }
+  if (requireFor.has("launch")) {
+    approvals.push({
+      id: "approval-launch",
+      type: "launch",
+      label: "Launch campaign build",
+      reason: "The dry-run plan must be accepted before spendful build execution.",
+      blocking: true
+    });
+  }
+  return dedupeApprovals(approvals);
+}
+function createMcpFlow(request, buildRequest, routes, memory, approvals) {
+  const steps = [
+    {
+      id: "workspace-context",
+      phase: "workspace_context",
+      tool: "get_workspace",
+      arguments: {},
+      readOnly: true,
+      approvalRequired: false
+    }
+  ];
+  if (memory.enabled) {
+    for (const [index, query] of memory.queries.entries()) {
+      steps.push({
+        id: `memory-${index + 1}`,
+        phase: "memory",
+        tool: "gtm_memory_search",
+        arguments: buildGtmMemorySearchArgs(request, routes, query),
+        readOnly: true,
+        approvalRequired: memory.useNetworkPatterns
+      });
+    }
+  }
+  for (const route of routes) {
+    steps.push({
+      id: `route-${route.id}`,
+      phase: route.layer,
+      tool: route.toolName ?? "discover_capabilities",
+      arguments: {
+        provider: route.provider,
+        mcp_server_name: route.mcpServerName,
+        mode: route.mode,
+        config: route.config
+      },
+      readOnly: !["delivery", "feedback"].includes(route.layer),
+      approvalRequired: route.approvalRequired === true || route.layer === "delivery" || route.layer === "feedback"
+    });
+  }
+  steps.push({
+    id: "scope-campaign",
+    phase: "plan",
+    tool: "scope_campaign",
+    arguments: {
+      prompt: request.goal,
+      client_name: request.clientName,
+      client_context: request.clientContext,
+      target_count: request.targetCount
+    },
+    readOnly: true,
+    approvalRequired: false
+  });
+  const brainPreflight = asRecord(buildRequest.brainPreflight);
+  const brainToolSequence = Array.isArray(brainPreflight.tool_sequence) ? brainPreflight.tool_sequence.map((step) => asRecord(step)).filter((step) => typeof step.tool === "string") : [];
+  for (const [index, brainStep] of brainToolSequence.entries()) {
+    steps.push({
+      id: `brain-preflight-${index + 1}`,
+      phase: "plan",
+      tool: String(brainStep.tool),
+      arguments: asRecord(brainStep.arguments),
+      readOnly: true,
+      approvalRequired: memory.useNetworkPatterns === true
+    });
+  }
+  if (buildRequest.gtmCampaignId) {
+    steps.push({
+      id: "dry-run-prepare",
+      phase: "plan",
+      tool: "gtm_campaign_build_execution_prepare",
+      arguments: buildExecutionPrepareArgs(buildRequest, true, false),
+      readOnly: true,
+      approvalRequired: false
+    });
+  }
+  steps.push({
+    id: "dry-run-build",
+    phase: "plan",
+    tool: "build_campaign",
+    arguments: {
+      ...buildCampaignArgs({ ...buildRequest, dryRun: true, confirmSpend: false }),
+      dry_run: true
+    },
+    readOnly: true,
+    approvalRequired: false
+  });
+  if (buildRequest.gtmCampaignId) {
+    steps.push({
+      id: "execution-prepare",
+      phase: "launch",
+      tool: "gtm_campaign_build_execution_prepare",
+      arguments: buildExecutionPrepareArgs(buildRequest, false, true),
+      readOnly: true,
+      approvalRequired: approvals.some((approval) => approval.blocking)
+    });
+  }
+  steps.push({
+    id: "approved-build",
+    phase: "launch",
+    tool: "build_campaign",
+    arguments: {
+      ...buildCampaignArgs({ ...buildRequest, dryRun: false, confirmSpend: true }),
+      required_approvals: approvals.map((approval) => approval.id)
+    },
+    readOnly: false,
+    approvalRequired: approvals.some((approval) => approval.blocking)
+  });
+  return steps.map((step) => ({ ...step, arguments: compact(step.arguments) }));
+}
+function buildGtmMemorySearchArgs(request, routes, query) {
+  const layers = uniqueStrings(routes.flatMap(gtmLayersForRoute));
+  const providerChain = uniqueStrings(routes.map((route) => route.provider));
+  return compact({
+    query: query.query,
+    limit: query.topK,
+    target_icp: request.icp ? buildGtmTargetIcpContext(request.icp) : void 0,
+    layers: layers.length > 0 ? layers : void 0,
+    provider_chain: providerChain.length > 0 ? providerChain : void 0,
+    days: 180
+  });
+}
+function buildGtmTargetIcpContext(icp) {
+  return compact({
+    roles: icp.personas,
+    personas: icp.personas,
+    industries: icp.industries,
+    company_sizes: icp.companySizes,
+    geographies: icp.geographies,
+    keywords: icp.keywords,
+    exclusions: icp.exclusions,
+    require_verified_email: icp.requireVerifiedEmail
+  });
+}
+function buildCampaignArgs(request) {
+  const args = {
+    name: request.name,
+    prompt: request.prompt
+  };
+  if (request.description) args.description = request.description;
+  if (request.targetCount) args.target_count = request.targetCount;
+  if (request.dryRun !== void 0) args.dry_run = request.dryRun;
+  if (request.allowDownscale !== void 0) args.allow_downscale = request.allowDownscale;
+  if (request.confirmSpend !== void 0) args.confirm_spend = request.confirmSpend;
+  if (request.dedupKeys) args.dedup_keys = request.dedupKeys;
+  if (request.brainPreflight) args.brain_preflight = request.brainPreflight;
+  if (request.brainDefaults) args.brain_defaults = request.brainDefaults;
+  if (request.deliveryRisk) args.delivery_risk = request.deliveryRisk;
+  if (request.icp) {
+    args.icp = compact({
+      personas: request.icp.personas,
+      industries: request.icp.industries,
+      company_sizes: request.icp.companySizes,
+      geographies: request.icp.geographies,
+      keywords: request.icp.keywords,
+      exclusions: request.icp.exclusions,
+      require_verified_email: request.icp.requireVerifiedEmail
+    });
+  }
+  if (request.policy) {
+    args.policy = compact({
+      max_credits: request.policy.maxCredits,
+      verify_emails: request.policy.verifyEmails,
+      model: request.policy.model
+    });
+  }
+  if (request.signals) {
+    args.signals = compact({
+      enabled: request.signals.enabled,
+      types: request.signals.types,
+      custom_prompt: request.signals.customPrompt,
+      confidence_threshold: request.signals.confidenceThreshold,
+      lookback_days: request.signals.lookbackDays
+    });
+  }
+  if (request.qualification) {
+    args.qualification = compact({
+      enabled: request.qualification.enabled,
+      model: request.qualification.model
+    });
+  }
+  if (request.copy) {
+    args.copy = compact({
+      enabled: request.copy.enabled,
+      tone: request.copy.tone,
+      max_body_words: request.copy.maxBodyWords,
+      sender_context: request.copy.senderContext,
+      offer_context: request.copy.offerContext,
+      model: request.copy.model
+    });
+  }
+  if (request.delivery) {
+    args.delivery = compact({
+      enabled: request.delivery.enabled,
+      destination_type: request.delivery.destinationType,
+      approval_required: request.delivery.approvalRequired,
+      include_disqualified: request.delivery.includeDisqualified,
+      destination_config: request.delivery.destinationConfig
+    });
+  }
+  if (request.enhancers) {
+    args.enhancers = compact({
+      clay: request.enhancers.clay && compact({
+        enabled: request.enhancers.clay.enabled,
+        mode: request.enhancers.clay.mode,
+        table_id: request.enhancers.clay.tableId,
+        enrichment_fields: request.enhancers.clay.enrichmentFields,
+        api_key_env: request.enhancers.clay.apiKeyEnv
+      }),
+      octave: request.enhancers.octave && compact({
+        enabled: request.enhancers.octave.enabled,
+        mode: request.enhancers.octave.mode,
+        copy_agent_id: request.enhancers.octave.copyAgentId,
+        qualification_agent_id: request.enhancers.octave.qualificationAgentId,
+        api_key_env: request.enhancers.octave.apiKeyEnv
+      })
+    });
+  }
+  return compact(args);
+}
+function buildExecutionPrepareArgs(request, dryRun, confirmSpend) {
+  const buildArgs2 = buildCampaignArgs(request);
+  return compact({
+    campaign_id: request.gtmCampaignId,
+    target_count: buildArgs2.target_count,
+    allow_downscale: buildArgs2.allow_downscale,
+    dry_run: dryRun,
+    confirm_spend: confirmSpend,
+    include_brain_context: true,
+    require_delivery_risk_clearance: true,
+    delivery_risk: buildArgs2.delivery_risk,
+    dedup_keys: buildArgs2.dedup_keys,
+    policy: buildArgs2.policy,
+    signals: buildArgs2.signals,
+    qualification: buildArgs2.qualification,
+    copy: buildArgs2.copy,
+    delivery: buildArgs2.delivery,
+    enhancers: buildArgs2.enhancers
+  });
+}
+function mapBuildResult(data, dryRun) {
+  return {
+    campaignBuildId: data.campaign_build_id ?? null,
+    campaignId: data.campaign_id ?? null,
+    campaignObject: data.campaign_object ?? null,
+    status: dryRun || data.dry_run ? "dry_run" : data.status ?? "queued",
+    currentPhase: dryRun || data.dry_run ? "plan" : data.current_phase ?? "acquisition",
+    nextPollAfterSeconds: data.next_poll_after_seconds ?? 10,
+    message: data.message ?? data.summary ?? "",
+    dryRun: dryRun || data.dry_run === true,
+    requestedTargetCount: data.requested_target_count,
+    plannedTargetCount: data.planned_target_count,
+    estimatedCredits: data.estimated_credits,
+    estimatedDurationSeconds: data.estimated_duration_seconds,
+    targetLimitApplied: data.target_limit_applied,
+    targetLimitReason: data.target_limit_reason,
+    maxSupportedTargetCount: data.max_supported_target_count,
+    brainContext: data.brain_context ?? {},
+    providerRoute: mapProviderRoute2(data)
+  };
+}
+function mapProviderRoute2(data) {
+  const brainContext = asRecord(data?.brain_context);
+  const plan = nullableRecord(data?.provider_route_plan) ?? nullableRecord(brainContext.provider_route_plan);
+  const summary = nullableRecord(data?.provider_route_summary) ?? nullableRecord(brainContext.provider_route_summary) ?? nullableRecord(plan?.summary);
+  const blockers = arrayOfStrings(data?.provider_route_blockers ?? brainContext.provider_route_blockers ?? plan?.blockers) ?? [];
+  const warnings = arrayOfStrings(data?.provider_route_warnings ?? brainContext.provider_route_warnings ?? plan?.warnings) ?? [];
+  const ready = typeof data?.provider_route_ready === "boolean" ? data.provider_route_ready : typeof brainContext.provider_route_ready === "boolean" ? brainContext.provider_route_ready : typeof plan?.ready === "boolean" ? plan.ready : null;
+  const label = typeof data?.provider_route_label === "string" ? data.provider_route_label : typeof brainContext.provider_route_label === "string" ? brainContext.provider_route_label : providerRouteLabel2(summary, ready);
+  if (!plan && !summary && ready === null && blockers.length === 0 && warnings.length === 0 && !label) {
+    return null;
+  }
+  return {
+    plan,
+    summary,
+    ready,
+    label: label || "attached",
+    blockers,
+    warnings
+  };
+}
+function nullableRecord(value) {
+  const record = asRecord(value);
+  return Object.keys(record).length > 0 ? record : null;
+}
+function providerRouteLabel2(summary, ready) {
+  if (!summary) return ready === true ? "ready" : ready === false ? "blocked" : "";
+  const totalLayers = numberOrNull2(summary.total_layers);
+  const readyLayers = numberOrNull2(summary.ready_layers);
+  const customProviderLayers = numberOrNull2(summary.custom_provider_layers);
+  const signalizDefaultLayers = numberOrNull2(summary.signaliz_default_layers);
+  const fallbackLayers = numberOrNull2(summary.fallback_layers);
+  const blockedLayers = numberOrNull2(summary.blocked_layers);
+  return [
+    totalLayers === null || readyLayers === null ? ready === true ? "ready" : ready === false ? "blocked" : null : `${readyLayers}/${totalLayers} layers ready`,
+    customProviderLayers !== null ? `${customProviderLayers} custom` : null,
+    signalizDefaultLayers !== null ? `${signalizDefaultLayers} Signaliz default` : null,
+    fallbackLayers !== null ? `${fallbackLayers} fallback` : null,
+    blockedLayers !== null ? `${blockedLayers} blocked` : null
+  ].filter(Boolean).join(", ");
+}
+function numberOrNull2(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function estimateCredits(request, defaults, targetCount) {
+  if (typeof defaults.maxCredits === "number") return defaults.maxCredits;
+  const signalCredits = defaults.signals?.enabled === false ? 0 : targetCount * 2;
+  const copyCredits = defaults.copy?.enabled === false ? 0 : targetCount;
+  const requiredCustomerToolPremium = [...request.integrations ?? [], ...routesFromCustomerTools(request.customerTools ?? [])].filter((route) => route.mode === "required" && ["octave", "ai_ark", "clay_webhook"].includes(route.provider)).length * Math.ceil(targetCount / 25);
+  return signalCredits + copyCredits + requiredCustomerToolPremium;
+}
+function buildDescription(request) {
+  const parts = [
+    request.clientName ? `Client: ${request.clientName}` : void 0,
+    request.clientContext ? `Context: ${request.clientContext}` : void 0,
+    request.constraints?.deliverabilityNotes?.length ? `Deliverability: ${request.constraints.deliverabilityNotes.join("; ")}` : void 0,
+    "Agent-built campaign plan layered on Signaliz kernel and existing MCP tools."
+  ];
+  return parts.filter(Boolean).join("\n");
+}
+function dedupeApprovals(approvals) {
+  const seen = /* @__PURE__ */ new Set();
+  return approvals.filter((approval) => {
+    const key = `${approval.type}:${approval.routeId ?? approval.provider ?? approval.id}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function compact(record) {
+  return Object.fromEntries(
+    Object.entries(record).filter(([, value]) => value !== void 0 && value !== null && value !== "")
+  );
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberOrUndefined2(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function arrayOfStrings(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : void 0;
+}
+function uniqueStrings(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    if (!value) continue;
+    const key = value.trim();
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push(key);
+  }
+  return out;
+}
+function titleFromGoal(goal) {
+  const words = goal.replace(/[^a-zA-Z0-9 ]/g, " ").trim().split(/\s+/).slice(0, 7);
+  return words.length > 0 ? words.map((word) => word[0]?.toUpperCase() + word.slice(1)).join(" ") : "Agent Built Campaign";
+}
+function hashString(input) {
+  let hash = 0;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) - hash + input.charCodeAt(i) | 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/resources/icps.ts
+var Icps = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List all ICPs in the workspace */
+  async list(opts) {
+    const data = await this.client.mcp("tools/call", {
+      name: "list_icps",
+      arguments: {
+        include_source_playbook_data: opts?.includeSourcePlaybookData ?? opts?.includeOctaveData ?? false
+      }
+    });
+    return data.icps ?? [];
+  }
+  /** Get full ICP details by ID */
+  async get(icpId) {
+    return this.client.mcp("tools/call", {
+      name: "get_icp",
+      arguments: { icp_id: icpId }
+    });
+  }
+  /** Import connected source playbooks as ICPs */
+  async importFromPlaybooks(playbookIds) {
+    return this.client.mcp("tools/call", {
+      name: "import_icps_from_playbooks",
+      arguments: playbookIds?.length ? { playbook_ids: playbookIds } : {}
+    });
+  }
+  /** @deprecated Use importFromPlaybooks. */
+  async importFromOctave(playbookIds) {
+    return this.importFromPlaybooks(playbookIds);
+  }
+};
+
+// src/resources/leads.ts
+var Leads = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Generate B2B leads from a natural-language prompt.
+   * Returns a job_id — poll with `runs.get(jobId)` or `check_job_status`.
+   */
+  async generate(params) {
+    const data = await this.client.mcp("tools/call", {
+      name: "generate_leads",
+      arguments: {
+        prompt: params.prompt,
+        max_leads: params.maxLeads,
+        verify_emails: params.verifyEmails,
+        file_name: params.fileName,
+        model: params.model,
+        company_domains: params.companyDomains,
+        completeness_mode: params.completenessMode,
+        lookalike_expansion: params.lookalikeExpansion,
+        confirm_spend: params.confirmSpend
+      }
+    });
+    return mapJobResult(data);
+  }
+  /**
+   * Generate local business leads via Google Maps + email scraping.
+   * Returns a job_id — poll with `runs.get(jobId)` or `check_job_status`.
+   */
+  async generateLocal(params) {
+    const data = await this.client.mcp("tools/call", {
+      name: "generate_local_leads",
+      arguments: {
+        prompt: params.prompt,
+        target_verified: params.targetVerified ?? params.maxLeads,
+        verify_emails: params.verifyEmails,
+        file_name: params.fileName,
+        confirm_spend: params.confirmSpend
+      }
+    });
+    return mapJobResult(data);
+  }
+  /**
+   * List curated native GTM data sources with data-cost guardrails.
+   */
+  async listNativeGtmCapabilities(category) {
+    const data = await this.client.mcp("tools/call", {
+      name: "list_native_gtm_capabilities",
+      arguments: category ? { category } : {}
+    });
+    return data.capabilities ?? [];
+  }
+  /**
+   * Run a curated native GTM capability. Returns a job_id; poll with `runs.get(jobId)`
+   * or `checkStatus(jobId)`.
+   */
+  async runNativeGtmCapability(params) {
+    const data = await this.client.mcp("tools/call", {
+      name: "run_native_gtm_capability",
+      arguments: {
+        capability: params.capability,
+        query: params.query,
+        urls: params.urls,
+        place_ids: params.placeIds,
+        max_results: params.maxResults,
+        mode: params.mode,
+        since: params.since,
+        location: params.location,
+        country_code: params.countryCode,
+        confirm_spend: params.confirmSpend
+      }
+    });
+    return mapJobResult(data);
+  }
+  /**
+   * Free-text router: pass an intent like "pull youtube subscribers of @joshwhitfieldai"
+   * and get back the top GTM capability matches with suggested args ready to run.
+   */
+  async findGtmCapability(intent) {
+    const data = await this.client.mcp("tools/call", {
+      name: "find_gtm_capability",
+      arguments: { intent }
+    });
+    return { matches: data.matches ?? [], intent: data.intent ?? intent };
+  }
+  /**
+   * Check the status of a lead generation job.
+   */
+  async checkStatus(jobId) {
+    return this.client.mcp("tools/call", {
+      name: "check_job_status",
+      arguments: { job_id: jobId }
+    });
+  }
+};
+function mapJobResult(data) {
+  return {
+    jobId: data.job_id,
+    status: data.status,
+    capability: data.capability,
+    prompt: data.prompt,
+    source: data.source,
+    targetVerified: data.target_verified,
+    maxLeads: data.max_leads ?? data.max_results,
+    verifyEmails: data.verify_emails ?? false,
+    message: data.message,
+    estimatedTimeSeconds: data.estimated_time_seconds
+  };
+}
+
+// src/resources/execution-reference.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var PREFIXED_RE = /^(op|routine|tick|routine_tick|trigger|trigger_run|run|dataplane|dataplane_run|queue|queue_job|job|event|execution_event|replay|replay_run):(.+)$/i;
+var FIELD_KIND_MAP = {
+  op_id: "op",
+  opId: "op",
+  routine_id: "routine",
+  routineId: "routine",
+  tick_id: "routine_tick",
+  tickId: "routine_tick",
+  routineTickId: "routine_tick",
+  run_id: "trigger_run",
+  runId: "trigger_run",
+  trigger_run_id: "trigger_run",
+  triggerRunId: "trigger_run",
+  dataplane_run_id: "dataplane_run",
+  dataplaneRunId: "dataplane_run",
+  job_id: "queue_job",
+  jobId: "queue_job",
+  queue_job_id: "queue_job",
+  queueJobId: "queue_job",
+  execution_event_id: "execution_event",
+  executionEventId: "execution_event",
+  event_id: "execution_event",
+  eventId: "execution_event",
+  replay_run_id: "replay_run",
+  replayRunId: "replay_run"
+};
+var PREFIX_KIND_MAP = {
+  op: "op",
+  routine: "routine",
+  tick: "routine_tick",
+  routine_tick: "routine_tick",
+  trigger: "trigger_run",
+  trigger_run: "trigger_run",
+  run: "trigger_run",
+  dataplane: "dataplane_run",
+  dataplane_run: "dataplane_run",
+  queue: "queue_job",
+  queue_job: "queue_job",
+  job: "queue_job",
+  event: "execution_event",
+  execution_event: "execution_event",
+  replay: "replay_run",
+  replay_run: "replay_run"
+};
+function normalizeExecutionReference(input) {
+  const original = typeof input === "string" ? input : input.id;
+  const trimmed = original.trim();
+  const sourceField = typeof input === "string" ? void 0 : input.source_field;
+  const explicitKind = typeof input === "string" ? void 0 : input.kind;
+  const prefixed = trimmed.match(PREFIXED_RE);
+  const kind = explicitKind ?? kindFromPrefix(prefixed?.[1]) ?? kindFromField(sourceField) ?? inferKind(trimmed);
+  const id = prefixed?.[2]?.trim() || trimmed;
+  return {
+    kind,
+    id,
+    original,
+    label: labelFor(kind),
+    query_field: queryFieldFor(kind),
+    status_command: statusCommandFor(kind, id),
+    replay_command: replayCommandFor(kind, id)
+  };
+}
+function collectExecutionReferences(payload) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [field, value] of Object.entries(payload)) {
+    if (!Object.prototype.hasOwnProperty.call(FIELD_KIND_MAP, field)) continue;
+    if (typeof value !== "string" || value.trim().length === 0) continue;
+    const ref = normalizeExecutionReference({ id: value, source_field: field });
+    const key = `${ref.kind}:${ref.id}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    refs.push(ref);
+  }
+  return refs;
+}
+function kindFromPrefix(prefix) {
+  if (!prefix) return void 0;
+  return PREFIX_KIND_MAP[prefix.toLowerCase()];
+}
+function kindFromField(field) {
+  if (!field) return void 0;
+  return FIELD_KIND_MAP[field];
+}
+function inferKind(value) {
+  if (value.startsWith("run_")) return "trigger_run";
+  if (UUID_RE.test(value)) return "dataplane_run";
+  return "unknown";
+}
+function labelFor(kind) {
+  switch (kind) {
+    case "op":
+      return "Op";
+    case "routine":
+      return "Routine";
+    case "routine_tick":
+      return "Routine tick";
+    case "trigger_run":
+      return "Trigger.dev run";
+    case "dataplane_run":
+      return "Dataplane run";
+    case "queue_job":
+      return "Queue job";
+    case "execution_event":
+      return "Execution event";
+    case "replay_run":
+      return "Replay run";
+    case "unknown":
+    default:
+      return "Execution reference";
+  }
+}
+function queryFieldFor(kind) {
+  switch (kind) {
+    case "op":
+      return "op_id";
+    case "routine":
+      return "routine_id";
+    case "routine_tick":
+      return "tick_id";
+    case "trigger_run":
+      return "run_id";
+    case "dataplane_run":
+      return "run_id";
+    case "queue_job":
+      return "job_id";
+    case "execution_event":
+      return "execution_event_id";
+    case "replay_run":
+      return "replay_run_id";
+    case "unknown":
+    default:
+      return "id";
+  }
+}
+function statusCommandFor(kind, id) {
+  switch (kind) {
+    case "op":
+      return `signaliz status ${id}`;
+    case "trigger_run":
+    case "dataplane_run":
+    case "replay_run":
+      return `signaliz watch ${id}`;
+    case "queue_job":
+      return `signaliz queue --job-id ${id}`;
+    case "routine":
+      return `signaliz routine ${id}`;
+    default:
+      return void 0;
+  }
+}
+function replayCommandFor(kind, id) {
+  if (kind !== "execution_event") return void 0;
+  return `signaliz replay ${id}`;
+}
+
+// src/resources/ops.ts
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue2(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberValue(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+var Ops = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async plan(params) {
+    const body = typeof params === "string" ? { prompt: params } : buildOpsPlanBody(params);
+    return normalizeOpsPlanResult(await this.call("ops_plan", body));
+  }
+  async autopilot(params = {}) {
+    const data = await this.call("ops_autopilot", {
+      window_hours: params.windowHours,
+      output_format: "json"
+    });
+    return normalizeOpsAutopilotResult(data);
+  }
+  async create(params) {
+    const body = typeof params === "string" ? { prompt: params } : buildOpsCreateBody(params);
+    return normalizeOpsCreateResult(withExecutionRefs(await this.call("ops_create", body)));
+  }
+  async execute(params) {
+    const body = typeof params === "string" ? { prompt: params } : buildOpsExecuteBody(params);
+    return normalizeOpsExecuteResult(withExecutionRefs(await this.call("ops_execute", body)));
+  }
+  async run(params) {
+    const body = typeof params === "string" ? { op_id: params } : buildOpsRunBody(params);
+    return normalizeOpsRunResult(withExecutionRefs(await this.call("ops_run", body)));
+  }
+  async status(params) {
+    const body = typeof params === "string" ? { op_id: params } : buildOpsStatusBody(params);
+    return normalizeOpsStatusResult(withExecutionRefs(await this.call("ops_status", body)));
+  }
+  async results(params) {
+    const body = typeof params === "string" ? { op_id: params } : buildOpsResultsBody(params);
+    return normalizeOpsResultsResult(withExecutionRefs(await this.call("ops_results", body)));
+  }
+  async proof(params = {}) {
+    const data = await this.call("ops_proof", {
+      window_hours: params.windowHours,
+      output_format: "json"
+    });
+    return normalizeOpsProofResult(data);
+  }
+  async debug(params) {
+    const options = typeof params === "string" ? { op_id: params } : buildOpsDebugOptions(params);
+    const diagnosticErrors = [];
+    const status = await this.status(options.op_id);
+    const refs = /* @__PURE__ */ new Map();
+    const addRefs = (items) => {
+      for (const ref of items ?? []) refs.set(`${ref.kind}:${ref.id}`, ref);
+    };
+    const recordError = (step, err) => {
+      diagnosticErrors.push({
+        step,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    };
+    addRefs(status.execution_refs);
+    if (status.latest_run && typeof status.latest_run === "object") {
+      addRefs(collectExecutionReferences(status.latest_run));
+    }
+    const runRefs = Array.from(refs.values()).filter((ref) => ref.kind === "trigger_run" || ref.kind === "dataplane_run" || ref.kind === "replay_run");
+    const runStatuses = [];
+    for (const ref of runRefs) {
+      try {
+        const result = await this.getTriggerRunStatus(ref.id);
+        const runs = "runs" in result ? result.runs : [result];
+        runStatuses.push(...runs);
+        for (const run of runs) addRefs(run.execution_refs);
+      } catch (err) {
+        recordError(`run-status:${ref.id}`, err);
+      }
+    }
+    let queue;
+    if (options.include_queue !== false) {
+      try {
+        queue = await this.getQueueStatus({ summary: true });
+        addRefs(queue.execution_refs);
+      } catch (err) {
+        recordError("queue", err);
+      }
+    }
+    let dashboardRecent;
+    if (options.include_dashboard !== false) {
+      try {
+        dashboardRecent = await this.getDashboard({
+          section: "recent",
+          limit: options.dashboard_limit ?? 10,
+          timeRangeDays: options.time_range_days
+        });
+      } catch (err) {
+        recordError("dashboard:recent", err);
+      }
+    }
+    let results;
+    if (options.include_results) {
+      try {
+        results = await this.results({
+          op_id: options.op_id,
+          limit: options.results_limit ?? 25,
+          include_failed_runs: true
+        });
+        addRefs(results.execution_refs);
+      } catch (err) {
+        recordError("results", err);
+      }
+    }
+    const executionRefs = Array.from(refs.values());
+    const replayCandidates = executionRefs.filter((ref) => ref.kind === "execution_event");
+    const nextActions = buildDebugNextActions(status, executionRefs, diagnosticErrors);
+    return normalizeOpsDebugResult({
+      success: diagnosticErrors.length === 0,
+      op_id: options.op_id,
+      checked_at: (/* @__PURE__ */ new Date()).toISOString(),
+      diagnosis: buildDebugDiagnosis(status, runStatuses, queue, diagnosticErrors),
+      status,
+      execution_refs: executionRefs,
+      run_statuses: runStatuses,
+      queue,
+      dashboard_recent: dashboardRecent,
+      results,
+      replay_candidates: replayCandidates,
+      next_actions: nextActions,
+      diagnostic_errors: diagnosticErrors
+    });
+  }
+  async quickstartWorkflow(workflowType = "email_verification") {
+    const workflow = normalizeOpsQuickstartWorkflow(await this.call("quickstart_workflow", { workflow_type: workflowType }));
+    assertQuickstartWorkflowCoherent(workflow, workflowType);
+    return workflow;
+  }
+  async approve(params) {
+    return normalizeOpsApproveResult(await this.call("ops_approve", buildApproveBody(params)));
+  }
+  async createRoutine(params) {
+    return normalizeOpsRoutine(await this.call("create_routine", buildCreateRoutineBody(params)));
+  }
+  async listRoutines(params = {}) {
+    const data = await this.call("list_routines", { ...params, format: "json" });
+    const nextCursor = data.next_cursor ?? data.nextCursor ?? null;
+    const hasMore = data.has_more ?? data.hasMore ?? false;
+    return {
+      routines: Array.isArray(data.routines ?? data) ? (data.routines ?? data).map(normalizeOpsRoutine) : [],
+      total: data.total,
+      next_cursor: nextCursor,
+      nextCursor,
+      has_more: hasMore,
+      hasMore
+    };
+  }
+  async getRoutine(routineId) {
+    return normalizeOpsRoutine(await this.call("get_routine", { routine_id: routineId }));
+  }
+  async updateRoutine(params) {
+    return normalizeOpsRoutine(await this.call("update_routine", buildRoutineBody(params)));
+  }
+  async runRoutineNow(params) {
+    const body = typeof params === "string" ? { routine_id: params } : buildRoutineBody(params);
+    return normalizeOpsRoutineRunResult(await this.call("run_routine_now", body));
+  }
+  async deleteRoutine(routineId, permanent = false) {
+    return normalizeOpsRoutineDeleteResult(await this.call("delete_routine", { routine_id: routineId, confirm: true, permanent }));
+  }
+  async listOutputSinks(params = {}) {
+    const data = await this.call("list_output_sinks", buildListOutputSinksBody(params));
+    const sinks = data.sinks ?? data ?? [];
+    return Array.isArray(sinks) ? sinks.map(normalizeOpsSink) : [];
+  }
+  async getReadiness(params = {}) {
+    const data = await this.call("get_ops_readiness", {
+      window_hours: params.windowHours,
+      include_details: params.includeDetails,
+      run_acquisition_probe: params.runAcquisitionProbe,
+      output_format: "json"
+    });
+    const summary = asRecord2(data.summary);
+    const checks = Array.isArray(data.checks) ? data.checks : [];
+    const checkedAt = stringValue2(data.checked_at ?? data.checkedAt, (/* @__PURE__ */ new Date()).toISOString());
+    const nextActions = Array.isArray(data.next_actions) ? data.next_actions.map(String) : Array.isArray(data.nextActions) ? data.nextActions.map(String) : [];
+    return {
+      status: data.status === "ready" || data.status === "blocked" ? data.status : "degraded",
+      checked_at: checkedAt,
+      checkedAt,
+      credits_used: 0,
+      creditsUsed: 0,
+      credits_charged: 0,
+      creditsCharged: 0,
+      summary: {
+        active_connections: numberValue(summary.active_connections ?? summary.activeConnections),
+        activeConnections: numberValue(summary.active_connections ?? summary.activeConnections),
+        failing_connections: numberValue(summary.failing_connections ?? summary.failingConnections),
+        failingConnections: numberValue(summary.failing_connections ?? summary.failingConnections),
+        active_routines: numberValue(summary.active_routines ?? summary.activeRoutines),
+        activeRoutines: numberValue(summary.active_routines ?? summary.activeRoutines),
+        recent_failed_ticks: numberValue(summary.recent_failed_ticks ?? summary.recentFailedTicks),
+        recentFailedTicks: numberValue(summary.recent_failed_ticks ?? summary.recentFailedTicks),
+        queued_deliveries: numberValue(summary.queued_deliveries ?? summary.queuedDeliveries),
+        queuedDeliveries: numberValue(summary.queued_deliveries ?? summary.queuedDeliveries),
+        pending_approvals: numberValue(summary.pending_approvals ?? summary.pendingApprovals),
+        pendingApprovals: numberValue(summary.pending_approvals ?? summary.pendingApprovals),
+        lead_records: numberValue(summary.lead_records ?? summary.leadRecords),
+        leadRecords: numberValue(summary.lead_records ?? summary.leadRecords),
+        recent_acquisition_failures: numberValue(summary.recent_acquisition_failures ?? summary.recentAcquisitionFailures),
+        recentAcquisitionFailures: numberValue(summary.recent_acquisition_failures ?? summary.recentAcquisitionFailures),
+        acquisition_probe_status: optionalString(summary.acquisition_probe_status ?? summary.acquisitionProbeStatus),
+        acquisitionProbeStatus: optionalString(summary.acquisition_probe_status ?? summary.acquisitionProbeStatus)
+      },
+      checks: checks.map((rawCheck) => {
+        const check = asRecord2(rawCheck);
+        const nextAction = optionalString(check.next_action ?? check.nextAction);
+        return {
+          id: String(check.id ?? ""),
+          label: String(check.label ?? check.id ?? ""),
+          status: check.status === "fail" ? "fail" : check.status === "warn" ? "warn" : "pass",
+          detail: String(check.detail ?? ""),
+          next_action: nextAction,
+          nextAction
+        };
+      }),
+      next_actions: nextActions,
+      nextActions,
+      raw: data
+    };
+  }
+  async doctor(params = {}) {
+    return this.getReadiness(params);
+  }
+  async createOutputSink(params) {
+    const data = await this.call("create_output_sink", buildCreateOutputSinkBody(params));
+    return normalizeOpsSink(data.sink ?? data);
+  }
+  async attachSinkToRoutine(params) {
+    return normalizeOpsRoutineSinkResult(await this.call("attach_sink_to_routine", buildRoutineSinkBody(params)));
+  }
+  async getRoutineTicks(params) {
+    return normalizeOpsRoutineTicksResult(await this.call("get_routine_ticks", buildRoutineBody(params)));
+  }
+  async getLastTickItems(params) {
+    return normalizeOpsRoutineTickItemsResult(await this.call("get_last_tick_items", buildRoutineBody(params)));
+  }
+  async getTriggerRunStatus(params) {
+    const body = typeof params === "string" ? { run_id: params } : {
+      run_id: params.run_id ?? params.runId,
+      run_ids: params.run_ids ?? params.runIds
+    };
+    const result = await this.client.post("trigger-run-status", body);
+    if ("runs" in result) {
+      return {
+        ...result,
+        runs: result.runs.map((run) => normalizeOpsTriggerRunStatus(withExecutionRefs(run)))
+      };
+    }
+    return normalizeOpsTriggerRunStatus(withExecutionRefs(result));
+  }
+  async getQueueStatus(params = {}) {
+    return normalizeOpsQueueStatus(withExecutionRefs(await this.client.get("check-queue-status", {
+      job_id: params.job_id ?? params.jobId,
+      idempotency_key: params.idempotency_key ?? params.idempotencyKey,
+      summary: params.summary
+    })));
+  }
+  async replayFromCheckpoint(executionEventId) {
+    const result = await this.client.post("replay-from-checkpoint", { execution_event_id: executionEventId });
+    const normalized = normalizeOpsReplayResult(withExecutionRefs(result));
+    return {
+      ...normalized,
+      execution_refs: [
+        ...normalized.execution_refs ?? [],
+        normalizeExecutionReference({ id: executionEventId, source_field: "execution_event_id" })
+      ]
+    };
+  }
+  normalizeExecutionReference(input) {
+    return normalizeExecutionReference(input);
+  }
+  collectExecutionReferences(payload) {
+    return collectExecutionReferences(payload);
+  }
+  async getDashboard(params = {}) {
+    return normalizeOpsDashboardResult(await this.client.post("ops-dashboard", params));
+  }
+  async call(name, args) {
+    return this.client.mcp("tools/call", {
+      name,
+      arguments: args
+    });
+  }
+};
+function withExecutionRefs(result) {
+  return {
+    ...result,
+    execution_refs: mergeExecutionRefs(result)
+  };
+}
+function mergeExecutionRefs(result) {
+  const refs = /* @__PURE__ */ new Map();
+  const add = (ref) => refs.set(`${ref.kind}:${ref.id}`, ref);
+  if (Array.isArray(result.execution_refs)) {
+    for (const raw of result.execution_refs) {
+      if (raw && typeof raw === "object") {
+        const ref = raw;
+        if (typeof ref.id === "string" && typeof ref.kind === "string") add(ref);
+      }
+    }
+  }
+  for (const ref of collectExecutionReferences(result)) add(ref);
+  return Array.from(refs.values());
+}
+function normalizeOpsPrimitiveRetryPolicy(policy = {}) {
+  return {
+    ...policy,
+    max_retries: policy.max_retries ?? policy.maxRetries ?? 0,
+    maxRetries: policy.maxRetries ?? policy.max_retries ?? 0,
+    initial_delay_ms: policy.initial_delay_ms ?? policy.initialDelayMs ?? 0,
+    initialDelayMs: policy.initialDelayMs ?? policy.initial_delay_ms ?? 0,
+    max_delay_ms: policy.max_delay_ms ?? policy.maxDelayMs ?? 0,
+    maxDelayMs: policy.maxDelayMs ?? policy.max_delay_ms ?? 0,
+    backoff_multiplier: policy.backoff_multiplier ?? policy.backoffMultiplier ?? 0,
+    backoffMultiplier: policy.backoffMultiplier ?? policy.backoff_multiplier ?? 0,
+    jitter: policy.jitter ?? false,
+    retryable_errors: policy.retryable_errors ?? policy.retryableErrors ?? [],
+    retryableErrors: policy.retryableErrors ?? policy.retryable_errors ?? [],
+    respect_retry_after: policy.respect_retry_after ?? policy.respectRetryAfter ?? false,
+    respectRetryAfter: policy.respectRetryAfter ?? policy.respect_retry_after ?? false
+  };
+}
+function normalizeOpsPrimitiveConcurrencyPolicy(policy = {}) {
+  return {
+    ...policy,
+    workspace_key: policy.workspace_key ?? policy.workspaceKey ?? "",
+    workspaceKey: policy.workspaceKey ?? policy.workspace_key ?? "",
+    provider_key: policy.provider_key ?? policy.providerKey,
+    providerKey: policy.providerKey ?? policy.provider_key,
+    max_concurrency: policy.max_concurrency ?? policy.maxConcurrency ?? 0,
+    maxConcurrency: policy.maxConcurrency ?? policy.max_concurrency ?? 0
+  };
+}
+function normalizeOpsPrimitiveDeadLetterPolicy(policy = {}) {
+  return {
+    ...policy,
+    enabled: policy.enabled ?? false,
+    queue: policy.queue ?? "",
+    include_input_hash: policy.include_input_hash ?? policy.includeInputHash ?? false,
+    includeInputHash: policy.includeInputHash ?? policy.include_input_hash ?? false,
+    include_execution_refs: policy.include_execution_refs ?? policy.includeExecutionRefs ?? false,
+    includeExecutionRefs: policy.includeExecutionRefs ?? policy.include_execution_refs ?? false
+  };
+}
+function normalizeOpsPrimitiveObservabilityPolicy(policy = {}) {
+  return {
+    ...policy,
+    emits_execution_refs: policy.emits_execution_refs ?? policy.emitsExecutionRefs ?? false,
+    emitsExecutionRefs: policy.emitsExecutionRefs ?? policy.emits_execution_refs ?? false,
+    emits_progress_events: policy.emits_progress_events ?? policy.emitsProgressEvents ?? false,
+    emitsProgressEvents: policy.emitsProgressEvents ?? policy.emits_progress_events ?? false,
+    event_fields: policy.event_fields ?? policy.eventFields ?? [],
+    eventFields: policy.eventFields ?? policy.event_fields ?? []
+  };
+}
+function normalizeOpsPrimitive(primitive) {
+  return {
+    ...primitive,
+    permission_level: primitive.permission_level ?? primitive.permissionLevel,
+    permissionLevel: primitive.permissionLevel ?? primitive.permission_level,
+    workspace_scope: primitive.workspace_scope ?? primitive.workspaceScope,
+    workspaceScope: primitive.workspaceScope ?? primitive.workspace_scope,
+    input_schema: primitive.input_schema ?? primitive.inputSchema,
+    inputSchema: primitive.inputSchema ?? primitive.input_schema,
+    output_schema: primitive.output_schema ?? primitive.outputSchema,
+    outputSchema: primitive.outputSchema ?? primitive.output_schema,
+    retry_policy: normalizeOpsPrimitiveRetryPolicy(primitive.retry_policy ?? primitive.retryPolicy),
+    retryPolicy: normalizeOpsPrimitiveRetryPolicy(primitive.retryPolicy ?? primitive.retry_policy),
+    concurrency_policy: normalizeOpsPrimitiveConcurrencyPolicy(primitive.concurrency_policy ?? primitive.concurrencyPolicy),
+    concurrencyPolicy: normalizeOpsPrimitiveConcurrencyPolicy(primitive.concurrencyPolicy ?? primitive.concurrency_policy),
+    rate_limit_key: primitive.rate_limit_key ?? primitive.rateLimitKey,
+    rateLimitKey: primitive.rateLimitKey ?? primitive.rate_limit_key,
+    idempotency_key_fields: primitive.idempotency_key_fields ?? primitive.idempotencyKeyFields ?? [],
+    idempotencyKeyFields: primitive.idempotencyKeyFields ?? primitive.idempotency_key_fields ?? [],
+    dead_letter_policy: normalizeOpsPrimitiveDeadLetterPolicy(primitive.dead_letter_policy ?? primitive.deadLetterPolicy),
+    deadLetterPolicy: normalizeOpsPrimitiveDeadLetterPolicy(primitive.deadLetterPolicy ?? primitive.dead_letter_policy),
+    observability: normalizeOpsPrimitiveObservabilityPolicy(primitive.observability)
+  };
+}
+function normalizeOpsPlanResult(result) {
+  const primitiveGraph = result.primitive_graph ?? result.primitiveGraph;
+  return {
+    ...result,
+    plan_id: result.plan_id ?? result.planId,
+    planId: result.planId ?? result.plan_id,
+    target_count: result.target_count ?? result.targetCount,
+    targetCount: result.targetCount ?? result.target_count,
+    estimated_credits: result.estimated_credits ?? result.estimatedCredits,
+    estimatedCredits: result.estimatedCredits ?? result.estimated_credits,
+    approval_required: result.approval_required ?? result.approvalRequired,
+    approvalRequired: result.approvalRequired ?? result.approval_required,
+    expected_output: result.expected_output ?? result.expectedOutput,
+    expectedOutput: result.expectedOutput ?? result.expected_output,
+    next_action: result.next_action ?? result.nextAction,
+    nextAction: result.nextAction ?? result.next_action,
+    ui_summary: result.ui_summary ?? result.uiSummary,
+    uiSummary: result.uiSummary ?? result.ui_summary,
+    review_steps: result.review_steps ?? result.reviewSteps,
+    reviewSteps: result.reviewSteps ?? result.review_steps,
+    fix_actions: result.fix_actions ?? result.fixActions,
+    fixActions: result.fixActions ?? result.fix_actions,
+    destination_status: result.destination_status ?? result.destinationStatus,
+    destinationStatus: result.destinationStatus ?? result.destination_status,
+    primitive_graph: primitiveGraph?.map(normalizeOpsPrimitive),
+    primitiveGraph: primitiveGraph?.map(normalizeOpsPrimitive)
+  };
+}
+function normalizeOpsCreateResult(result) {
+  return {
+    ...result,
+    op_id: result.op_id ?? result.opId,
+    opId: result.opId ?? result.op_id,
+    routine_id: result.routine_id ?? result.routineId,
+    routineId: result.routineId ?? result.routine_id,
+    run_id: result.run_id ?? result.runId,
+    runId: result.runId ?? result.run_id,
+    next_action: result.next_action ?? result.nextAction,
+    nextAction: result.nextAction ?? result.next_action,
+    results_count: result.results_count ?? result.resultsCount,
+    resultsCount: result.resultsCount ?? result.results_count,
+    results_url: result.results_url ?? result.resultsUrl,
+    resultsUrl: result.resultsUrl ?? result.results_url,
+    delivery_status: result.delivery_status ?? result.deliveryStatus,
+    deliveryStatus: result.deliveryStatus ?? result.delivery_status,
+    estimated_credits: result.estimated_credits ?? result.estimatedCredits,
+    estimatedCredits: result.estimatedCredits ?? result.estimated_credits,
+    plan: result.plan ? normalizeOpsPlanResult(result.plan) : result.plan
+  };
+}
+function normalizeOpsExecuteResult(result) {
+  const created = normalizeOpsCreateResult(result);
+  return {
+    ...created,
+    error_code: result.error_code ?? result.errorCode,
+    errorCode: result.errorCode ?? result.error_code,
+    approval_required: result.approval_required ?? result.approvalRequired,
+    approvalRequired: result.approvalRequired ?? result.approval_required,
+    retry_arguments: result.retry_arguments ?? result.retryArguments,
+    retryArguments: result.retryArguments ?? result.retry_arguments,
+    next_step: result.next_step ?? result.nextStep,
+    nextStep: result.nextStep ?? result.next_step,
+    next_steps: result.next_steps ?? result.nextSteps,
+    nextSteps: result.nextSteps ?? result.next_steps,
+    blockers: result.blockers
+  };
+}
+function normalizeOpsDebugDiagnosis(diagnosis) {
+  return {
+    ...diagnosis,
+    queue_pending: diagnosis.queue_pending ?? diagnosis.queuePending,
+    queuePending: diagnosis.queuePending ?? diagnosis.queue_pending,
+    queue_processing: diagnosis.queue_processing ?? diagnosis.queueProcessing,
+    queueProcessing: diagnosis.queueProcessing ?? diagnosis.queue_processing,
+    queue_failed_last_hour: diagnosis.queue_failed_last_hour ?? diagnosis.queueFailedLastHour,
+    queueFailedLastHour: diagnosis.queueFailedLastHour ?? diagnosis.queue_failed_last_hour,
+    provider_pressure: diagnosis.provider_pressure ?? diagnosis.providerPressure,
+    providerPressure: diagnosis.providerPressure ?? diagnosis.provider_pressure,
+    failed_run_count: diagnosis.failed_run_count ?? diagnosis.failedRunCount,
+    failedRunCount: diagnosis.failedRunCount ?? diagnosis.failed_run_count,
+    primary_error: diagnosis.primary_error ?? diagnosis.primaryError,
+    primaryError: diagnosis.primaryError ?? diagnosis.primary_error
+  };
+}
+function normalizeOpsDebugResult(result) {
+  return {
+    ...result,
+    op_id: result.op_id ?? result.opId,
+    opId: result.opId ?? result.op_id,
+    checked_at: result.checked_at ?? result.checkedAt,
+    checkedAt: result.checkedAt ?? result.checked_at,
+    diagnosis: normalizeOpsDebugDiagnosis(result.diagnosis),
+    execution_refs: result.execution_refs ?? result.executionRefs ?? [],
+    executionRefs: result.executionRefs ?? result.execution_refs ?? [],
+    run_statuses: result.run_statuses ?? result.runStatuses ?? [],
+    runStatuses: result.runStatuses ?? result.run_statuses ?? [],
+    dashboard_recent: result.dashboard_recent ?? result.dashboardRecent,
+    dashboardRecent: result.dashboardRecent ?? result.dashboard_recent,
+    replay_candidates: result.replay_candidates ?? result.replayCandidates ?? [],
+    replayCandidates: result.replayCandidates ?? result.replay_candidates ?? [],
+    next_actions: result.next_actions ?? result.nextActions ?? [],
+    nextActions: result.nextActions ?? result.next_actions ?? [],
+    diagnostic_errors: result.diagnostic_errors ?? result.diagnosticErrors ?? [],
+    diagnosticErrors: result.diagnosticErrors ?? result.diagnostic_errors ?? []
+  };
+}
+function normalizeOpsQuickstartStep(step) {
+  return {
+    ...step,
+    primitive_id: step.primitive_id ?? step.primitiveId,
+    primitiveId: step.primitiveId ?? step.primitive_id,
+    primitive_version: step.primitive_version ?? step.primitiveVersion,
+    primitiveVersion: step.primitiveVersion ?? step.primitive_version
+  };
+}
+function normalizeOpsQuickstartWorkflow(result) {
+  const primitiveGraph = result.primitive_graph ?? result.primitiveGraph;
+  return {
+    ...result,
+    workflow_type: result.workflow_type ?? result.workflowType,
+    workflowType: result.workflowType ?? result.workflow_type,
+    requested_workflow_type: result.requested_workflow_type ?? result.requestedWorkflowType,
+    requestedWorkflowType: result.requestedWorkflowType ?? result.requested_workflow_type,
+    credits_required: result.credits_required ?? result.creditsRequired,
+    creditsRequired: result.creditsRequired ?? result.credits_required,
+    steps: (result.steps ?? []).map(normalizeOpsQuickstartStep),
+    primitive_graph: primitiveGraph?.map(normalizeOpsPrimitive),
+    primitiveGraph: primitiveGraph?.map(normalizeOpsPrimitive),
+    available_types: result.available_types ?? result.availableTypes ?? [],
+    availableTypes: result.availableTypes ?? result.available_types ?? []
+  };
+}
+function assertQuickstartWorkflowCoherent(workflow, requestedWorkflowType) {
+  if (!workflow.available_types.length) return;
+  if (workflow.available_types.includes(workflow.workflow_type)) return;
+  throw new SignalizError({
+    code: "QUICKSTART_TEMPLATE_DRIFT",
+    errorType: "validation",
+    message: `quickstart_workflow returned workflow_type "${workflow.workflow_type}" for requested type "${requestedWorkflowType}", but available_types did not include it`,
+    details: {
+      requested_workflow_type: requestedWorkflowType,
+      workflow_type: workflow.workflow_type,
+      available_types: workflow.available_types
+    }
+  });
+}
+function normalizeOpsRunResult(result) {
+  return {
+    ...result,
+    op_id: result.op_id ?? result.opId,
+    opId: result.opId ?? result.op_id,
+    routine_id: result.routine_id ?? result.routineId,
+    routineId: result.routineId ?? result.routine_id,
+    run_id: result.run_id ?? result.runId,
+    runId: result.runId ?? result.run_id,
+    next_action: result.next_action ?? result.nextAction,
+    nextAction: result.nextAction ?? result.next_action,
+    results_count: result.results_count ?? result.resultsCount,
+    resultsCount: result.resultsCount ?? result.results_count,
+    results_url: result.results_url ?? result.resultsUrl,
+    resultsUrl: result.resultsUrl ?? result.results_url,
+    delivery_status: result.delivery_status ?? result.deliveryStatus,
+    deliveryStatus: result.deliveryStatus ?? result.delivery_status
+  };
+}
+function normalizeOpsStatusResult(result) {
+  return {
+    ...normalizeOpsRunResult(result),
+    estimated_credits: result.estimated_credits ?? result.estimatedCredits,
+    estimatedCredits: result.estimatedCredits ?? result.estimated_credits,
+    latest_run: result.latest_run ?? result.latestRun,
+    latestRun: result.latestRun ?? result.latest_run,
+    diagnosis: result.diagnosis ? normalizeOpsDebugDiagnosis(result.diagnosis) : void 0
+  };
+}
+function normalizeOpsResultsResult(result) {
+  const nextCursor = result.next_cursor ?? result.nextCursor ?? null;
+  const hasMore = result.has_more ?? result.hasMore ?? false;
+  return {
+    ...result,
+    op_id: result.op_id ?? result.opId,
+    opId: result.opId ?? result.op_id,
+    routine_id: result.routine_id ?? result.routineId,
+    routineId: result.routineId ?? result.routine_id,
+    run_id: result.run_id ?? result.runId,
+    runId: result.runId ?? result.run_id,
+    results_count: result.results_count ?? result.resultsCount,
+    resultsCount: result.resultsCount ?? result.results_count,
+    results_total: result.results_total ?? result.resultsTotal,
+    resultsTotal: result.resultsTotal ?? result.results_total,
+    next_cursor: nextCursor,
+    nextCursor,
+    has_more: hasMore,
+    hasMore,
+    next_action: result.next_action ?? result.nextAction,
+    nextAction: result.nextAction ?? result.next_action,
+    results_url: result.results_url ?? result.resultsUrl,
+    resultsUrl: result.resultsUrl ?? result.results_url,
+    delivery_status: result.delivery_status ?? result.deliveryStatus,
+    deliveryStatus: result.deliveryStatus ?? result.delivery_status
+  };
+}
+function normalizeOpsProofResult(data) {
+  const summary = asRecord2(data.summary);
+  const destinations = Array.isArray(data.destinations) ? data.destinations.map((rawDestination) => {
+    const destination = asRecord2(rawDestination);
+    return {
+      type: stringValue2(destination.type),
+      label: stringValue2(destination.label, stringValue2(destination.type)),
+      connected: Boolean(destination.connected),
+      healthy: Boolean(destination.healthy),
+      delivered: numberValue(destination.delivered),
+      failed: numberValue(destination.failed),
+      proof: stringValue2(destination.proof, "connected")
+    };
+  }) : [];
+  const checkedAt = optionalString(data.checked_at ?? data.checkedAt);
+  const nextActions = Array.isArray(data.next_actions) ? data.next_actions.map(String) : Array.isArray(data.nextActions) ? data.nextActions.map(String) : [];
+  const blockers = Array.isArray(data.blockers) ? data.blockers.map(String) : [];
+  const queryErrors = Array.isArray(data.query_errors) ? data.query_errors.map(String) : Array.isArray(data.queryErrors) ? data.queryErrors.map(String) : [];
+  return {
+    ...data,
+    status: stringValue2(data.status, stringValue2(data.proof_state ?? data.proofState, "unproven")),
+    proof_state: stringValue2(data.proof_state ?? data.proofState, stringValue2(data.status, "unproven")),
+    proofState: stringValue2(data.proofState ?? data.proof_state, stringValue2(data.status, "unproven")),
+    checked_at: checkedAt,
+    checkedAt,
+    window_hours: numberValue(data.window_hours ?? data.windowHours),
+    windowHours: numberValue(data.window_hours ?? data.windowHours),
+    label: stringValue2(data.label, "Ops proof"),
+    ui_summary: optionalString(data.ui_summary ?? data.uiSummary),
+    uiSummary: optionalString(data.ui_summary ?? data.uiSummary),
+    founder_verdict: optionalString(data.founder_verdict ?? data.founderVerdict),
+    founderVerdict: optionalString(data.founder_verdict ?? data.founderVerdict),
+    summary: {
+      connected_destinations: numberValue(summary.connected_destinations ?? summary.connectedDestinations),
+      connectedDestinations: numberValue(summary.connected_destinations ?? summary.connectedDestinations),
+      healthy_destinations: numberValue(summary.healthy_destinations ?? summary.healthyDestinations),
+      healthyDestinations: numberValue(summary.healthy_destinations ?? summary.healthyDestinations),
+      failing_destinations: numberValue(summary.failing_destinations ?? summary.failingDestinations),
+      failingDestinations: numberValue(summary.failing_destinations ?? summary.failingDestinations),
+      deliveries_30d: numberValue(summary.deliveries_30d ?? summary.deliveries30d),
+      deliveries30d: numberValue(summary.deliveries_30d ?? summary.deliveries30d),
+      delivered_30d: numberValue(summary.delivered_30d ?? summary.delivered30d),
+      delivered30d: numberValue(summary.delivered_30d ?? summary.delivered30d),
+      failed_30d: numberValue(summary.failed_30d ?? summary.failed30d),
+      failed30d: numberValue(summary.failed_30d ?? summary.failed30d),
+      external_delivered_30d: numberValue(summary.external_delivered_30d ?? summary.externalDelivered30d),
+      externalDelivered30d: numberValue(summary.external_delivered_30d ?? summary.externalDelivered30d),
+      nango_proofs_30d: numberValue(summary.nango_proofs_30d ?? summary.nangoProofs30d),
+      nangoProofs30d: numberValue(summary.nango_proofs_30d ?? summary.nangoProofs30d),
+      nango_failures_30d: numberValue(summary.nango_failures_30d ?? summary.nangoFailures30d),
+      nangoFailures30d: numberValue(summary.nango_failures_30d ?? summary.nangoFailures30d),
+      airbyte_configured: numberValue(summary.airbyte_configured ?? summary.airbyteConfigured),
+      airbyteConfigured: numberValue(summary.airbyte_configured ?? summary.airbyteConfigured),
+      airbyte_proofs_30d: numberValue(summary.airbyte_proofs_30d ?? summary.airbyteProofs30d),
+      airbyteProofs30d: numberValue(summary.airbyte_proofs_30d ?? summary.airbyteProofs30d),
+      airbyte_failures_30d: numberValue(summary.airbyte_failures_30d ?? summary.airbyteFailures30d),
+      airbyteFailures30d: numberValue(summary.airbyte_failures_30d ?? summary.airbyteFailures30d)
+    },
+    destinations,
+    blockers,
+    next_action: optionalString(data.next_action ?? data.nextAction),
+    nextAction: optionalString(data.next_action ?? data.nextAction),
+    next_actions: nextActions,
+    nextActions,
+    estimated_credits: numberValue(data.estimated_credits ?? data.estimatedCredits),
+    estimatedCredits: numberValue(data.estimated_credits ?? data.estimatedCredits),
+    approval_required: Boolean(data.approval_required ?? data.approvalRequired),
+    approvalRequired: Boolean(data.approval_required ?? data.approvalRequired),
+    credits_charged: 0,
+    creditsCharged: 0,
+    proof_mode: data.proof_mode !== false,
+    proofMode: data.proof_mode !== false,
+    query_errors: queryErrors,
+    queryErrors,
+    raw: data
+  };
+}
+function normalizeOpsAutopilotMotion(rawMotion) {
+  const motion = asRecord2(rawMotion);
+  const targetCount = numberValue(motion.target_count ?? motion.targetCount);
+  const estimatedCredits = numberValue(motion.estimated_credits ?? motion.estimatedCredits);
+  const mcpSequence = Array.isArray(motion.mcp_sequence) ? motion.mcp_sequence : Array.isArray(motion.mcpSequence) ? motion.mcpSequence : [];
+  return {
+    ...motion,
+    id: stringValue2(motion.id),
+    blueprint: stringValue2(motion.blueprint, "build_leads"),
+    title: stringValue2(motion.title),
+    outcome: stringValue2(motion.outcome),
+    prompt: stringValue2(motion.prompt),
+    target_count: targetCount,
+    targetCount,
+    cadence: stringValue2(motion.cadence, "manual"),
+    destinations: Array.isArray(motion.destinations) ? motion.destinations.map(String) : [],
+    estimated_credits: estimatedCredits,
+    estimatedCredits,
+    proof_gate: optionalString(motion.proof_gate ?? motion.proofGate),
+    proofGate: optionalString(motion.proof_gate ?? motion.proofGate),
+    why_now: optionalString(motion.why_now ?? motion.whyNow),
+    whyNow: optionalString(motion.why_now ?? motion.whyNow),
+    agent_prompt: optionalString(motion.agent_prompt ?? motion.agentPrompt),
+    agentPrompt: optionalString(motion.agent_prompt ?? motion.agentPrompt),
+    cli_command: optionalString(motion.cli_command ?? motion.cliCommand),
+    cliCommand: optionalString(motion.cli_command ?? motion.cliCommand),
+    mcp_sequence: mcpSequence,
+    mcpSequence
+  };
+}
+function normalizeOpsAutopilotResult(result) {
+  const primary = normalizeOpsAutopilotMotion(result.primary_motion ?? result.primaryMotion);
+  const motions = Array.isArray(result.motions) ? result.motions.map(normalizeOpsAutopilotMotion) : [];
+  const queryErrors = Array.isArray(result.query_errors) ? result.query_errors.map(String) : Array.isArray(result.queryErrors) ? result.queryErrors.map(String) : [];
+  return {
+    ...result,
+    stage: stringValue2(result.stage, "prove"),
+    headline: stringValue2(result.headline, "Ops Autopilot"),
+    verdict: stringValue2(result.verdict),
+    next_action: stringValue2(result.next_action ?? result.nextAction),
+    nextAction: stringValue2(result.next_action ?? result.nextAction),
+    primary_motion: primary,
+    primaryMotion: primary,
+    motions,
+    scale_rule: optionalString(result.scale_rule ?? result.scaleRule),
+    scaleRule: optionalString(result.scale_rule ?? result.scaleRule),
+    agent_handoff: optionalString(result.agent_handoff ?? result.agentHandoff),
+    agentHandoff: optionalString(result.agent_handoff ?? result.agentHandoff),
+    proof_state: optionalString(result.proof_state ?? result.proofState),
+    proofState: optionalString(result.proof_state ?? result.proofState),
+    proof_summary: result.proof_summary ?? result.proofSummary,
+    proofSummary: result.proof_summary ?? result.proofSummary,
+    next_step: result.next_step ?? result.nextStep,
+    nextStep: result.next_step ?? result.nextStep,
+    query_errors: queryErrors,
+    queryErrors,
+    credits_charged: 0,
+    creditsCharged: 0
+  };
+}
+function normalizeOpsTriggerRunStatus(result) {
+  const runId = result.run_id ?? result.runId;
+  return {
+    ...result,
+    run_id: runId,
+    runId,
+    diagnosis: result.diagnosis ? normalizeOpsDebugDiagnosis(result.diagnosis) : void 0
+  };
+}
+function normalizeOpsQueueStatus(result) {
+  const summary = result.summary;
+  const producerEnvelope = normalizeOpsQueueProducerEnvelope(result.producer_envelope ?? result.producerEnvelope);
+  const job = result.job ? {
+    ...result.job,
+    id: result.job.id ?? result.job.jobId,
+    jobId: result.job.jobId ?? result.job.id,
+    function_name: result.job.function_name ?? result.job.functionName,
+    functionName: result.job.functionName ?? result.job.function_name,
+    estimated_wait_ms: result.job.estimated_wait_ms ?? result.job.estimatedWaitMs,
+    estimatedWaitMs: result.job.estimatedWaitMs ?? result.job.estimated_wait_ms,
+    error_message: result.job.error_message ?? result.job.errorMessage,
+    errorMessage: result.job.errorMessage ?? result.job.error_message
+  } : void 0;
+  if (!summary) {
+    return {
+      ...result,
+      producer_envelope: producerEnvelope,
+      producerEnvelope,
+      job,
+      diagnosis: result.diagnosis ? normalizeOpsDebugDiagnosis(result.diagnosis) : void 0
+    };
+  }
+  const queue = summary.queue;
+  const normalizedQueue = queue ? {
+    ...queue,
+    completed_last_hour: queue.completed_last_hour ?? queue.completedLastHour,
+    completedLastHour: queue.completedLastHour ?? queue.completed_last_hour,
+    failed_last_hour: queue.failed_last_hour ?? queue.failedLastHour,
+    failedLastHour: queue.failedLastHour ?? queue.failed_last_hour,
+    pending_by_function: queue.pending_by_function ?? queue.pendingByFunction,
+    pendingByFunction: queue.pendingByFunction ?? queue.pending_by_function
+  } : void 0;
+  return {
+    ...result,
+    producer_envelope: producerEnvelope,
+    producerEnvelope,
+    job,
+    diagnosis: result.diagnosis ? normalizeOpsDebugDiagnosis(result.diagnosis) : void 0,
+    summary: {
+      ...summary,
+      queue: normalizedQueue,
+      provider_stats: summary.provider_stats ?? summary.providerStats,
+      providerStats: summary.providerStats ?? summary.provider_stats,
+      redis_status: summary.redis_status ?? summary.redisStatus,
+      redisStatus: summary.redisStatus ?? summary.redis_status,
+      recent_events: summary.recent_events ?? summary.recentEvents,
+      recentEvents: summary.recentEvents ?? summary.recent_events
+    }
+  };
+}
+function normalizeOpsQueueProducerEnvelope(envelope) {
+  if (!envelope) return void 0;
+  return {
+    ...envelope,
+    schema_version: envelope.schema_version ?? envelope.schemaVersion,
+    schemaVersion: envelope.schemaVersion ?? envelope.schema_version,
+    queue_name: envelope.queue_name ?? envelope.queueName,
+    queueName: envelope.queueName ?? envelope.queue_name,
+    status_source: envelope.status_source ?? envelope.statusSource,
+    statusSource: envelope.statusSource ?? envelope.status_source,
+    idempotency_key: envelope.idempotency_key ?? envelope.idempotencyKey ?? null,
+    idempotencyKey: envelope.idempotencyKey ?? envelope.idempotency_key ?? null,
+    job_id: envelope.job_id ?? envelope.jobId ?? null,
+    jobId: envelope.jobId ?? envelope.job_id ?? null,
+    summary_requested: envelope.summary_requested ?? envelope.summaryRequested,
+    summaryRequested: envelope.summaryRequested ?? envelope.summary_requested,
+    retry_after_ms: envelope.retry_after_ms ?? envelope.retryAfterMs,
+    retryAfterMs: envelope.retryAfterMs ?? envelope.retry_after_ms,
+    poll_after_seconds: envelope.poll_after_seconds ?? envelope.pollAfterSeconds,
+    pollAfterSeconds: envelope.pollAfterSeconds ?? envelope.poll_after_seconds,
+    emitted_at: envelope.emitted_at ?? envelope.emittedAt,
+    emittedAt: envelope.emittedAt ?? envelope.emitted_at
+  };
+}
+function normalizeOpsReplayResult(result) {
+  const replayRunId = result.replay_run_id ?? result.replayRunId ?? "";
+  const originalRunId = result.original_run_id ?? result.originalRunId ?? "";
+  const startFromNode = result.start_from_node ?? result.startFromNode ?? 0;
+  const totalNodes = result.total_nodes ?? result.totalNodes ?? 0;
+  return {
+    ...result,
+    replay_run_id: replayRunId,
+    replayRunId,
+    original_run_id: originalRunId,
+    originalRunId,
+    start_from_node: startFromNode,
+    startFromNode,
+    total_nodes: totalNodes,
+    totalNodes,
+    diagnosis: result.diagnosis ? normalizeOpsDebugDiagnosis(result.diagnosis) : void 0
+  };
+}
+function normalizeOpsApproveResult(result) {
+  return {
+    ...result,
+    token_id: result.token_id ?? result.tokenId,
+    tokenId: result.tokenId ?? result.token_id,
+    token_ids: result.token_ids ?? result.tokenIds,
+    tokenIds: result.tokenIds ?? result.token_ids,
+    reviewer_notes: result.reviewer_notes ?? result.reviewerNotes,
+    reviewerNotes: result.reviewerNotes ?? result.reviewer_notes
+  };
+}
+function normalizeOpsDashboardResult(result) {
+  return {
+    ...result,
+    today_executions: result.today_executions ?? result.todayExecutions,
+    todayExecutions: result.todayExecutions ?? result.today_executions,
+    today_credits: result.today_credits ?? result.todayCredits,
+    todayCredits: result.todayCredits ?? result.today_credits,
+    month_executions: result.month_executions ?? result.monthExecutions,
+    monthExecutions: result.monthExecutions ?? result.month_executions,
+    month_credits: result.month_credits ?? result.monthCredits,
+    monthCredits: result.monthCredits ?? result.month_credits,
+    avg_execution_time_ms: result.avg_execution_time_ms ?? result.avgExecutionTimeMs,
+    avgExecutionTimeMs: result.avgExecutionTimeMs ?? result.avg_execution_time_ms
+  };
+}
+function normalizeOpsSink(sink) {
+  return {
+    ...sink,
+    id: sink.id ?? sink.sink_id ?? sink.sinkId,
+    sink_id: sink.sink_id ?? sink.sinkId ?? sink.id,
+    sinkId: sink.sinkId ?? sink.sink_id ?? sink.id,
+    connection_id: sink.connection_id ?? sink.connectionId,
+    connectionId: sink.connectionId ?? sink.connection_id,
+    connector_id: sink.connector_id ?? sink.connectorId,
+    connectorId: sink.connectorId ?? sink.connector_id,
+    sync_status: sink.sync_status ?? sink.syncStatus,
+    syncStatus: sink.syncStatus ?? sink.sync_status,
+    last_synced_at: sink.last_synced_at ?? sink.lastSyncedAt,
+    lastSyncedAt: sink.lastSyncedAt ?? sink.last_synced_at
+  };
+}
+function normalizeOpsRoutine(routine) {
+  const outputSinks = routine.output_sinks ?? routine.outputSinks;
+  return withExecutionRefs({
+    ...routine,
+    id: routine.id ?? routine.routine_id ?? routine.routineId,
+    routine_id: routine.routine_id ?? routine.routineId ?? routine.id,
+    routineId: routine.routineId ?? routine.routine_id ?? routine.id,
+    last_tick_at: routine.last_tick_at ?? routine.lastTickAt,
+    lastTickAt: routine.lastTickAt ?? routine.last_tick_at,
+    next_tick_at: routine.next_tick_at ?? routine.nextTickAt,
+    nextTickAt: routine.nextTickAt ?? routine.next_tick_at,
+    output_sinks: outputSinks?.map(normalizeOpsSink),
+    outputSinks: outputSinks?.map(normalizeOpsSink)
+  });
+}
+function normalizeOpsRoutineRunResult(result) {
+  return withExecutionRefs({
+    ...result,
+    routine_id: result.routine_id ?? result.routineId,
+    routineId: result.routineId ?? result.routine_id,
+    tick_id: result.tick_id ?? result.tickId,
+    tickId: result.tickId ?? result.tick_id,
+    run_id: result.run_id ?? result.runId,
+    runId: result.runId ?? result.run_id,
+    next_action: result.next_action ?? result.nextAction,
+    nextAction: result.nextAction ?? result.next_action
+  });
+}
+function normalizeOpsRoutineDeleteResult(result) {
+  return withExecutionRefs({
+    ...result,
+    routine_id: result.routine_id ?? result.routineId,
+    routineId: result.routineId ?? result.routine_id,
+    next_action: result.next_action ?? result.nextAction,
+    nextAction: result.nextAction ?? result.next_action
+  });
+}
+function normalizeOpsRoutineSinkResult(result) {
+  return withExecutionRefs({
+    ...result,
+    routine_id: result.routine_id ?? result.routineId,
+    routineId: result.routineId ?? result.routine_id,
+    sink_id: result.sink_id ?? result.sinkId,
+    sinkId: result.sinkId ?? result.sink_id,
+    next_action: result.next_action ?? result.nextAction,
+    nextAction: result.nextAction ?? result.next_action,
+    routine: result.routine ? normalizeOpsRoutine(result.routine) : result.routine,
+    sink: result.sink ? normalizeOpsSink(result.sink) : result.sink
+  });
+}
+function normalizeOpsRoutineTick(tick) {
+  return withExecutionRefs({
+    ...tick,
+    id: tick.id ?? tick.tick_id ?? tick.tickId,
+    tick_id: tick.tick_id ?? tick.tickId ?? tick.id,
+    tickId: tick.tickId ?? tick.tick_id ?? tick.id,
+    routine_id: tick.routine_id ?? tick.routineId,
+    routineId: tick.routineId ?? tick.routine_id,
+    started_at: tick.started_at ?? tick.startedAt,
+    startedAt: tick.startedAt ?? tick.started_at,
+    completed_at: tick.completed_at ?? tick.completedAt,
+    completedAt: tick.completedAt ?? tick.completed_at,
+    error_message: tick.error_message ?? tick.errorMessage,
+    errorMessage: tick.errorMessage ?? tick.error_message
+  });
+}
+function normalizeOpsRoutineTicksResult(result) {
+  const ticks = Array.isArray(result.ticks ?? result.items) ? (result.ticks ?? result.items ?? []).map(normalizeOpsRoutineTick) : [];
+  const nextCursor = result.next_cursor ?? result.nextCursor ?? null;
+  const hasMore = result.has_more ?? result.hasMore ?? false;
+  return {
+    ...result,
+    ticks,
+    items: result.items ? ticks : result.items,
+    next_cursor: nextCursor,
+    nextCursor,
+    has_more: hasMore,
+    hasMore
+  };
+}
+function normalizeOpsRoutineTickItem(item) {
+  return withExecutionRefs({
+    ...item,
+    id: item.id ?? item.item_id ?? item.itemId,
+    item_id: item.item_id ?? item.itemId ?? item.id,
+    itemId: item.itemId ?? item.item_id ?? item.id,
+    tick_id: item.tick_id ?? item.tickId,
+    tickId: item.tickId ?? item.tick_id,
+    routine_id: item.routine_id ?? item.routineId,
+    routineId: item.routineId ?? item.routine_id,
+    error_message: item.error_message ?? item.errorMessage,
+    errorMessage: item.errorMessage ?? item.error_message
+  });
+}
+function normalizeOpsRoutineTickItemsResult(result) {
+  const items = Array.isArray(result.items ?? result.rows) ? (result.items ?? result.rows ?? []).map(normalizeOpsRoutineTickItem) : [];
+  const nextCursor = result.next_cursor ?? result.nextCursor ?? null;
+  const hasMore = result.has_more ?? result.hasMore ?? false;
+  return {
+    ...result,
+    items,
+    rows: result.rows ? items : result.rows,
+    next_cursor: nextCursor,
+    nextCursor,
+    has_more: hasMore,
+    hasMore
+  };
+}
+function buildOpsPlanBody(params) {
+  const { targetCount, companyDomains, customAiPrompt, signalPrompt, outputPrompt, ...rest } = params;
+  return {
+    ...rest,
+    target_count: rest.target_count ?? targetCount,
+    company_domains: rest.company_domains ?? companyDomains,
+    custom_ai_prompt: rest.custom_ai_prompt ?? customAiPrompt,
+    signal_prompt: rest.signal_prompt ?? signalPrompt,
+    output_prompt: rest.output_prompt ?? outputPrompt
+  };
+}
+function buildOpsCreateBody(params) {
+  const { confirmSpend, ...rest } = params;
+  return {
+    ...buildOpsPlanBody(rest),
+    confirm_spend: rest.confirm_spend ?? confirmSpend
+  };
+}
+function buildOpsExecuteBody(params) {
+  const { autoRun, dryRun, outputFormat, ...rest } = params;
+  return {
+    ...buildOpsCreateBody(rest),
+    auto_run: rest.auto_run ?? autoRun,
+    dry_run: rest.dry_run ?? dryRun,
+    output_format: rest.output_format ?? outputFormat
+  };
+}
+function buildOpsRunBody(params) {
+  const { opId, ...rest } = params;
+  return {
+    ...rest,
+    op_id: rest.op_id ?? opId
+  };
+}
+function buildOpsStatusBody(params) {
+  const { opId, ...rest } = params;
+  return {
+    ...rest,
+    op_id: rest.op_id ?? opId
+  };
+}
+function buildOpsResultsBody(params) {
+  const { opId, nextCursor, includeFailedRuns, ...rest } = params;
+  return {
+    ...rest,
+    op_id: rest.op_id ?? opId,
+    cursor: rest.cursor ?? nextCursor,
+    include_failed_runs: rest.include_failed_runs ?? includeFailedRuns
+  };
+}
+function buildOpsDebugOptions(params) {
+  const {
+    opId,
+    includeResults,
+    resultsLimit,
+    includeQueue,
+    includeDashboard,
+    dashboardLimit,
+    timeRangeDays,
+    ...rest
+  } = params;
+  const op_id = rest.op_id ?? opId;
+  if (!op_id) throw new Error("ops.debug requires op_id or opId");
+  return {
+    ...rest,
+    op_id,
+    include_results: rest.include_results ?? includeResults,
+    results_limit: rest.results_limit ?? resultsLimit,
+    include_queue: rest.include_queue ?? includeQueue,
+    include_dashboard: rest.include_dashboard ?? includeDashboard,
+    dashboard_limit: rest.dashboard_limit ?? dashboardLimit,
+    time_range_days: rest.time_range_days ?? timeRangeDays
+  };
+}
+function buildCreateRoutineBody(params) {
+  const { outputSinks, wakeOnEvents, ...rest } = params;
+  const sinks = rest.output_sinks ?? outputSinks;
+  return {
+    ...rest,
+    output_sinks: Array.isArray(sinks) ? sinks.map(normalizeOpsSinkRequest) : sinks,
+    wake_on_events: rest.wake_on_events ?? wakeOnEvents
+  };
+}
+function buildRoutineBody(params) {
+  const { routineId, ...rest } = params;
+  return {
+    ...rest,
+    routine_id: rest.routine_id ?? routineId
+  };
+}
+function buildRoutineSinkBody(params) {
+  const { routineId, sinkId, ...rest } = params;
+  return {
+    ...rest,
+    routine_id: rest.routine_id ?? routineId,
+    sink_id: rest.sink_id ?? sinkId
+  };
+}
+function buildListOutputSinksBody(params) {
+  const { includeInactive, ...rest } = params;
+  return {
+    ...rest,
+    include_inactive: rest.include_inactive ?? includeInactive
+  };
+}
+function buildCreateOutputSinkBody(params) {
+  const { connectionId, webhookUrl, ...rest } = params;
+  return {
+    ...rest,
+    connection_id: rest.connection_id ?? connectionId,
+    webhook_url: rest.webhook_url ?? webhookUrl
+  };
+}
+function normalizeOpsSinkRequest(sink) {
+  const {
+    sinkId,
+    connectionId,
+    connectorId,
+    connectorName,
+    deliveryMode,
+    providerConfigKey,
+    integrationId,
+    nangoConnectionId,
+    actionName,
+    nangoAction,
+    proxyPath,
+    nangoProxyPath,
+    fieldMap,
+    requiredFields,
+    writeConfirmed,
+    agentWriteConfirmed,
+    config,
+    ...rest
+  } = sink;
+  const normalizedConfig = normalizeOpsSinkConfigRequest(config);
+  const connection_id = rest.connection_id ?? connectionId;
+  const connector_id = rest.connector_id ?? connectorId;
+  const delivery_mode = rest.delivery_mode ?? deliveryMode;
+  const provider_config_key = rest.provider_config_key ?? providerConfigKey;
+  const integration_id = rest.integration_id ?? integrationId;
+  const nango_connection_id = rest.nango_connection_id ?? nangoConnectionId;
+  const action_name = rest.action_name ?? actionName;
+  const nango_action = rest.nango_action ?? nangoAction;
+  const proxy_path = rest.proxy_path ?? proxyPath;
+  const nango_proxy_path = rest.nango_proxy_path ?? nangoProxyPath;
+  const field_map = rest.field_map ?? fieldMap;
+  const required_fields = rest.required_fields ?? requiredFields;
+  const write_confirmed = rest.write_confirmed ?? writeConfirmed;
+  const agent_write_confirmed = rest.agent_write_confirmed ?? agentWriteConfirmed;
+  if (connection_id !== void 0 && normalizedConfig.connection_id === void 0) normalizedConfig.connection_id = connection_id;
+  if (connector_id !== void 0 && normalizedConfig.connector_id === void 0) normalizedConfig.connector_id = connector_id;
+  if (delivery_mode !== void 0 && normalizedConfig.delivery_mode === void 0) normalizedConfig.delivery_mode = delivery_mode;
+  if (provider_config_key !== void 0 && normalizedConfig.provider_config_key === void 0) normalizedConfig.provider_config_key = provider_config_key;
+  if (integration_id !== void 0 && normalizedConfig.integration_id === void 0) normalizedConfig.integration_id = integration_id;
+  if (nango_connection_id !== void 0 && normalizedConfig.nango_connection_id === void 0) normalizedConfig.nango_connection_id = nango_connection_id;
+  if (action_name !== void 0 && normalizedConfig.action_name === void 0) normalizedConfig.action_name = action_name;
+  if (nango_action !== void 0 && normalizedConfig.nango_action === void 0) normalizedConfig.nango_action = nango_action;
+  if (proxy_path !== void 0 && normalizedConfig.proxy_path === void 0) normalizedConfig.proxy_path = proxy_path;
+  if (nango_proxy_path !== void 0 && normalizedConfig.nango_proxy_path === void 0) normalizedConfig.nango_proxy_path = nango_proxy_path;
+  if (field_map !== void 0 && normalizedConfig.field_map === void 0) normalizedConfig.field_map = field_map;
+  if (required_fields !== void 0 && normalizedConfig.required_fields === void 0) normalizedConfig.required_fields = required_fields;
+  if (write_confirmed !== void 0 && normalizedConfig.write_confirmed === void 0) normalizedConfig.write_confirmed = write_confirmed;
+  if (agent_write_confirmed !== void 0 && normalizedConfig.agent_write_confirmed === void 0) normalizedConfig.agent_write_confirmed = agent_write_confirmed;
+  if (sink.type === "nango" && normalizedConfig.integration_platform === void 0) normalizedConfig.integration_platform = "nango";
+  return {
+    ...rest,
+    sink_id: rest.sink_id ?? sinkId,
+    connection_id,
+    connector_id,
+    connector_name: rest.connector_name ?? connectorName,
+    delivery_mode,
+    provider_config_key,
+    integration_id,
+    nango_connection_id,
+    action_name,
+    nango_action,
+    proxy_path,
+    nango_proxy_path,
+    field_map,
+    required_fields,
+    write_confirmed,
+    agent_write_confirmed,
+    config: normalizedConfig
+  };
+}
+function normalizeOpsSinkConfigRequest(config) {
+  const out = { ...config ?? {} };
+  if (out.connection_id === void 0 && out.connectionId !== void 0) out.connection_id = out.connectionId;
+  if (out.connector_id === void 0 && out.connectorId !== void 0) out.connector_id = out.connectorId;
+  if (out.connector_name === void 0 && out.connectorName !== void 0) out.connector_name = out.connectorName;
+  if (out.delivery_mode === void 0 && out.deliveryMode !== void 0) out.delivery_mode = out.deliveryMode;
+  if (out.provider_config_key === void 0 && out.providerConfigKey !== void 0) out.provider_config_key = out.providerConfigKey;
+  if (out.integration_id === void 0 && out.integrationId !== void 0) out.integration_id = out.integrationId;
+  if (out.nango_connection_id === void 0 && out.nangoConnectionId !== void 0) out.nango_connection_id = out.nangoConnectionId;
+  if (out.action_name === void 0 && out.actionName !== void 0) out.action_name = out.actionName;
+  if (out.nango_action === void 0 && out.nangoAction !== void 0) out.nango_action = out.nangoAction;
+  if (out.proxy_path === void 0 && out.proxyPath !== void 0) out.proxy_path = out.proxyPath;
+  if (out.nango_proxy_path === void 0 && out.nangoProxyPath !== void 0) out.nango_proxy_path = out.nangoProxyPath;
+  if (out.field_map === void 0 && out.fieldMap !== void 0) out.field_map = out.fieldMap;
+  if (out.required_fields === void 0 && out.requiredFields !== void 0) out.required_fields = out.requiredFields;
+  if (out.write_confirmed === void 0 && out.writeConfirmed !== void 0) out.write_confirmed = out.writeConfirmed;
+  if (out.agent_write_confirmed === void 0 && out.agentWriteConfirmed !== void 0) out.agent_write_confirmed = out.agentWriteConfirmed;
+  return out;
+}
+function buildApproveBody(params) {
+  const { tokenId, tokenIds, reviewerNotes, ...rest } = params;
+  return {
+    ...rest,
+    token_id: rest.token_id ?? tokenId,
+    token_ids: rest.token_ids ?? tokenIds,
+    reviewer_notes: rest.reviewer_notes ?? reviewerNotes
+  };
+}
+function buildDebugNextActions(status, refs, errors) {
+  const actions = /* @__PURE__ */ new Set();
+  if (status.next_action) actions.add(status.next_action);
+  for (const ref of refs) {
+    if (ref.status_command) actions.add(ref.status_command);
+    if (ref.replay_command) actions.add(ref.replay_command);
+  }
+  if (errors.length > 0) actions.add("Review diagnostic_errors before replaying or changing the Op prompt.");
+  if (refs.some((ref) => ref.kind === "queue_job")) actions.add("Inspect queue pressure before retrying provider-backed work.");
+  return Array.from(actions);
+}
+function buildDebugDiagnosis(status, runStatuses, queue, errors) {
+  const backendDiagnosis = status.diagnosis ? normalizeOpsDebugDiagnosis(status.diagnosis) : void 0;
+  const queueSummary = queue?.summary?.queue ?? queue?.queue;
+  const queuePending = queueSummary?.pending ?? 0;
+  const queueProcessing = queueSummary?.processing ?? 0;
+  const queueFailedLastHour = queue?.summary?.queue?.failed_last_hour ?? queue?.summary?.queue?.failedLastHour ?? 0;
+  const failedRuns = runStatuses.filter((run) => /fail|error|cancel/i.test(run.status || ""));
+  const primaryRunError = failedRuns.map((run) => run.error).find((error) => error !== void 0);
+  const primaryError = errors[0]?.message || stringifyDebugError(primaryRunError);
+  const providerPressure = queuePending >= 100 ? "high" : queuePending >= 10 ? "medium" : queuePending > 0 || queueProcessing > 0 ? "low" : "none";
+  const statusText = `${status.status || ""} ${status.phase || ""}`.toLowerCase();
+  const state = errors.length > 0 ? "degraded" : failedRuns.length > 0 || statusText.includes("failed") || statusText.includes("error") ? "failed" : statusText.includes("running") || statusText.includes("pending") || statusText.includes("queued") || queueProcessing > 0 ? "running" : statusText.includes("complete") || statusText.includes("success") ? "healthy" : backendDiagnosis?.state ?? "unknown";
+  const retryable = state === "failed" && (failedRuns.length > 0 || backendDiagnosis?.retryable === true || Boolean(status.execution_refs?.some((ref) => ref.replay_command)));
+  const summary = [
+    `State ${state}`,
+    `retry ${retryable ? "available" : "not indicated"}`,
+    `queue ${queuePending} pending/${queueProcessing} processing`,
+    `provider pressure ${providerPressure}`
+  ].join("; ");
+  return {
+    state,
+    retryable,
+    queue_pending: queuePending,
+    queue_processing: queueProcessing,
+    queue_failed_last_hour: queueFailedLastHour,
+    provider_pressure: providerPressure,
+    failed_run_count: failedRuns.length || backendDiagnosis?.failed_run_count || 0,
+    primary_error: primaryError ?? backendDiagnosis?.primary_error,
+    summary
+  };
+}
+function stringifyDebugError(error) {
+  if (error === void 0 || error === null) return void 0;
+  if (typeof error === "string") return error;
+  if (error instanceof Error) return error.message;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+
+// src/resources/ai.ts
+function toSnakeConfig(params) {
+  return {
+    system_prompt: params.systemPrompt || params.system_prompt || "You are a senior business research analyst. Use multi-model evidence carefully and return concise structured enrichment.",
+    user_template: params.userTemplate || params.user_template || params.prompt,
+    model: params.model,
+    temperature: params.temperature,
+    max_concurrency: params.maxConcurrency || params.max_concurrency,
+    max_tokens: params.maxTokens || params.max_tokens,
+    output_fields: params.outputFields || params.output_fields || [{ name: "response", type: "text", description: "Structured enrichment result" }],
+    attachments: params.attachments,
+    attachment_fields: params.attachmentFields || params.attachment_fields,
+    pdf_engine: params.pdfEngine || params.pdf_engine,
+    fusion: params.fusion
+  };
+}
+function recordsFromParams(params) {
+  const records = params.records || params.inputs;
+  if (records?.length) return { records };
+  if (params.input) return { input: params.input };
+  return { input: {} };
+}
+var Ai = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Run Custom AI Enrichment - Multi Model.
+   *
+   * Uses OpenRouter Fusion for multi-model analysis with web search/fetch enabled
+   * inside Fusion, then synthesizes the requested structured output fields.
+   */
+  async multiModel(params) {
+    if (!params.model) {
+      throw new Error('model is required. Use an OpenRouter id such as "anthropic/claude-sonnet-4" or "google/gemini-2.5-flash".');
+    }
+    if (!params.prompt && !params.userTemplate && !params.user_template) {
+      throw new Error("prompt or userTemplate is required.");
+    }
+    const data = await this.client.post("custom-ai-multi-model", {
+      ...recordsFromParams(params),
+      config: toSnakeConfig(params)
+    });
+    return {
+      success: data.success ?? false,
+      capability: data.capability ?? "custom_ai_multi_model",
+      displayName: data.display_name ?? "Custom AI Enrichment - Multi Model",
+      results: data.results ?? [],
+      creditsUsed: data.total_credits_used ?? data.credits_used ?? 0,
+      model: data.model,
+      fusion: data.fusion,
+      multimodalCount: data.multimodal_count ?? 0,
+      tokensUsed: data.tokens_used ?? 0,
+      costUsd: data.cost_usd ?? 0,
+      billingMetadata: data.billing_metadata,
+      raw: data
+    };
+  }
+};
+
+// src/resources/gtm-kernel.ts
+var GtmKernel = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Load workspace context for an agent session: campaigns, memory, Brain, connections, and Signaliz primitives. */
+  async context(options = {}) {
+    return this.callMcp("gtm_workspace_context", {
+      include_campaigns: options.includeCampaigns,
+      include_memory: options.includeMemory,
+      include_brain: options.includeBrain,
+      include_connections: options.includeConnections,
+      limit: options.limit
+    });
+  }
+  /** Inspect whether the workspace has the Kernel + Brain substrate pieces needed to build, run, and improve campaigns. */
+  async bootstrapStatus(options = {}) {
+    return this.callMcp("gtm_workspace_bootstrap_status", {
+      campaign_id: options.campaignId,
+      days: options.days,
+      min_sample_size: options.minSampleSize,
+      include_connections: options.includeConnections,
+      include_samples: options.includeSamples,
+      limit: options.limit
+    });
+  }
+  /** Discover existing provider campaigns, starting with live/Kernel-linked Instantly campaigns, before audit or import preview. */
+  async discoverExistingCampaigns(options = {}) {
+    return this.callMcp("gtm_existing_campaign_discover", {
+      provider: options.provider,
+      integration_id: options.integrationId,
+      search: options.search,
+      limit: options.limit,
+      include_kernel_linked: options.includeKernelLinked,
+      include_provider_live: options.includeProviderLive
+    });
+  }
+  /** Run a read-only existing campaign audit with completeness, recommendations, safe next MCP JSON, and approval boundaries. */
+  async auditExistingCampaign(options) {
+    return this.callMcp("gtm_existing_campaign_audit", {
+      campaign_id: options.campaignId,
+      provider: options.provider,
+      provider_campaign_id: options.providerCampaignId,
+      campaign_name: options.campaignName,
+      days: options.days,
+      include_route_preview: options.includeRoutePreview,
+      include_memory: options.includeMemory,
+      include_brain: options.includeBrain
+    });
+  }
+  /** Discover the first matching existing provider campaign, then run the same read-only audit against that match. */
+  async auditExistingCampaignBySearch(options) {
+    const discovery = await this.discoverExistingCampaigns({
+      provider: options.provider,
+      integrationId: options.integrationId,
+      search: options.search,
+      limit: 1,
+      includeKernelLinked: options.includeKernelLinked,
+      includeProviderLive: options.includeProviderLive
+    });
+    const match = discovery.campaigns?.[0];
+    const campaignId = match?.linked_kernel_campaign_id || void 0;
+    const providerCampaignId = match?.provider_campaign_id || void 0;
+    if (!campaignId && !providerCampaignId) {
+      throw new Error(`No existing ${options.provider || discovery.provider || "provider"} campaign matched "${options.search}"`);
+    }
+    return this.auditExistingCampaign({
+      provider: options.provider || discovery.provider || match?.provider,
+      campaignId,
+      providerCampaignId,
+      campaignName: match?.name || match?.linked_kernel_campaign_name || void 0,
+      days: options.days,
+      includeRoutePreview: options.includeRoutePreview,
+      includeMemory: options.includeMemory,
+      includeBrain: options.includeBrain
+    });
+  }
+  /** Create a first-class GTM campaign object in the current workspace. */
+  async createCampaign(input) {
+    return this.callMcp("gtm_campaign_create", campaignCreateArgs(input));
+  }
+  /** Backfill historical campaigns, provider links, feedback, and memory into the GTM Kernel substrate. */
+  async importCampaignHistory(input) {
+    return this.callMcp("gtm_campaign_history_import", {
+      source: input.source,
+      dry_run: input.dryRun,
+      create_memory: input.createMemory,
+      campaigns: input.campaigns.map(campaignHistoryImportCampaignArgs)
+    });
+  }
+  /** Queue a Trigger-backed campaign history import for larger CMM/client backfills. */
+  async importCampaignHistoryRun(input) {
+    return this.callMcp("gtm_campaign_history_import_run", {
+      source: input.source,
+      dry_run: input.dryRun,
+      create_memory: input.createMemory,
+      campaigns: input.campaigns?.map(campaignHistoryImportCampaignArgs),
+      batches: input.batches?.map((batch) => ({
+        batch_id: batch.batchId,
+        campaigns: batch.campaigns.map(campaignHistoryImportCampaignArgs)
+      })),
+      batch_size: input.batchSize,
+      continue_on_error: input.continueOnError,
+      run_brain_cycle: input.runBrainCycle,
+      brain_cycle_write_mode: input.brainCycleWriteMode,
+      brain_cycle_phases: input.brainCyclePhases,
+      brain_cycle_days: input.brainCycleDays,
+      brain_cycle_network_days: input.brainCycleNetworkDays,
+      brain_cycle_min_sample_size: input.brainCycleMinSampleSize,
+      brain_cycle_limit: input.brainCycleLimit
+    });
+  }
+  /** Preview a provider-neutral history import payload derived from an existing campaign build. */
+  async previewCampaignBuildBackfill(options) {
+    return this.callMcp("gtm_campaign_build_backfill_preview", {
+      campaign_build_id: options.campaignBuildId,
+      include_sample_rows: options.includeSampleRows,
+      include_copy_samples: options.includeCopySamples,
+      sample_row_limit: options.sampleRowLimit,
+      create_memory: options.createMemory,
+      include_payload: options.includePayload
+    });
+  }
+  /** Queue campaign-build history backfills through the Trigger-backed history import runner. */
+  async runCampaignBuildBackfill(input) {
+    return this.callMcp("gtm_campaign_build_backfill_run", {
+      campaign_build_ids: input.campaignBuildIds,
+      source: input.source,
+      dry_run: input.dryRun,
+      create_memory: input.createMemory,
+      include_sample_rows: input.includeSampleRows,
+      include_copy_samples: input.includeCopySamples,
+      include_payload: input.includePayload,
+      sample_row_limit: input.sampleRowLimit,
+      batch_size: input.batchSize,
+      continue_on_error: input.continueOnError,
+      run_brain_cycle: input.runBrainCycle,
+      brain_cycle_write_mode: input.brainCycleWriteMode,
+      brain_cycle_phases: input.brainCyclePhases,
+      brain_cycle_days: input.brainCycleDays,
+      brain_cycle_network_days: input.brainCycleNetworkDays,
+      brain_cycle_min_sample_size: input.brainCycleMinSampleSize,
+      brain_cycle_limit: input.brainCycleLimit
+    });
+  }
+  /** Inspect Campaign Builder to Kernel backfill status for one build. */
+  async campaignBuildBackfillStatus(options) {
+    return this.callMcp("gtm_campaign_build_backfill_status", {
+      campaign_build_id: options.campaignBuildId,
+      include_phases: options.includePhases,
+      include_linked_campaign: options.includeLinkedCampaign
+    });
+  }
+  /** List first-class GTM campaign objects in the current workspace. */
+  async listCampaigns(options = {}) {
+    return this.callMcp("gtm_campaign_list", {
+      status: options.status,
+      provider: options.provider,
+      search: options.search,
+      limit: options.limit,
+      include_archived: options.includeArchived
+    });
+  }
+  /** Get one campaign with provider links, logs, feedback summary, memory, and Brain patterns. */
+  async getCampaign(campaignId, options = {}) {
+    return this.callMcp("gtm_campaign_get", {
+      campaign_id: campaignId,
+      log_limit: options.logLimit,
+      memory_limit: options.memoryLimit
+    });
+  }
+  /** Inspect campaign execution state, linked build progress, provider readiness, feedback, memory, and next actions. */
+  async campaignExecutionStatus(options) {
+    return this.callMcp("gtm_campaign_execution_status", {
+      campaign_id: options.campaignId,
+      campaign_build_id: options.campaignBuildId,
+      include_provider_readiness: options.includeProviderReadiness,
+      include_feedback: options.includeFeedback,
+      include_memory: options.includeMemory,
+      include_recent_log: options.includeRecentLog,
+      log_limit: options.logLimit,
+      memory_limit: options.memoryLimit
+    });
+  }
+  /** Inspect whether a campaign/build is ready for Brain learning and return exact learning-cycle args. */
+  async campaignLearningStatus(options) {
+    return this.callMcp("gtm_campaign_learning_status", {
+      campaign_id: options.campaignId,
+      campaign_build_id: options.campaignBuildId,
+      days: options.days,
+      network_days: options.networkDays,
+      min_sample_size: options.minSampleSize,
+      min_workspace_count: options.minWorkspaceCount,
+      min_privacy_k: options.minPrivacyK,
+      include_memory: options.includeMemory,
+      include_network: options.includeNetwork,
+      write_mode: options.writeMode,
+      limit: options.limit
+    });
+  }
+  /** Update a first-class GTM campaign and append the associated campaign log entry. */
+  async updateCampaign(input) {
+    return this.callMcp("gtm_campaign_update", campaignUpdateArgs(input));
+  }
+  /** Append an auditable campaign action with actor, rationale, payload, and optional idempotency key. */
+  async logCampaign(campaignId, input) {
+    return this.callMcp("gtm_campaign_log", campaignLogArgs({ ...input, campaignId }));
+  }
+  /** Ingest provider-neutral feedback from Instantly, Smartlead, HeyReach, webhook, or a custom MCP. */
+  async ingestFeedback(input) {
+    return this.callMcp("gtm_feedback_ingest", {
+      source: input.source,
+      campaign_id: input.campaignId,
+      campaign_build_id: input.campaignBuildId,
+      provider_campaign_id: input.providerCampaignId,
+      events: input.events,
+      provider_payload: input.providerPayload,
+      create_memory: input.createMemory,
+      write_routine_outcomes: input.writeRoutineOutcomes
+    });
+  }
+  /** Normalize Instantly webhook/pull payloads and ingest row-level feedback through the GTM Kernel. */
+  async syncInstantlyFeedback(input) {
+    return this.callMcp("gtm_instantly_feedback_sync", {
+      campaign_id: input.campaignId,
+      campaign_build_id: input.campaignBuildId,
+      provider_campaign_id: input.providerCampaignId,
+      instantly_campaign_id: input.instantlyCampaignId,
+      sync_mode: input.syncMode,
+      events: input.events,
+      provider_payload: input.providerPayload,
+      cursor: input.cursor,
+      since: input.since,
+      until: input.until,
+      aggregate_snapshot: input.aggregateSnapshot,
+      create_memory: input.createMemory,
+      write_routine_outcomes: input.writeRoutineOutcomes
+    });
+  }
+  /** Start a background Instantly webhook-events pull and route results into the GTM feedback loop. */
+  async pullInstantlyFeedback(input) {
+    return this.callMcp("gtm_instantly_feedback_pull", {
+      campaign_id: input.campaignId,
+      campaign_build_id: input.campaignBuildId,
+      provider_link_id: input.providerLinkId,
+      provider_campaign_id: input.providerCampaignId,
+      instantly_campaign_id: input.instantlyCampaignId,
+      integration_id: input.integrationId,
+      cursor: input.cursor,
+      from: input.from,
+      to: input.to,
+      limit: input.limit,
+      max_pages: input.maxPages,
+      create_memory: input.createMemory,
+      write_routine_outcomes: input.writeRoutineOutcomes,
+      dry_run: input.dryRun,
+      run_brain_cycle: input.runBrainCycle,
+      brain_cycle_write_mode: input.brainCycleWriteMode,
+      brain_cycle_phases: input.brainCyclePhases,
+      brain_cycle_min_ingested: input.brainCycleMinIngested,
+      brain_cycle_min_interval_minutes: input.brainCycleMinIntervalMinutes
+    });
+  }
+  /** Prepare a secure Instantly feedback webhook URL for a campaign provider link. */
+  async prepareInstantlyFeedbackWebhook(input) {
+    return this.callMcp("gtm_instantly_feedback_webhook_prepare", {
+      campaign_id: input.campaignId,
+      campaign_build_id: input.campaignBuildId,
+      provider_link_id: input.providerLinkId,
+      provider_campaign_id: input.providerCampaignId,
+      instantly_campaign_id: input.instantlyCampaignId,
+      integration_id: input.integrationId,
+      provider_workspace_id: input.providerWorkspaceId,
+      provider_account_id: input.providerAccountId,
+      rotate_secret: input.rotateSecret,
+      run_brain_cycle: input.runBrainCycle,
+      brain_cycle_write_mode: input.brainCycleWriteMode,
+      brain_cycle_phases: input.brainCyclePhases,
+      brain_cycle_min_ingested: input.brainCycleMinIngested,
+      brain_cycle_min_interval_minutes: input.brainCycleMinIntervalMinutes
+    });
+  }
+  /** Preview anonymized Instantly workspace sources registered for Kernel import. */
+  async previewKernelImport(input = {}) {
+    return this.callMcp("gtm_kernel_import_preview", {
+      source_ids: input.sourceIds,
+      include_leads: input.includeLeads,
+      include_replies: input.includeReplies,
+      include_private_copy: input.includePrivateCopy,
+      max_pages: input.maxPages,
+      limit: input.limit
+    });
+  }
+  /** Queue the read-only Instantly-to-GTM Kernel import. Live writes require writeApproved. */
+  async runKernelImport(input = {}) {
+    return this.callMcp("gtm_kernel_import_run", {
+      source_ids: input.sourceIds,
+      dry_run: input.dryRun,
+      write_approved: input.writeApproved,
+      include_leads: input.includeLeads,
+      include_replies: input.includeReplies,
+      include_private_copy: input.includePrivateCopy,
+      private_copy_approved: input.privateCopyApproved,
+      promote_global_patterns: input.promoteGlobalPatterns,
+      min_global_privacy_k: input.minGlobalPrivacyK,
+      max_pages: input.maxPages,
+      limit: input.limit
+    });
+  }
+  /** Queue Brain distillation over imported Instantly memory with abstracted-only outputs. */
+  async runBrainDistillation(input = {}) {
+    return this.callMcp("gtm_brain_distill_run", {
+      source_ids: input.sourceIds,
+      write_mode: input.writeMode,
+      write_approved: input.writeApproved,
+      brain_cycle_phases: input.brainCyclePhases,
+      days: input.days,
+      network_days: input.networkDays,
+      min_sample_size: input.minSampleSize,
+      min_workspace_count: input.minWorkspaceCount,
+      min_privacy_k: input.minPrivacyK
+    });
+  }
+  /** Prepare a provider-agnostic feedback webhook URL for Smartlead, HeyReach, Airbyte, or custom sender events. */
+  async prepareFeedbackWebhook(input) {
+    return this.callMcp("gtm_feedback_webhook_prepare", {
+      provider: input.provider,
+      campaign_id: input.campaignId,
+      campaign_build_id: input.campaignBuildId,
+      provider_link_id: input.providerLinkId,
+      provider_campaign_id: input.providerCampaignId,
+      integration_id: input.integrationId,
+      provider_workspace_id: input.providerWorkspaceId,
+      provider_account_id: input.providerAccountId,
+      rotate_secret: input.rotateSecret,
+      run_brain_cycle: input.runBrainCycle,
+      brain_cycle_write_mode: input.brainCycleWriteMode,
+      brain_cycle_phases: input.brainCyclePhases,
+      brain_cycle_min_ingested: input.brainCycleMinIngested,
+      brain_cycle_min_interval_minutes: input.brainCycleMinIntervalMinutes
+    });
+  }
+  /** Search ranked workspace campaign memory instead of dumping raw history. */
+  async searchMemory(options = {}) {
+    return this.callMcp("gtm_memory_search", {
+      query: options.query,
+      campaign_id: options.campaignId,
+      memory_type: options.memoryType,
+      keywords: options.keywords,
+      outcome_type: options.outcomeType,
+      target_icp: options.targetIcp,
+      layers: options.layers,
+      provider_chain: options.providerChain,
+      dimension_filters: options.dimensionFilters,
+      require_dimension_match: options.requireDimensionMatch,
+      days: options.days,
+      limit: options.limit
+    });
+  }
+  /** Retrieve evidence-backed workspace and privacy-safe aggregate Brain patterns. */
+  async brainPatterns(options = {}) {
+    return this.callMcp("gtm_brain_patterns", {
+      campaign_id: options.campaignId,
+      pattern_type: options.patternType,
+      segment_key: options.segmentKey,
+      include_global: options.includeGlobal,
+      min_confidence: options.minConfidence,
+      limit: options.limit
+    });
+  }
+  /** Plan the closed-loop Brain learning sequence without recursively executing Edge Functions. */
+  async learningCyclePlan(input = {}) {
+    return this.callMcp("gtm_brain_learning_cycle_plan", {
+      campaign_id: input.campaignId,
+      campaign_brief: input.campaignBrief,
+      target_icp: input.targetIcp,
+      layers: input.layers,
+      provider_chain: input.providerChain,
+      lead_source: input.leadSource,
+      days: input.days,
+      network_days: input.networkDays,
+      min_sample_size: input.minSampleSize,
+      min_workspace_count: input.minWorkspaceCount,
+      min_privacy_k: input.minPrivacyK,
+      include_memory: input.includeMemory,
+      include_network: input.includeNetwork,
+      write_mode: input.writeMode,
+      limit: input.limit
+    });
+  }
+  /** Queue the closed-loop Brain learning sequence in Trigger. */
+  async learningCycleRun(input = {}) {
+    return this.callMcp("gtm_brain_learning_cycle_run", {
+      campaign_id: input.campaignId,
+      campaign_brief: input.campaignBrief,
+      target_icp: input.targetIcp,
+      layers: input.layers,
+      provider_chain: input.providerChain,
+      lead_source: input.leadSource,
+      days: input.days,
+      network_days: input.networkDays,
+      min_sample_size: input.minSampleSize,
+      min_workspace_count: input.minWorkspaceCount,
+      min_privacy_k: input.minPrivacyK,
+      include_memory: input.includeMemory,
+      include_network: input.includeNetwork,
+      write_mode: input.writeMode,
+      phases: input.phases,
+      continue_on_error: input.continueOnError,
+      limit: input.limit
+    });
+  }
+  /** Seed campaign defaults from active Brain patterns and ranked workspace memory. */
+  async seedBrainDefaults(input = {}) {
+    return this.callMcp("gtm_brain_seed_defaults", {
+      campaign_id: input.campaignId,
+      campaign_brief: input.campaignBrief,
+      target_icp: input.targetIcp,
+      layers: input.layers,
+      include_global: input.includeGlobal,
+      include_memory: input.includeMemory,
+      min_confidence: input.minConfidence,
+      write_campaign: input.writeCampaign,
+      limit: input.limit
+    });
+  }
+  /** Extract within-workspace Brain V1 patterns from feedback, provider links, campaigns, and memory. */
+  async extractBrainPatterns(input = {}) {
+    return this.callMcp("gtm_brain_extract_patterns", {
+      campaign_id: input.campaignId,
+      days: input.days,
+      pattern_types: input.patternTypes,
+      min_sample_size: input.minSampleSize,
+      include_memory: input.includeMemory,
+      write_patterns: input.writePatterns,
+      dry_run: input.dryRun,
+      replace_existing: input.replaceExisting,
+      limit: input.limit
+    });
+  }
+  /** Aggregate opted-in workspace Brain patterns into privacy-safe global defaults. */
+  async aggregateBrainPatterns(input = {}) {
+    return this.callMcp("gtm_brain_aggregate_patterns", {
+      days: input.days,
+      pattern_types: input.patternTypes,
+      min_workspace_count: input.minWorkspaceCount,
+      min_privacy_k: input.minPrivacyK,
+      min_confidence: input.minConfidence,
+      include_low_confidence: input.includeLowConfidence,
+      write_patterns: input.writePatterns,
+      dry_run: input.dryRun,
+      replace_existing: input.replaceExisting,
+      limit: input.limit
+    });
+  }
+  /** Aggregate opted-in workspace deliverability calibrations into privacy-safe global calibration rows. */
+  async aggregateBrainCalibrations(input = {}) {
+    return this.callMcp("gtm_brain_aggregate_calibrations", {
+      days: input.days,
+      dimension_types: input.dimensionTypes,
+      min_workspace_count: input.minWorkspaceCount,
+      min_privacy_k: input.minPrivacyK,
+      min_confidence: input.minConfidence,
+      include_low_confidence: input.includeLowConfidence,
+      write_calibrations: input.writeCalibrations,
+      dry_run: input.dryRun,
+      replace_existing: input.replaceExisting,
+      limit: input.limit
+    });
+  }
+  /** Calibrate workspace deliverability predictions against actual bounce feedback. */
+  async calibrateDeliverability(input = {}) {
+    return this.callMcp("gtm_brain_calibrate_deliverability", {
+      campaign_id: input.campaignId,
+      days: input.days,
+      dimension_types: input.dimensionTypes,
+      min_sample_size: input.minSampleSize,
+      dry_run: input.dryRun,
+      write_calibrations: input.writeCalibrations,
+      write_patterns: input.writePatterns,
+      replace_existing: input.replaceExisting,
+      limit: input.limit
+    });
+  }
+  /** Estimate pre-send delivery risk from campaign context, lead samples, and Brain calibrations. */
+  async deliveryRisk(input = {}) {
+    return this.callMcp("gtm_brain_delivery_risk", {
+      campaign_id: input.campaignId,
+      provider_chain: input.providerChain,
+      lead_source: input.leadSource,
+      target_icp: input.targetIcp,
+      lead_samples: input.leadSamples,
+      include_global: input.includeGlobal,
+      min_confidence: input.minConfidence,
+      limit: input.limit
+    });
+  }
+  /** Rank provider-chain, ICP, source, copy, and sequence failure patterns without writing raw lead data. */
+  async failurePatterns(options = {}) {
+    return this.callMcp("gtm_brain_failure_patterns", {
+      campaign_id: options.campaignId,
+      days: options.days,
+      min_sample_size: options.minSampleSize,
+      dimensions: options.dimensions,
+      include_existing_patterns: options.includeExistingPatterns,
+      include_global: options.includeGlobal,
+      limit: options.limit
+    });
+  }
+  /** List provider presets agents can wire into GTM campaign layers, including BYO and Signaliz fallback options. */
+  async providerCatalog(options = {}) {
+    return this.callMcp("gtm_provider_catalog", {
+      provider_id: options.providerId,
+      layer: options.layer,
+      include_planned: options.includePlanned,
+      include_layer_catalog: options.includeLayerCatalog
+    });
+  }
+  /** Inspect GTM integration activation cards for UI and agent routing without writing state. */
+  async integrationsActivationStatus(options = {}) {
+    return this.callMcp("gtm_integrations_activation_status", {
+      campaign_id: options.campaignId,
+      layer: options.layer,
+      include_planned: options.includePlanned,
+      include_connections: options.includeConnections
+    });
+  }
+  /** Compose Memory, Brain defaults, failure intelligence, and provider routes into a read-only campaign build plan. */
+  async campaignBuildPlan(input = {}) {
+    return this.callMcp("gtm_campaign_build_plan", {
+      campaign_id: input.campaignId,
+      campaign_build_id: input.campaignBuildId,
+      campaign_brief: input.campaignBrief,
+      target_icp: input.targetIcp,
+      lead_count: input.leadCount,
+      layers: input.layers,
+      preferred_providers: input.preferredProviders,
+      memory_dimension_filters: input.memoryDimensionFilters,
+      require_memory_dimension_match: input.requireMemoryDimensionMatch,
+      include_memory: input.includeMemory,
+      include_brain: input.includeBrain,
+      include_provider_routes: input.includeProviderRoutes,
+      include_failure_patterns: input.includeFailurePatterns,
+      include_planned_providers: input.includePlannedProviders,
+      days: input.days,
+      limit: input.limit
+    });
+  }
+  /** Persist a reviewed campaign build plan into a campaign object and audit log. Dry-run first by default. */
+  async commitCampaignBuildPlan(input = {}) {
+    return this.callMcp("gtm_campaign_build_plan_commit", {
+      campaign_id: input.campaignId,
+      campaign_build_id: input.campaignBuildId,
+      name: input.name,
+      campaign_brief: input.campaignBrief,
+      target_icp: input.targetIcp,
+      lead_count: input.leadCount,
+      layers: input.layers,
+      preferred_providers: input.preferredProviders,
+      plan_snapshot: input.planSnapshot,
+      sequences: input.sequences,
+      lead_list_refs: input.leadListRefs,
+      send_config: input.sendConfig,
+      brain_config: input.brainConfig,
+      metadata: input.metadata,
+      status: input.status,
+      approval_required: input.approvalRequired,
+      actor_type: input.actorType,
+      actor_id: input.actorId,
+      rationale: input.rationale,
+      idempotency_key: input.idempotencyKey,
+      dry_run: input.dryRun,
+      confirm: input.confirm
+    });
+  }
+  /** Derive exact build_campaign arguments from a committed campaign object without creating a build. */
+  async prepareCampaignBuildExecution(input) {
+    return this.callMcp("gtm_campaign_build_execution_prepare", {
+      campaign_id: input.campaignId,
+      target_count: input.targetCount,
+      allow_downscale: input.allowDownscale,
+      dry_run: input.dryRun,
+      confirm_spend: input.confirmSpend,
+      include_brain_context: input.includeBrainContext,
+      require_delivery_risk_clearance: input.requireDeliveryRiskClearance,
+      delivery_risk: input.deliveryRisk,
+      dedup_keys: input.dedupKeys,
+      policy: input.policy,
+      signals: input.signals,
+      qualification: input.qualification,
+      copy: input.copy,
+      delivery: input.delivery,
+      enhancers: input.enhancers
+    });
+  }
+  /** Prepare exact recipe, route, preview, and delivery arguments for a provider without writing state. */
+  async prepareProviderRecipe(input) {
+    return this.callMcp("gtm_provider_recipe_prepare", {
+      provider_id: input.providerId,
+      provider_name: input.providerName,
+      description: input.description,
+      layer_capabilities: input.layerCapabilities,
+      invocation_type: input.invocationType,
+      auth_strategy: input.authStrategy,
+      endpoint_url: input.endpointUrl,
+      http_method: input.httpMethod,
+      secret_ref: input.secretRef,
+      workspace_integration_id: input.workspaceIntegrationId,
+      workspace_mcp_server_id: input.workspaceMcpServerId,
+      workspace_connection_id: input.workspaceConnectionId,
+      request_template: input.requestTemplate,
+      response_mapping: input.responseMapping,
+      input_schema: input.inputSchema,
+      output_schema: input.outputSchema,
+      readiness: input.readiness,
+      metadata: input.metadata,
+      layer: input.layer,
+      campaign_id: input.campaignId,
+      use_signaliz_fallback: input.useSignalizFallback,
+      priority: input.priority,
+      status: input.status,
+      sample_records: input.sampleRecords,
+      context: input.context
+    });
+  }
+  /** Prepare exact Clay webhook recipe, route, preview, and delivery arguments without writing state. */
+  async prepareClayWebhook(input = {}) {
+    return this.callMcp("gtm_clay_webhook_prepare", {
+      endpoint_url: input.endpointUrl,
+      secret_ref: input.secretRef,
+      layer: input.layer,
+      campaign_id: input.campaignId,
+      use_signaliz_fallback: input.useSignalizFallback,
+      priority: input.priority,
+      status: input.status,
+      sample_records: input.sampleRecords,
+      context: input.context
+    });
+  }
+  /** Dry-run or confirm a one-call provider route activation across one or more GTM layers. */
+  async activateProviderRoute(input) {
+    return this.callMcp("gtm_provider_route_activate", {
+      provider_id: input.providerId,
+      provider_name: input.providerName,
+      description: input.description,
+      layer: input.layer,
+      layers: input.layers,
+      campaign_id: input.campaignId,
+      invocation_type: input.invocationType,
+      auth_strategy: input.authStrategy,
+      endpoint_url: input.endpointUrl,
+      http_method: input.httpMethod,
+      secret_ref: input.secretRef,
+      workspace_integration_id: input.workspaceIntegrationId,
+      workspace_mcp_server_id: input.workspaceMcpServerId,
+      workspace_connection_id: input.workspaceConnectionId,
+      use_signaliz_fallback: input.useSignalizFallback,
+      priority: input.priority,
+      route_config: input.routeConfig,
+      request_template: input.requestTemplate,
+      response_mapping: input.responseMapping,
+      input_schema: input.inputSchema,
+      output_schema: input.outputSchema,
+      readiness: input.readiness,
+      metadata: input.metadata,
+      status: input.status,
+      route_status: input.routeStatus,
+      replace_existing_routes: input.replaceExistingRoutes,
+      dry_run: input.dryRun,
+      confirm: input.confirm,
+      sample_records: input.sampleRecords,
+      context: input.context
+    });
+  }
+  /** List Signaliz-managed integrations, external MCP servers, app connections, recipes, and layer routes. */
+  async listConnections(options = {}) {
+    return this.callMcp("gtm_connections_list", {
+      kind: options.kind,
+      include_disconnected: options.includeDisconnected
+    });
+  }
+  /** Register a workspace connection for the Kernel connection layer. */
+  async registerConnection(input) {
+    return this.callMcp("gtm_connection_register", {
+      connection_kind: input.connectionKind,
+      name: input.name,
+      server_url: input.serverUrl,
+      auth_type: input.authType,
+      auth_config: input.authConfig,
+      enabled_tools: input.enabledTools,
+      preset_id: input.presetId,
+      vendor_id: input.vendorId,
+      service_category: input.serviceCategory,
+      connection_type: input.connectionType,
+      status: input.status,
+      metadata: input.metadata
+    });
+  }
+  /** Create a reusable integration recipe for BYO providers such as Clay webhooks, Apollo, AI Ark, Octave, or Airbyte. */
+  async createIntegrationRecipe(input) {
+    return this.callMcp("gtm_integration_recipe_create", {
+      provider_id: input.providerId,
+      provider_name: input.providerName,
+      description: input.description,
+      layer_capabilities: input.layerCapabilities,
+      invocation_type: input.invocationType,
+      auth_strategy: input.authStrategy,
+      workspace_integration_id: input.workspaceIntegrationId,
+      workspace_mcp_server_id: input.workspaceMcpServerId,
+      workspace_connection_id: input.workspaceConnectionId,
+      endpoint_url: input.endpointUrl,
+      http_method: input.httpMethod,
+      request_template: input.requestTemplate,
+      response_mapping: input.responseMapping,
+      input_schema: input.inputSchema,
+      output_schema: input.outputSchema,
+      readiness: input.readiness,
+      metadata: input.metadata,
+      status: input.status
+    });
+  }
+  /** Set a workspace or campaign provider route for one GTM layer. */
+  async setLayerRoute(input) {
+    return this.callMcp("gtm_layer_route_set", {
+      layer: input.layer,
+      provider_id: input.providerId,
+      campaign_id: input.campaignId,
+      recipe_id: input.recipeId,
+      priority: input.priority,
+      use_signaliz_fallback: input.useSignalizFallback,
+      route_config: input.routeConfig,
+      status: input.status
+    });
+  }
+  /** Get effective layer routes, including Signaliz fallback availability. */
+  async getLayerRoutes(options = {}) {
+    return this.callMcp("gtm_layer_routes_get", {
+      campaign_id: options.campaignId,
+      layer: options.layer
+    });
+  }
+  /** Preview one effective layer route before external delivery or provider execution. */
+  async previewLayerRoute(input) {
+    return this.callMcp("gtm_layer_route_preview", {
+      layer: input.layer,
+      campaign_id: input.campaignId,
+      sample_records: input.sampleRecords,
+      context: input.context
+    });
+  }
+  /** List Nango-backed action tools for a workspace connection without executing them. */
+  async listNangoTools(options = {}) {
+    return this.callMcp("nango_mcp_tools_list", {
+      workspace_connection_id: options.workspaceConnectionId,
+      connection_id: options.connectionId,
+      provider_config_key: options.providerConfigKey,
+      integration_id: options.integrationId,
+      nango_connection_id: options.nangoConnectionId,
+      format: options.format,
+      include_raw: options.includeRaw
+    });
+  }
+  /** Dry-run or execute a Nango-backed action tool through the approval-aware MCP bridge. */
+  async callNangoTool(input) {
+    return this.callMcp("nango_mcp_tool_call", {
+      workspace_connection_id: input.workspaceConnectionId,
+      connection_id: input.connectionId,
+      provider_config_key: input.providerConfigKey,
+      integration_id: input.integrationId,
+      nango_connection_id: input.nangoConnectionId,
+      action_name: input.actionName,
+      tool_name: input.toolName,
+      input: input.input,
+      async: input.async,
+      max_retries: input.maxRetries,
+      dry_run: input.dryRun,
+      confirm: input.confirm,
+      confirm_write: input.confirmWrite
+    });
+  }
+  /** Poll an async Nango action result by action id or status URL. */
+  async getNangoActionResult(input) {
+    return this.callMcp("nango_mcp_action_result_get", {
+      action_id: input.actionId,
+      status_url: input.statusUrl
+    });
+  }
+  /** Deliver approved campaign-layer records to a webhook recipe, starting with Clay-style webhooks. */
+  async deliverWebhook(input) {
+    return this.callMcp("gtm_webhook_deliver", {
+      recipe_id: input.recipeId,
+      campaign_id: input.campaignId,
+      layer: input.layer,
+      records: input.records,
+      context: input.context,
+      idempotency_key: input.idempotencyKey
+    });
+  }
+  async callMcp(tool, args) {
+    return this.client.mcp("tools/call", { name: tool, arguments: compact2(args) });
+  }
+};
+function campaignCreateArgs(input) {
+  return {
+    name: input.name,
+    description: input.description,
+    source: input.source,
+    status: input.status,
+    campaign_build_id: input.campaignBuildId,
+    campaign_builder_job_id: input.campaignBuilderJobId,
+    routine_id: input.routineId,
+    target_icp: input.targetIcp,
+    sequences: input.sequences,
+    lead_list_refs: input.leadListRefs,
+    send_config: input.sendConfig,
+    provider_links: input.providerLinks?.map(providerLinkArgs),
+    brain_config: input.brainConfig,
+    metadata: input.metadata,
+    log: input.log ? campaignLogArgs(input.log) : void 0
+  };
+}
+function campaignHistoryImportCampaignArgs(input) {
+  return {
+    campaign_id: input.campaignId,
+    idempotency_key: input.idempotencyKey,
+    name: input.name,
+    description: input.description,
+    source: input.source,
+    status: input.status,
+    campaign_build_id: input.campaignBuildId,
+    campaign_builder_job_id: input.campaignBuilderJobId,
+    routine_id: input.routineId,
+    target_icp: input.targetIcp,
+    sequences: input.sequences,
+    lead_list_refs: input.leadListRefs,
+    send_config: input.sendConfig,
+    performance_metrics: input.performanceMetrics,
+    brain_config: input.brainConfig,
+    memory_summary: input.memorySummary,
+    metadata: input.metadata,
+    provider_links: input.providerLinks?.map(providerLinkArgs),
+    feedback_events: input.feedbackEvents,
+    memory_items: input.memoryItems?.map(campaignHistoryMemoryArgs),
+    started_at: input.startedAt,
+    completed_at: input.completedAt,
+    summary: input.summary,
+    memory_summary_text: input.memorySummaryText
+  };
+}
+function campaignHistoryMemoryArgs(input) {
+  return {
+    idempotency_key: input.idempotencyKey,
+    memory_type: input.memoryType,
+    title: input.title,
+    content: input.content,
+    keywords: input.keywords,
+    dimensions: input.dimensions,
+    outcome_type: input.outcomeType,
+    outcome_value: input.outcomeValue,
+    sample_size: input.sampleSize,
+    confidence: input.confidence,
+    shareable: input.shareable,
+    redaction_state: input.redactionState,
+    metadata: input.metadata,
+    recency_at: input.recencyAt
+  };
+}
+function campaignUpdateArgs(input) {
+  return {
+    campaign_id: input.campaignId,
+    name: input.name,
+    description: input.description,
+    status: input.status,
+    target_icp: input.targetIcp,
+    sequences: input.sequences,
+    lead_list_refs: input.leadListRefs,
+    send_config: input.sendConfig,
+    performance_metrics: input.performanceMetrics,
+    brain_config: input.brainConfig,
+    memory_summary: input.memorySummary,
+    metadata: input.metadata,
+    provider_links: input.providerLinks?.map(providerLinkArgs),
+    log: input.log ? campaignLogArgs(input.log) : void 0
+  };
+}
+function campaignLogArgs(input) {
+  return {
+    campaign_id: input.campaignId,
+    actor_type: input.actorType,
+    actor_id: input.actorId,
+    action: input.action,
+    rationale: input.rationale,
+    payload: input.payload,
+    idempotency_key: input.idempotencyKey
+  };
+}
+function providerLinkArgs(input) {
+  return {
+    provider: input.provider,
+    provider_campaign_id: input.providerCampaignId,
+    integration_id: input.integrationId,
+    provider_workspace_id: input.providerWorkspaceId,
+    provider_account_id: input.providerAccountId,
+    status: input.status,
+    metadata: input.metadata
+  };
+}
+function compact2(value) {
+  if (Array.isArray(value)) return value.map((item) => compact2(item)).filter((item) => item !== void 0);
+  if (!value || typeof value !== "object") return value;
+  const out = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (child === void 0) continue;
+    const compacted = compact2(child);
+    if (compacted === void 0) continue;
+    out[key] = compacted;
+  }
+  return out;
+}
+
+// src/index.ts
+function inferMcpToolCategory(toolName) {
+  if (typeof toolName !== "string" || !toolName) return void 0;
+  if (toolName.startsWith("ops_") || toolName === "get_ops_readiness" || toolName === "get_gtm_ops_readiness" || toolName.startsWith("gtm_") || [
+    "list_routines",
+    "create_routine",
+    "update_routine",
+    "run_routine_now",
+    "get_routine",
+    "get_routine_ticks",
+    "get_tick_items",
+    "get_last_tick_items",
+    "chain_routines",
+    "get_chain_status",
+    "launch_campaign",
+    "quickstart_gtm_book",
+    "list_campaigns",
+    "campaign_performance",
+    "tune_campaign",
+    "emit_event",
+    "approvals_list",
+    "list_output_sinks",
+    "create_output_sink",
+    "update_output_sink",
+    "delete_output_sink",
+    "attach_sink_to_routine"
+  ].includes(toolName)) {
+    return "ops";
+  }
+  if ([
+    "find_emails_with_verification",
+    "verify_email",
+    "enrich_company_signals",
+    "company_intelligence",
+    "find_contacts_with_email",
+    "execute_primitive"
+  ].includes(toolName)) {
+    return "enrichment";
+  }
+  if (toolName.includes("icp")) return "icp";
+  if (toolName.startsWith("ai_clean_")) return "data_cleaning";
+  if (toolName.includes("system") || toolName.includes("workflow")) return "automation";
+  if (toolName.includes("agent") || toolName.includes("platform_health") || toolName === "discover_capabilities") return "observability";
+  return void 0;
+}
+function asRecord3(value) {
+  return value && typeof value === "object" ? value : void 0;
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : void 0;
+}
+function asObjectSchema(value) {
+  return asRecord3(value);
+}
+var Signaliz = class {
+  constructor(config) {
+    this.client = new HttpClient(config);
+    this.emails = new Emails(this.client);
+    this.signals = new Signals(this.client);
+    this.systems = new Systems(this.client);
+    this.runs = new Runs(this.client);
+    this.http = new Http(this.client);
+    this.campaigns = new Campaigns(this.client);
+    this.campaignBuilderAgent = new CampaignBuilderAgent(this.client);
+    this.icps = new Icps(this.client);
+    this.leads = new Leads(this.client);
+    this.ops = new Ops(this.client);
+    this.ai = new Ai(this.client);
+    this.gtm = new GtmKernel(this.client);
+  }
+  /** Get current workspace info including credits */
+  async getWorkspace() {
+    const data = await this.client.mcp("tools/call", {
+      name: "get_workspace",
+      arguments: {}
+    });
+    return {
+      id: data.workspace_id ?? data.id,
+      name: data.workspace_name ?? data.name ?? "Unknown",
+      creditsRemaining: data.credits_remaining ?? data.credit_balance ?? data.credits ?? 0,
+      plan: data.plan ?? data.plan_name ?? "unknown"
+    };
+  }
+  /** Get MCP platform health and recent latency/error-rate signals */
+  async getPlatformHealth() {
+    const data = await this.client.mcp("tools/call", {
+      name: "get_platform_health",
+      arguments: {}
+    });
+    return {
+      status: data.status ?? "unknown",
+      period: data.period,
+      totalRequests: data.total_requests ?? data.totalRequests ?? 0,
+      errorRate: data.error_rate ?? data.errorRate ?? "0%",
+      latency: {
+        p50: data.latency?.p50 ?? 0,
+        p95: data.latency?.p95 ?? 0,
+        p99: data.latency?.p99 ?? 0,
+        sampleCount: data.latency?.sample_count ?? data.latency?.sampleCount,
+        source: data.latency?.source
+      }
+    };
+  }
+  /** Alias for getPlatformHealth, useful in health-check scripts */
+  async health() {
+    return this.getPlatformHealth();
+  }
+  /** List all available MCP tools */
+  async listTools() {
+    const data = await this.client.mcp("tools/list", {});
+    const tools = data?.tools ?? data ?? [];
+    return tools.map((t) => ({
+      name: typeof t.name === "string" ? t.name : "",
+      description: String(t.description ?? "").slice(0, 120),
+      category: typeof t.annotations?.category === "string" ? t.annotations.category : inferMcpToolCategory(t.name),
+      costCredits: typeof t.annotations?.cost_credits === "number" ? t.annotations.cost_credits : void 0,
+      contractVersion: typeof (t.annotations?.contract_version ?? t.annotations?.contract?.contract_version) === "string" ? t.annotations?.contract_version ?? t.annotations?.contract?.contract_version : void 0,
+      permissionLevel: typeof (t.annotations?.permission_level ?? t.annotations?.contract?.permission_level) === "string" ? t.annotations?.permission_level ?? t.annotations?.contract?.permission_level : void 0,
+      authScopes: asStringArray(t.annotations?.auth_scopes ?? t.annotations?.contract?.auth_scopes),
+      idempotent: typeof (t.annotations?.idempotentHint ?? t.annotations?.idempotent ?? t.annotations?.contract?.idempotent) === "boolean" ? t.annotations?.idempotentHint ?? t.annotations?.idempotent ?? t.annotations?.contract?.idempotent : void 0,
+      destructive: typeof (t.annotations?.destructiveHint ?? t.annotations?.destructive ?? t.annotations?.contract?.destructive) === "boolean" ? t.annotations?.destructiveHint ?? t.annotations?.destructive ?? t.annotations?.contract?.destructive : void 0,
+      retryable: typeof (t.annotations?.retryable ?? t.annotations?.contract?.retryable) === "boolean" ? t.annotations?.retryable ?? t.annotations?.contract?.retryable : void 0,
+      rateLimitKey: typeof (t.annotations?.rate_limit_key ?? t.annotations?.contract?.rate_limit_key) === "string" ? t.annotations?.rate_limit_key ?? t.annotations?.contract?.rate_limit_key : void 0,
+      observability: asRecord3(t.annotations?.observability ?? t.annotations?.contract?.observability),
+      inputSchema: asObjectSchema(t.inputSchema ?? t.input_schema ?? t.annotations?.contract?.input_schema),
+      outputSchema: asObjectSchema(t.outputSchema ?? t.output_schema ?? t.annotations?.contract?.output_schema),
+      annotations: asRecord3(t.annotations)
+    }));
+  }
+  /** Discover tools by natural language query */
+  async discover(query, category) {
+    const data = await this.client.mcp("tools/call", {
+      name: "discover_capabilities",
+      arguments: { query, category }
+    });
+    return (data.matches ?? []).map((m) => ({
+      name: m.tool,
+      description: m.description,
+      category: m.category,
+      costCredits: m.cost_credits,
+      contractVersion: m.contract_version ?? m.contract?.contract_version,
+      permissionLevel: m.permission_level ?? m.contract?.permission_level,
+      authScopes: m.auth_scopes ?? m.contract?.auth_scopes,
+      idempotent: m.idempotent ?? m.contract?.idempotent,
+      destructive: m.destructive ?? m.contract?.destructive,
+      retryable: m.retryable ?? m.contract?.retryable,
+      rateLimitKey: m.rate_limit_key ?? m.contract?.rate_limit_key,
+      observability: m.observability ?? m.contract?.observability,
+      inputSchema: m.input_schema ?? m.inputSchema ?? m.contract?.input_schema,
+      outputSchema: m.output_schema ?? m.outputSchema ?? m.contract?.output_schema,
+      annotations: m.annotations
+    }));
+  }
+};
+
+export {
+  SignalizError,
+  Campaigns,
+  DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS,
+  CampaignBuilderAgent,
+  createCampaignBuilderAgentPlan,
+  getMissingCampaignBuilderApprovals,
+  createCampaignBuilderApproval,
+  Icps,
+  normalizeExecutionReference,
+  collectExecutionReferences,
+  Ops,
+  Ai,
+  GtmKernel,
+  Signaliz
+};