@kadoa/node-sdk 0.0.2 → 0.1.0

package/dist/index.mjs

@@ -1,8 +1,184 @@
+import { EventEmitter } from 'events';
 import globalAxios2, { AxiosError } from 'axios';
+import { merge } from 'es-toolkit/object';
 import { URL as URL$1, URLSearchParams } from 'url';
-import { EventEmitter } from 'events';
 
-// src/kadoa-sdk.ts
+// src/events/index.ts
+var KadoaEventEmitter = class extends EventEmitter {
+  /**
+   * Emit a typed SDK event
+   */
+  emit(eventName, payload, source = "sdk", metadata) {
+    const event = {
+      type: eventName,
+      timestamp: /* @__PURE__ */ new Date(),
+      source,
+      payload,
+      metadata
+    };
+    return super.emit("event", event);
+  }
+  /**
+   * Subscribe to SDK events
+   */
+  onEvent(listener) {
+    return super.on("event", listener);
+  }
+  /**
+   * Subscribe to SDK events (once)
+   */
+  onceEvent(listener) {
+    return super.once("event", listener);
+  }
+  /**
+   * Unsubscribe from SDK events
+   */
+  offEvent(listener) {
+    return super.off("event", listener);
+  }
+  /**
+   * Remove all event listeners
+   */
+  removeAllEventListeners() {
+    return super.removeAllListeners("event");
+  }
+};
+
+// src/exceptions/kadoa-sdk.exception.ts
+var KadoaSdkException = class _KadoaSdkException extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "KadoaSdkException";
+    this.code = options?.code ?? "UNKNOWN";
+    this.details = options?.details;
+    if (options && "cause" in options) this.cause = options.cause;
+    Error.captureStackTrace?.(this, _KadoaSdkException);
+  }
+  static from(error, details) {
+    if (error instanceof _KadoaSdkException) return error;
+    const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Unexpected error";
+    return new _KadoaSdkException(message, {
+      code: "UNKNOWN",
+      details,
+      cause: error
+    });
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details
+    };
+  }
+  toString() {
+    return [this.name, this.code, this.message].filter(Boolean).join(": ");
+  }
+};
+
+// src/exceptions/http.exception.ts
+var KadoaHttpException = class _KadoaHttpException extends KadoaSdkException {
+  constructor(message, options) {
+    super(message, {
+      code: options?.code,
+      details: options?.details,
+      cause: options?.cause
+    });
+    this.name = "KadoaHttpException";
+    this.httpStatus = options?.httpStatus;
+    this.requestId = options?.requestId;
+    this.endpoint = options?.endpoint;
+    this.method = options?.method;
+    this.responseBody = options?.responseBody;
+  }
+  static fromAxiosError(error, extra) {
+    const status = error.response?.status;
+    const requestId = error.response?.headers?.["x-request-id"] || error.response?.headers?.["x-amzn-requestid"];
+    const method = error.config?.method?.toUpperCase();
+    const url = error.config?.url;
+    return new _KadoaHttpException(extra?.message || error.message, {
+      code: _KadoaHttpException.mapStatusToCode(error),
+      httpStatus: status,
+      requestId,
+      endpoint: url,
+      method,
+      responseBody: error.response?.data,
+      details: extra?.details,
+      cause: error
+    });
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      httpStatus: this.httpStatus,
+      requestId: this.requestId,
+      endpoint: this.endpoint,
+      method: this.method,
+      responseBody: this.responseBody
+    };
+  }
+  static mapStatusToCode(error) {
+    const status = error.response?.status;
+    if (!status) {
+      return error.code === "ECONNABORTED" ? "TIMEOUT" : error.request ? "NETWORK_ERROR" : "UNKNOWN";
+    }
+    if (status === 401 || status === 403) return "AUTH_ERROR";
+    if (status === 404) return "NOT_FOUND";
+    if (status === 408) return "TIMEOUT";
+    if (status === 429) return "RATE_LIMITED";
+    if (status >= 400 && status < 500) return "VALIDATION_ERROR";
+    if (status >= 500) return "HTTP_ERROR";
+    return "UNKNOWN";
+  }
+};
+function isKadoaSdkException(error) {
+  return error instanceof KadoaSdkException;
+}
+function isKadoaHttpException(error) {
+  return error instanceof KadoaHttpException;
+}
+function wrapKadoaError(error, extra) {
+  if (error instanceof AxiosError)
+    return KadoaHttpException.fromAxiosError(error, extra);
+  return KadoaSdkException.from(error, extra?.details);
+}
+
+// src/extraction/constants.ts
+var DEFAULT_OPTIONS = {
+  pollingInterval: 5e3,
+  maxWaitTime: 3e5,
+  navigationMode: "single-page",
+  location: { type: "auto" },
+  name: "Untitled Workflow",
+  dataLimit: 100
+};
+var MAX_DATA_LIMIT = 99999;
+var TERMINAL_RUN_STATES = /* @__PURE__ */ new Set([
+  "FINISHED",
+  "SUCCESS",
+  "FAILED",
+  "ERROR",
+  "STOPPED",
+  "CANCELLED"
+]);
+var SUCCESSFUL_RUN_STATES = /* @__PURE__ */ new Set(["FINISHED", "SUCCESS"]);
+var ENTITY_API_ENDPOINT = "/v4/entity";
+var DEFAULT_API_BASE_URL = "https://api.kadoa.com";
+var ERROR_MESSAGES = {
+  NO_URLS: "At least one URL is required for extraction",
+  NO_API_KEY: "API key is required for entity detection",
+  LINK_REQUIRED: "Link is required for entity field detection",
+  NO_WORKFLOW_ID: "Failed to start extraction process - no ID received",
+  NO_PREDICTIONS: "No entity predictions returned from the API",
+  PARSE_ERROR: "Failed to parse entity response",
+  NETWORK_ERROR: "Network error while fetching entity fields",
+  AUTH_FAILED: "Authentication failed. Please check your API key",
+  RATE_LIMITED: "Rate limit exceeded. Please try again later",
+  SERVER_ERROR: "Server error while fetching entity fields",
+  DATA_FETCH_FAILED: "Failed to retrieve extracted data from workflow",
+  PROGRESS_CHECK_FAILED: "Failed to check extraction progress",
+  EXTRACTION_FAILED: "Data extraction failed for the provided URLs"
+};
 var BASE_PATH = "https://api.kadoa.com".replace(/\/+$/, "");
 var BaseAPI = class {
   constructor(configuration, basePath = BASE_PATH, axios2 = globalAxios2) {
@@ -1687,180 +1863,6 @@ var Configuration = class {
     return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === "application/json-patch+json");
   }
 };
