@signaliz/sdk 1.0.21 → 1.0.23

package/dist/chunk-EQ3WI2UU.mjs

@@ -0,0 +1,594 @@
+// 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;
+    if (this.accessTokenPromise) return this.accessTokenPromise;
+    this.accessTokenPromise = (async () => {
+      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;
+    })().finally(() => {
+      this.accessTokenPromise = void 0;
+    });
+    return this.accessTokenPromise;
+  }
+};
+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 unwrapMcpPayload(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/index.ts
+var Signaliz = class {
+  constructor(config) {
+    this.client = new HttpClient(config);
+  }
+  async findEmail(params) {
+    const data = await this.client.post("api/v1/find-email", compact({
+      company_domain: params.companyDomain,
+      full_name: params.fullName,
+      first_name: params.firstName,
+      last_name: params.lastName,
+      linkedin_url: params.linkedinUrl,
+      company_name: params.companyName,
+      skip_cache: params.skipCache
+    }));
+    const email = typeof data.email === "string" && data.email.trim() ? data.email.trim() : null;
+    const found = Boolean(email) && data.found !== false;
+    return {
+      success: data.success !== false && found,
+      found,
+      email,
+      firstName: data.first_name,
+      lastName: data.last_name,
+      confidence: data.confidence ?? data.confidence_score ?? 0,
+      verificationStatus: data.verification_status ?? data.status ?? "unknown",
+      providerUsed: data.provider_used ?? data.provider ?? data.source ?? "unknown",
+      error: found ? void 0 : data.error ?? "No verified email found",
+      errorCode: found ? void 0 : data.error_code ?? "EMAIL_NOT_FOUND",
+      raw: data
+    };
+  }
+  async findEmails(params, options) {
+    return runBatch(params, (item) => this.findEmail(item), options);
+  }
+  async verifyEmail(email) {
+    const data = await this.client.post("api/v1/verify-email", { email });
+    const verificationStatus = String(data.verification_status ?? "").toLowerCase();
+    const verified = data.email_verified === true || ["valid", "deliverable"].includes(verificationStatus);
+    return {
+      email: data.email ?? email,
+      isValid: data.is_valid ?? data.valid ?? verified,
+      isDeliverable: data.is_deliverable ?? data.deliverable ?? verified,
+      isCatchAll: data.is_catch_all ?? data.catch_all ?? data.diagnostics?.is_catch_all ?? false,
+      confidenceScore: data.confidence_score ?? data.confidence ?? data.diagnostics?.confidence_score ?? (verified ? 1 : 0),
+      provider: data.provider,
+      verificationSource: data.verification_source,
+      raw: data
+    };
+  }
+  async verifyEmails(emails, options) {
+    return runBatch(emails, (email) => this.verifyEmail(email), options);
+  }
+  async enrichCompanySignals(params) {
+    const online = params.online ?? true;
+    const request = compact({
+      company_domain: params.companyDomain,
+      company_name: params.companyName,
+      research_prompt: params.researchPrompt,
+      signal_types: params.signalTypes,
+      target_signal_count: params.targetSignalCount,
+      lookback_days: params.lookbackDays,
+      online,
+      enable_deep_search: params.enableDeepSearch ?? online,
+      enable_outreach_intelligence: params.enableOutreachIntelligence,
+      enable_predictive_intelligence: params.enablePredictiveIntelligence,
+      skip_cache: params.skipCache,
+      wait_for_result: params.waitForResult !== false,
+      max_wait_ms: params.maxWaitMs
+    });
+    let data = await this.client.post("api/v1/company-signals", request);
+    if (params.waitForResult !== false && data.run_id && isPendingSignalResponse(data)) {
+      const maxWaitMs = Math.max(1e3, params.maxWaitMs ?? 20 * 6e4);
+      const pollIntervalMs = Math.max(250, params.pollIntervalMs ?? 2e3);
+      const startedAt = Date.now();
+      while (Date.now() - startedAt < maxWaitMs) {
+        const status = await this.client.post("api/v1/company-signals", {
+          ...request,
+          signal_run_id: data.run_id
+        });
+        if (isCompletedSignalRun(status)) {
+          data = status.output ?? status.result ?? status.data ?? status;
+          break;
+        }
+        if (isFailedSignalRun(status)) {
+          throw new Error(`Company signal enrichment ${data.run_id} failed with status ${status.status || "unknown"}`);
+        }
+        if (!isPendingSignalResponse(status)) {
+          data = status.output ?? status.result ?? status.data ?? status;
+          break;
+        }
+        await sleep2(pollIntervalMs);
+      }
+      if (isPendingSignalResponse(data)) {
+        throw new Error(`Company signal enrichment ${data.run_id} did not complete within ${maxWaitMs}ms`);
+      }
+    }
+    return {
+      success: data.success ?? true,
+      company: {
+        name: data.company?.name ?? params.companyName ?? null,
+        domain: data.company?.domain ?? params.companyDomain ?? null
+      },
+      signals: (data.signals ?? []).map((signal) => ({
+        id: signal.id,
+        title: signal.title ?? "",
+        type: signal.type ?? signal.signal_type ?? "unknown",
+        content: signal.content ?? signal.description ?? "",
+        date: signal.date ?? signal.detected_at ?? null,
+        sourceUrl: signal.source_url ?? signal.url ?? null,
+        sourceType: signal.source_type,
+        confidence: signal.confidence ?? signal.confidence_score ?? null
+      })),
+      signalCount: data.signal_count ?? data.total_signals ?? data.signals?.length ?? 0,
+      intelligence: data.intelligence ?? null,
+      credits: data.credits,
+      metadata: data.metadata,
+      raw: data
+    };
+  }
+  async enrichCompanies(companies, options) {
+    return runBatch(companies, (company) => this.enrichCompanySignals(company), options);
+  }
+  async signalToCopy(params) {
+    const request = compact({
+      company_domain: params.companyDomain,
+      person_name: params.personName,
+      title: params.title,
+      campaign_offer: params.campaignOffer,
+      research_prompt: params.researchPrompt,
+      signal_run_id: params.signalRunId
+    });
+    let data = await this.client.post("api/v1/signal-to-copy", request);
+    if (params.waitForResult !== false && data.run_id && isPendingSignalResponse(data)) {
+      const maxWaitMs = Math.max(1e3, params.maxWaitMs ?? 20 * 6e4);
+      const pollIntervalMs = Math.max(250, params.pollIntervalMs ?? 2e3);
+      const startedAt = Date.now();
+      while (Date.now() - startedAt < maxWaitMs) {
+        await sleep2(pollIntervalMs);
+        data = await this.client.post("api/v1/signal-to-copy", {
+          ...request,
+          signal_run_id: data.run_id
+        });
+        if (!isPendingSignalResponse(data)) break;
+      }
+      if (isPendingSignalResponse(data)) {
+        throw new Error(`Signal Copy ${data.run_id} did not complete within ${maxWaitMs}ms`);
+      }
+    }
+    return {
+      success: data.success ?? true,
+      status: data.status,
+      runId: data.run_id,
+      strongestSignal: data.strongest_signal ?? "",
+      whyNow: data.why_now ?? "",
+      subjectLine: data.subject_line ?? "",
+      openingLine: data.opening_line ?? "",
+      confidence: data.confidence ?? 0,
+      evidenceUrl: data.evidence_url ?? "",
+      researchPrompt: data.research_prompt,
+      variations: (data.variations ?? []).map((variation) => ({
+        style: variation.style,
+        subjectLine: variation.subject_line ?? "",
+        openingLine: variation.opening_line ?? "",
+        cta: variation.cta ?? "",
+        prediction: variation.prediction,
+        email: variation.email
+      })),
+      raw: data
+    };
+  }
+  async createSignalCopyBatch(requests, options) {
+    return runBatch(requests, (request) => this.signalToCopy(request), options);
+  }
+  async listTools() {
+    const result = await this.client.mcp("tools/list");
+    return result.tools ?? [];
+  }
+  async health() {
+    const result = await this.client.get("api/v1/health");
+    return {
+      status: result.status ?? "unknown",
+      products: Array.isArray(result.products) ? result.products : []
+    };
+  }
+};
+function compact(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+function isPendingSignalResponse(data) {
+  return ["triggered", "queued", "processing", "pending", "pending_version", "waiting_for_deploy"].includes(String(data.status || "").toLowerCase());
+}
+function isCompletedSignalRun(data) {
+  return ["completed", "success", "succeeded"].includes(String(data.status || "").toLowerCase());
+}
+function isFailedSignalRun(data) {
+  return ["failed", "error", "cancelled", "canceled", "crashed", "timed_out"].includes(String(data.status || "").toLowerCase());
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function runBatch(items, execute, options) {
+  if (!Array.isArray(items) || items.length === 0) {
+    throw new Error("Signaliz batch requests require at least one item");
+  }
+  if (items.length > 5e3) {
+    throw new Error(`Signaliz batch requests support at most 5,000 items; received ${items.length}`);
+  }
+  const concurrency = options?.concurrency ?? 10;
+  if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 50) {
+    throw new Error("Signaliz batch concurrency must be an integer between 1 and 50");
+  }
+  const startedAt = Date.now();
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (true) {
+      const index = nextIndex;
+      nextIndex += 1;
+      if (index >= items.length) return;
+      try {
+        results[index] = { index, success: true, data: await execute(items[index]) };
+      } catch (error) {
+        results[index] = {
+          index,
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker));
+  const succeeded = results.filter((item) => item.success).length;
+  return {
+    total: items.length,
+    succeeded,
+    failed: items.length - succeeded,
+    durationMs: Date.now() - startedAt,
+    results
+  };
+}
+
+export {
+  SignalizError,
+  Signaliz
+};