-var KadoaEventEmitter = class extends EventEmitter {
-  /**
-   * Emit a typed SDK event
-   */
-  emit(eventName, payload, source = "sdk", metadata) {
-    const event = {
-      type: eventName,
-      timestamp: /* @__PURE__ */ new Date(),
-      source,
-      payload,
-      metadata
-    };
-    return super.emit("event", event);
-  }
-  /**
-   * Subscribe to SDK events
-   */
-  onEvent(listener) {
-    return super.on("event", listener);
-  }
-  /**
-   * Subscribe to SDK events (once)
-   */
-  onceEvent(listener) {
-    return super.once("event", listener);
-  }
-  /**
-   * Unsubscribe from SDK events
-   */
-  offEvent(listener) {
-    return super.off("event", listener);
-  }
-  /**
-   * Remove all event listeners
-   */
-  removeAllEventListeners() {
-    return super.removeAllListeners("event");
-  }
-};
-
-// src/kadoa-sdk.ts
-function initializeSdk(config) {
-  const baseUrl = config.baseUrl || "https://api.kadoa.com";
-  const configParams = {
-    apiKey: config.apiKey,
-    basePath: baseUrl
-  };
-  const configuration = new Configuration(configParams);
-  const axiosInstance = globalAxios2.create({
-    timeout: config.timeout || 3e4
-  });
-  const events = new KadoaEventEmitter();
-  return {
-    configuration,
-    axiosInstance,
-    baseUrl,
-    events,
-    emit: (eventName, payload, source, metadata) => {
-      events.emit(eventName, payload, source, metadata);
-    },
-    onEvent: (listener) => {
-      events.onEvent(listener);
-    },
-    offEvent: (listener) => {
-      events.offEvent(listener);
-    }
-  };
-}
-function dispose(sdkInstance) {
-  if (sdkInstance?.events) {
-    sdkInstance.events.removeAllListeners();
-  }
-}
-
-// src/exceptions/kadoa-sdk.exception.ts
-var KadoaSdkException = class _KadoaSdkException extends Error {
-  constructor(message, options) {
-    super(message);
-    this.name = "KadoaSdkException";
-    this.code = options?.code ?? "UNKNOWN";
-    this.details = options?.details;
-    if (options && "cause" in options) this.cause = options.cause;
-    Error.captureStackTrace?.(this, _KadoaSdkException);
-  }
-  static from(error, details) {
-    if (error instanceof _KadoaSdkException) return error;
-    const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Unexpected error";
-    return new _KadoaSdkException(message, {
-      code: "UNKNOWN",
-      details,
-      cause: error
-    });
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      code: this.code,
-      details: this.details
-    };
-  }
-  toString() {
-    return [this.name, this.code, this.message].filter(Boolean).join(": ");
-  }
-};
-
-// src/exceptions/http.exception.ts
-var KadoaHttpException = class _KadoaHttpException extends KadoaSdkException {
-  constructor(message, options) {
-    super(message, {
-      code: options?.code,
-      details: options?.details,
-      cause: options?.cause
-    });
-    this.name = "KadoaHttpException";
-    this.httpStatus = options?.httpStatus;
-    this.requestId = options?.requestId;
-    this.endpoint = options?.endpoint;
-    this.method = options?.method;
-    this.responseBody = options?.responseBody;
-  }
-  static fromAxiosError(error, extra) {
-    const status = error.response?.status;
-    const requestId = error.response?.headers?.["x-request-id"] || error.response?.headers?.["x-amzn-requestid"];
-    const method = error.config?.method?.toUpperCase();
-    const url = error.config?.url;
-    return new _KadoaHttpException(extra?.message || error.message, {
-      code: _KadoaHttpException.mapStatusToCode(error),
-      httpStatus: status,
-      requestId,
-      endpoint: url,
-      method,
-      responseBody: error.response?.data,
-      details: extra?.details,
-      cause: error
-    });
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      httpStatus: this.httpStatus,
-      requestId: this.requestId,
-      endpoint: this.endpoint,
-      method: this.method,
-      responseBody: this.responseBody
-    };
-  }
-  static mapStatusToCode(error) {
-    const status = error.response?.status;
-    if (!status) {
-      return error.code === "ECONNABORTED" ? "TIMEOUT" : error.request ? "NETWORK_ERROR" : "UNKNOWN";
-    }
-    if (status === 401 || status === 403) return "AUTH_ERROR";
-    if (status === 404) return "NOT_FOUND";
-    if (status === 408) return "TIMEOUT";
-    if (status === 429) return "RATE_LIMITED";
-    if (status >= 400 && status < 500) return "VALIDATION_ERROR";
-    if (status >= 500) return "HTTP_ERROR";
-    return "UNKNOWN";
-  }
-};
-
-// src/exceptions/utils.ts
-function isKadoaSdkException(error) {
-  return error instanceof KadoaSdkException;
-}
-function isKadoaHttpException(error) {
-  return error instanceof KadoaHttpException;
-}
-function wrapKadoaError(error, extra) {
-  if (error instanceof AxiosError)
-    return KadoaHttpException.fromAxiosError(error, extra);
-  return KadoaSdkException.from(error, extra?.details);
-}
 
 // src/api-client.ts
 var workflowsApiCache = /* @__PURE__ */ new WeakMap();
@@ -1873,20 +1875,37 @@ function getWorkflowsApi(app) {
   return api;
 }
 
-// src/extraction/detect-entity.ts
-async function fetchEntityFields(app, options) {
+// src/extraction/data-fetcher.ts
+async function fetchWorkflowData(sdkInstance, workflowId, limit = DEFAULT_OPTIONS.dataLimit) {
+  const workflowsApi = getWorkflowsApi(sdkInstance);
+  try {
+    const response = await workflowsApi.v4WorkflowsWorkflowIdDataGet({
+      workflowId,
+      limit
+    });
+    return response.data.data ?? [];
+  } catch (error) {
+    throw wrapKadoaError(error, {
+      message: ERROR_MESSAGES.DATA_FETCH_FAILED,
+      details: { workflowId, limit }
+    });
+  }
+}
+
+// src/extraction/entity-detector.ts
+function validateEntityOptions(options) {
   if (!options.link) {
-    throw new KadoaSdkException("Link is required for entity field detection", {
+    throw new KadoaSdkException(ERROR_MESSAGES.LINK_REQUIRED, {
       code: "VALIDATION_ERROR",
       details: { options }
     });
   }
-  const url = new URL("/v4/entity", app.baseUrl || "https://api.kadoa.com");
+}
+async function buildRequestHeaders(config) {
   const headers = {
     "Content-Type": "application/json",
     Accept: "application/json"
   };
-  const config = app.configuration;
   if (config?.apiKey) {
     if (typeof config.apiKey === "function") {
       const apiKeyValue = await config.apiKey("X-API-Key");
@@ -1897,16 +1916,71 @@ async function fetchEntityFields(app, options) {
       headers["X-API-Key"] = config.apiKey;
     }
   } else {
-    throw new KadoaSdkException("API key is required for entity detection", {
+    throw new KadoaSdkException(ERROR_MESSAGES.NO_API_KEY, {
       code: "AUTH_ERROR",
       details: { hasConfig: !!config, hasApiKey: !!config?.apiKey }
     });
   }
-  const requestBody = {
-    link: options.link,
-    location: options.location || { type: "auto" },
-    navigationMode: options.navigationMode || "single-page"
+  return headers;
+}
+function getErrorCodeFromStatus(status) {
+  if (status === 401 || status === 403) return "AUTH_ERROR";
+  if (status === 404) return "NOT_FOUND";
+  if (status === 429) return "RATE_LIMITED";
+  if (status >= 400 && status < 500) return "VALIDATION_ERROR";
+  if (status >= 500) return "HTTP_ERROR";
+  return "UNKNOWN";
+}
+async function handleErrorResponse(response, url, link) {
+  let errorData;
+  let errorText = "";
+  try {
+    errorText = await response.text();
+    errorData = JSON.parse(errorText);
+  } catch {
+    errorData = { message: errorText || response.statusText };
+  }
+  const baseErrorOptions = {
+    httpStatus: response.status,
+    endpoint: url.toString(),
+    method: "POST",
+    responseBody: errorData,
+    details: {
+      url: url.toString(),
+      link
+    }
   };
+  if (response.status === 401) {
+    throw new KadoaHttpException(ERROR_MESSAGES.AUTH_FAILED, {
+      ...baseErrorOptions,
+      code: "AUTH_ERROR"
+    });
+  }
+  if (response.status === 429) {
+    throw new KadoaHttpException(ERROR_MESSAGES.RATE_LIMITED, {
+      ...baseErrorOptions,
+      code: "RATE_LIMITED"
+    });
+  }
+  if (response.status >= 500) {
+    throw new KadoaHttpException(ERROR_MESSAGES.SERVER_ERROR, {
+      ...baseErrorOptions,
+      code: "HTTP_ERROR"
+    });
+  }
+  throw new KadoaHttpException(
+    `Failed to fetch entity fields: ${errorData?.message || response.statusText}`,
+    {
+      ...baseErrorOptions,
+      code: getErrorCodeFromStatus(response.status)
+    }
+  );
+}
+async function fetchEntityFields(app, options) {
+  validateEntityOptions(options);
+  const url = new URL(ENTITY_API_ENDPOINT, app.baseUrl || DEFAULT_API_BASE_URL);
+  const headers = await buildRequestHeaders(app.configuration);
+  const requestBody = options;
   let response;
   try {
     response = await fetch(url.toString(), {
@@ -1915,7 +1989,7 @@ async function fetchEntityFields(app, options) {
       body: JSON.stringify(requestBody)
     });
   } catch (error) {
-    throw new KadoaSdkException("Network error while fetching entity fields", {
+    throw new KadoaSdkException(ERROR_MESSAGES.NETWORK_ERROR, {
       code: "NETWORK_ERROR",
       details: {
         url: url.toString(),
@@ -1925,89 +1999,13 @@ async function fetchEntityFields(app, options) {
     });
   }
   if (!response.ok) {
-    let errorData;
-    let errorText = "";
-    try {
-      errorText = await response.text();
-      errorData = JSON.parse(errorText);
-    } catch {
-      errorData = { message: errorText || response.statusText };
-    }
-    const getErrorCode = (status) => {
-      if (status === 401 || status === 403) return "AUTH_ERROR";
-      if (status === 404) return "NOT_FOUND";
-      if (status === 429) return "RATE_LIMITED";
-      if (status >= 400 && status < 500) return "VALIDATION_ERROR";
-      if (status >= 500) return "HTTP_ERROR";
-      return "UNKNOWN";
-    };
-    if (response.status === 401) {
-      throw new KadoaHttpException(
-        "Authentication failed. Please check your API key",
-        {
-          code: "AUTH_ERROR",
-          httpStatus: response.status,
-          endpoint: url.toString(),
-          method: "POST",
-          responseBody: errorData,
-          details: {
-            url: url.toString(),
-            link: options.link
-          }
-        }
-      );
-    } else if (response.status === 429) {
-      throw new KadoaHttpException(
-        "Rate limit exceeded. Please try again later",
-        {
-          code: "RATE_LIMITED",
-          httpStatus: response.status,
-          endpoint: url.toString(),
-          method: "POST",
-          responseBody: errorData,
-          details: {
-            url: url.toString(),
-            link: options.link
-          }
-        }
-      );
-    } else if (response.status >= 500) {
-      throw new KadoaHttpException(
-        "Server error while fetching entity fields",
-        {
-          code: "HTTP_ERROR",
-          httpStatus: response.status,
-          endpoint: url.toString(),
-          method: "POST",
-          responseBody: errorData,
-          details: {
-            url: url.toString(),
-            link: options.link
-          }
-        }
-      );
-    } else {
-      throw new KadoaHttpException(
-        `Failed to fetch entity fields: ${errorData?.message || response.statusText}`,
-        {
-          code: getErrorCode(response.status),
-          httpStatus: response.status,
-          endpoint: url.toString(),
-          method: "POST",
-          responseBody: errorData,
-          details: {
-            url: url.toString(),
-            link: options.link
-          }
-        }
-      );
-    }
+    await handleErrorResponse(response, url, options.link);
   }
   let data;
   try {
     data = await response.json();
   } catch (error) {
-    throw new KadoaSdkException("Failed to parse entity response", {
+    throw new KadoaSdkException(ERROR_MESSAGES.PARSE_ERROR, {
       code: "INTERNAL_ERROR",
       details: {
         url: url.toString(),
@@ -2017,7 +2015,7 @@ async function fetchEntityFields(app, options) {
     });
   }
   if (!data.success || !data.entityPrediction || data.entityPrediction.length === 0) {
-    throw new KadoaSdkException("No entity predictions returned from the API", {
+    throw new KadoaSdkException(ERROR_MESSAGES.NO_PREDICTIONS, {
       code: "NOT_FOUND",
       details: {
         success: data.success,
@@ -2030,150 +2028,148 @@ async function fetchEntityFields(app, options) {
   return data.entityPrediction[0];
 }
 
-// src/extraction/run-extraction.ts
-var TERMINAL_RUN_STATES = /* @__PURE__ */ new Set([
-  "FINISHED",
-  "SUCCESS",
-  "FAILED",
-  "ERROR",
-  "STOPPED",
-  "CANCELLED"
-]);
+// src/extraction/workflow-manager.ts
 function isTerminalRunState(runState) {
   if (!runState) return false;
   return TERMINAL_RUN_STATES.has(runState.toUpperCase());
 }
-async function fetchWorkflowData(sdkInstance, workflowId, limit = 100) {
+async function createWorkflow(sdkInstance, config) {
   const workflowsApi = getWorkflowsApi(sdkInstance);
+  const request = {
+    urls: config.urls,
+    navigationMode: config.navigationMode,
+    entity: config.entity,
+    name: config.name,
+    fields: config.fields,
+    bypassPreview: true,
+    limit: MAX_DATA_LIMIT,
+    tags: ["sdk"]
+  };
   try {
-    const response = await workflowsApi.v4WorkflowsWorkflowIdDataGet({
-      workflowId,
-      limit
+    const response = await workflowsApi.v4WorkflowsPost({
+      v4WorkflowsPostRequest: request
     });
-    return response.data.data ?? [];
+    const workflowId = response.data.workflowId;
+    if (!workflowId) {
+      throw new KadoaSdkException(ERROR_MESSAGES.NO_WORKFLOW_ID, {
+        code: "INTERNAL_ERROR",
+        details: { urls: config.urls }
+      });
+    }
+    return workflowId;
   } catch (error) {
-    const e = wrapKadoaError(error, {
-      message: "Failed to retrieve extracted data from workflow",
-      details: { workflowId, limit }
+    throw wrapKadoaError(error, {
+      message: "Failed to create workflow",
+      details: config
     });
-    throw e;
   }
 }
-async function waitForWorkflowCompletion(sdkInstance, workflowId, pollingInterval = 5e3, maxWaitTime = 3e5) {
+async function getWorkflowStatus(sdkInstance, workflowId) {
   const workflowsApi = getWorkflowsApi(sdkInstance);
+  try {
+    const response = await workflowsApi.v4WorkflowsWorkflowIdGet({
+      workflowId
+    });
+    return response.data;
+  } catch (error) {
+    throw wrapKadoaError(error, {
+      message: ERROR_MESSAGES.PROGRESS_CHECK_FAILED,
+      details: { workflowId }
+    });
+  }
+}
+async function waitForWorkflowCompletion(sdkInstance, workflowId, options) {
+  const pollingInterval = options.pollingInterval;
+  const maxWaitTime = options.maxWaitTime;
   const startTime = Date.now();
   let previousState;
   let previousRunState;
   while (Date.now() - startTime < maxWaitTime) {
-    try {
-      const response = await workflowsApi.v4WorkflowsWorkflowIdGet({
-        workflowId
-      });
-      const workflow = response.data;
-      if (workflow.state !== previousState || workflow.runState !== previousRunState) {
-        sdkInstance.emit(
-          "extraction:status_changed",
-          {
-            workflowId,
-            previousState,
-            previousRunState,
-            currentState: workflow.state,
-            currentRunState: workflow.runState
-          },
-          "extraction"
-        );
-        previousState = workflow.state;
-        previousRunState = workflow.runState;
-      }
-      if (isTerminalRunState(workflow.runState)) {
-        return workflow;
+    const workflow = await getWorkflowStatus(sdkInstance, workflowId);
+    if (workflow.state !== previousState || workflow.runState !== previousRunState) {
+      const statusChange = {
+        workflowId,
+        previousState,
+        previousRunState,
+        currentState: workflow.state,
+        currentRunState: workflow.runState
+      };
+      sdkInstance.emit("extraction:status_changed", statusChange, "extraction");
+      if (options?.onStatusChange) {
+        options.onStatusChange(statusChange);
       }
-      await new Promise((resolve) => setTimeout(resolve, pollingInterval));
-    } catch (error) {
-      const e = wrapKadoaError(error, {
-        message: "Failed to check extraction progress",
-        details: { workflowId }
-      });
-      throw e;
+      previousState = workflow.state;
+      previousRunState = workflow.runState;
     }
+    if (isTerminalRunState(workflow.runState)) {
+      return workflow;
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollingInterval));
   }
-  const timeoutError = new KadoaSdkException(
+  throw new KadoaSdkException(
     `Extraction did not complete within ${maxWaitTime / 1e3} seconds`,
     { code: "TIMEOUT", details: { workflowId, maxWaitTime } }
   );
-  throw timeoutError;
 }
-async function runExtraction(sdkInstance, options) {
+
+// src/extraction/extraction-runner.ts
+function validateExtractionOptions(options) {
   if (!options.urls || options.urls.length === 0) {
-    const e = new KadoaSdkException(
-      "At least one URL is required for extraction",
-      {
-        code: "VALIDATION_ERROR"
-      }
-    );
-    throw e;
+    throw new KadoaSdkException(ERROR_MESSAGES.NO_URLS, {
+      code: "VALIDATION_ERROR"
+    });
   }
+}
+function isExtractionSuccessful(runState) {
+  return runState ? SUCCESSFUL_RUN_STATES.has(runState.toUpperCase()) : false;
+}
+async function runExtraction(sdkInstance, options) {
+  validateExtractionOptions(options);
+  const config = merge(
+    DEFAULT_OPTIONS,
+    options
+  );
   try {
     const entityPrediction = await fetchEntityFields(sdkInstance, {
-      link: options.urls[0],
-      location: options.location || { type: "auto" },
-      navigationMode: options.navigationMode || "single-page"
+      link: config.urls[0],
+      location: config.location,
+      navigationMode: config.navigationMode
     });
     sdkInstance.emit(
       "entity:detected",
       {
         entity: entityPrediction.entity,
         fields: entityPrediction.fields,
-        url: options.urls[0]
+        url: config.urls[0]
       },
       "extraction",
       {
-        navigationMode: options.navigationMode,
-        location: options.location
+        navigationMode: config.navigationMode,
+        location: config.location
       }
     );
-    const response = await getWorkflowsApi(sdkInstance).v4WorkflowsPost({
-      v4WorkflowsPostRequest: {
-        urls: options.urls,
-        navigationMode: options.navigationMode || "single-page",
-        entity: entityPrediction.entity,
-        name: options.name || "Untitled Workflow",
-        fields: entityPrediction.fields,
-        bypassPreview: true,
-        limit: 99999,
-        // no limits for SDK
-        tags: ["sdk"]
-      }
+    const workflowId = await createWorkflow(sdkInstance, {
+      urls: config.urls,
+      navigationMode: config.navigationMode,
+      entity: entityPrediction.entity,
+      fields: entityPrediction.fields,
+      name: config.name
     });
-    const workflowId = response.data.workflowId;
-    if (!workflowId) {
-      const e = new KadoaSdkException(
-        "Failed to start extraction process - no ID received",
-        {
-          code: "INTERNAL_ERROR",
-          details: { urls: options.urls }
-        }
-      );
-      throw e;
-    }
     sdkInstance.emit(
       "extraction:started",
       {
         workflowId,
-        name: options.name || "Untitled Workflow",
-        urls: options.urls
+        name: config.name,
+        urls: config.urls
       },
       "extraction"
     );
-    const workflow = await waitForWorkflowCompletion(
-      sdkInstance,
-      workflowId,
-      options.pollingInterval,
-      options.maxWaitTime
-    );
+    const workflow = await waitForWorkflowCompletion(sdkInstance, workflowId, {
+      pollingInterval: config.pollingInterval,
+      maxWaitTime: config.maxWaitTime
+    });
     let data;
-    const successfulRunStates = ["FINISHED", "SUCCESS"];
-    const isSuccess = workflow.runState && successfulRunStates.includes(workflow.runState.toUpperCase());
+    const isSuccess = isExtractionSuccessful(workflow.runState);
     if (isSuccess) {
       data = await fetchWorkflowData(sdkInstance, workflowId);
       if (data) {
@@ -2210,7 +2206,7 @@ async function runExtraction(sdkInstance, options) {
         },
         "extraction"
       );
-      const e = new KadoaSdkException(
+      throw new KadoaSdkException(
         `Extraction completed with unexpected status: ${workflow.runState}`,
         {
           code: "INTERNAL_ERROR",
@@ -2221,7 +2217,6 @@ async function runExtraction(sdkInstance, options) {
           }
         }
       );
-      throw e;
     }
     return {
       workflowId,
@@ -2229,11 +2224,42 @@ async function runExtraction(sdkInstance, options) {
       data
     };
   } catch (error) {
-    const e = wrapKadoaError(error, {
-      message: "Data extraction failed for the provided URLs",
+    throw wrapKadoaError(error, {
+      message: ERROR_MESSAGES.EXTRACTION_FAILED,
       details: { urls: options.urls }
     });
-    throw e;
+  }
+}
+function initializeSdk(config) {
+  const baseUrl = config.baseUrl || "https://api.kadoa.com";
+  const configParams = {
+    apiKey: config.apiKey,
+    basePath: baseUrl
+  };
+  const configuration = new Configuration(configParams);
+  const axiosInstance = globalAxios2.create({
+    timeout: config.timeout || 3e4
+  });
+  const events = new KadoaEventEmitter();
+  return {
+    configuration,
+    axiosInstance,
+    baseUrl,
+    events,
+    emit: (eventName, payload, source, metadata) => {
+      events.emit(eventName, payload, source, metadata);
+    },
+    onEvent: (listener) => {
+      events.onEvent(listener);
+    },
+    offEvent: (listener) => {
+      events.offEvent(listener);
+    }
+  };
+}
+function dispose(sdkInstance) {
+  if (sdkInstance?.events) {
+    sdkInstance.events.removeAllListeners();
   }
 }