@realtimex/sdk 1.7.21 → 2.0.1

package/dist/index.mjs

@@ -6,3689 +6,22 @@ import {
   ServerError,
   V1ApiNamespace,
   ValidationError
-} from "./chunk-Z5GAUBIM.mjs";
-
-// src/modules/api.ts
-var PermissionDeniedError = class extends Error {
-  constructor(permission, message, code = "PERMISSION_DENIED") {
-    super(message || `Permission '${permission}' was denied`);
-    this.name = "PermissionDeniedError";
-    this.permission = permission;
-    this.code = code;
-  }
-};
-var PermissionRequiredError = class extends Error {
-  constructor(permission, message, code = "PERMISSION_REQUIRED") {
-    super(message || `Permission '${permission}' is required`);
-    this.name = "PermissionRequiredError";
-    this.permission = permission;
-    this.code = code;
-  }
-};
-var ApiModule = class {
-  constructor(realtimexUrl, appId, appName, apiKey) {
-    this.realtimexUrl = realtimexUrl.replace(/\/$/, "");
-    this.appId = appId;
-    this.appName = appName || process.env.RTX_APP_NAME || "Local App";
-    this.apiKey = apiKey;
-  }
-  getHeaders() {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.apiKey) {
-      headers["Authorization"] = `Bearer ${this.apiKey}`;
-    }
-    if (this.appId) {
-      headers["x-app-id"] = this.appId;
-    }
-    return headers;
-  }
-  /**
-   * Request a single permission from Electron via internal API
-   */
-  async requestPermission(permission) {
-    try {
-      const response = await fetch(`${this.realtimexUrl}/api/local-apps/request-permission`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          app_id: this.appId,
-          app_name: this.appName,
-          permission
-        })
-      });
-      const data = await response.json();
-      return data.granted === true;
-    } catch (error) {
-      return false;
-    }
-  }
-  /**
-   * Make an API call with automatic permission handling
-   */
-  async apiCall(method, endpoint, options) {
-    const url = `${this.realtimexUrl}${endpoint}`;
-    const response = await fetch(url, {
-      method,
-      headers: this.getHeaders(),
-      ...options
-    });
-    const data = await response.json();
-    if (response.status === 403) {
-      const errorCode = data.error;
-      const permission = data.permission;
-      const message = data.message;
-      if (errorCode === "PERMISSION_REQUIRED" && permission) {
-        const granted = await this.requestPermission(permission);
-        if (granted) {
-          return this.apiCall(method, endpoint, options);
-        } else {
-          throw new PermissionDeniedError(permission, message);
-        }
-      }
-      if (errorCode === "PERMISSION_DENIED") {
-        throw new PermissionDeniedError(permission, message);
-      }
-      throw new Error(data.error || "Permission denied");
-    }
-    if (!response.ok) {
-      throw new Error(data.error || `API call failed: ${response.status}`);
-    }
-    return data;
-  }
-  async getAgents() {
-    const data = await this.apiCall("GET", "/agents");
-    return data.agents;
-  }
-  async getWorkspaces() {
-    const data = await this.apiCall("GET", "/workspaces");
-    return data.workspaces;
-  }
-  async getThreads(workspaceSlug) {
-    const data = await this.apiCall("GET", `/workspaces/${encodeURIComponent(workspaceSlug)}/threads`);
-    return data.threads;
-  }
-  async getTask(taskUuid) {
-    const data = await this.apiCall("GET", `/task/${encodeURIComponent(taskUuid)}`);
-    return { ...data.task, runs: data.runs };
-  }
-};
-
-// src/modules/activities.ts
-var ActivitiesModule = class {
-  constructor(realtimexUrl, appId, appName, apiKey) {
-    this.baseUrl = realtimexUrl.replace(/\/$/, "");
-    this.appId = appId;
-    this.appName = appName || process.env.RTX_APP_NAME || "Local App";
-    this.apiKey = apiKey;
-  }
-  /**
-   * Request a single permission from Electron via internal API
-   */
-  async requestPermission(permission) {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/local-apps/request-permission`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          app_id: this.appId,
-          app_name: this.appName,
-          permission
-        })
-      });
-      const data = await response.json();
-      return data.granted === true;
-    } catch (error) {
-      console.error("[SDK] Permission request failed:", error);
-      return false;
-    }
-  }
-  async request(path, options = {}) {
-    const url = `${this.baseUrl}${path}`;
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.apiKey) {
-      headers["Authorization"] = `Bearer ${this.apiKey}`;
-    }
-    if (this.appId) {
-      headers["x-app-id"] = this.appId;
-    }
-    const response = await fetch(url, {
-      ...options,
-      headers: {
-        ...headers,
-        ...options.headers
-      }
-    });
-    const data = await response.json();
-    if (response.status === 403) {
-      const errorCode = data.error;
-      const permission = data.permission;
-      const message = data.message;
-      if (errorCode === "PERMISSION_REQUIRED" && permission) {
-        const granted = await this.requestPermission(permission);
-        if (granted) {
-          return this.request(path, options);
-        } else {
-          throw new PermissionDeniedError(permission, message);
-        }
-      }
-      if (errorCode === "PERMISSION_DENIED") {
-        throw new PermissionDeniedError(permission, message);
-      }
-    }
-    if (!response.ok) {
-      throw new Error(data.error || `Request failed: ${response.status}`);
-    }
-    return data;
-  }
-  /**
-   * Insert a new activity
-   */
-  async insert(rawData) {
-    const result = await this.request("/activities", {
-      method: "POST",
-      body: JSON.stringify({ raw_data: rawData })
-    });
-    return result.data;
-  }
-  /**
-   * Update an existing activity
-   */
-  async update(id, updates) {
-    const result = await this.request(`/activities/${id}`, {
-      method: "PATCH",
-      body: JSON.stringify(updates)
-    });
-    return result.data;
-  }
-  /**
-   * Delete an activity
-   */
-  async delete(id) {
-    await this.request(`/activities/${id}`, {
-      method: "DELETE"
-    });
-  }
-  /**
-   * Get a single activity by ID
-   */
-  async get(id) {
-    try {
-      const result = await this.request(`/activities/${id}`);
-      return result.data;
-    } catch (error) {
-      if (error.message?.includes("not found")) return null;
-      throw error;
-    }
-  }
-  /**
-   * List activities with optional filters
-   */
-  async list(options) {
-    const params = new URLSearchParams();
-    if (options?.status) params.set("status", options.status);
-    if (options?.limit) params.set("limit", String(options.limit));
-    if (options?.offset) params.set("offset", String(options.offset));
-    const query = params.toString() ? `?${params}` : "";
-    const result = await this.request(`/activities${query}`);
-    return result.data;
-  }
-};
-
-// src/modules/contract.ts
-import { createHash, createHmac, randomUUID } from "crypto";
-var LOCAL_APP_CONTRACT_VERSION = "local-app-contract/v1";
-var CONTRACT_SIGNATURE_HEADER = "x-rtx-contract-signature";
-var CONTRACT_EVENT_ID_HEADER = "x-rtx-event-id";
-var CONTRACT_SIGNATURE_ALGORITHM = "sha256";
-var CONTRACT_ATTEMPT_PREFIX = "run-";
-var CONTRACT_EVENT_ALIASES = {
-  "trigger-agent": "task.trigger",
-  "task.trigger": "task.trigger",
-  ping: "system.ping",
-  "system.ping": "system.ping",
-  claim: "task.claimed",
-  claimed: "task.claimed",
-  "task.claimed": "task.claimed",
-  "task-start": "task.started",
-  start: "task.started",
-  "task.started": "task.started",
-  "task-progress": "task.progress",
-  progress: "task.progress",
-  processing: "task.progress",
-  "task.progress": "task.progress",
-  "task-complete": "task.completed",
-  complete: "task.completed",
-  completed: "task.completed",
-  "task.completed": "task.completed",
-  "task-fail": "task.failed",
-  fail: "task.failed",
-  failed: "task.failed",
-  "task.failed": "task.failed",
-  "task-cancel": "task.canceled",
-  "task-cancelled": "task.canceled",
-  "task-canceled": "task.canceled",
-  cancel: "task.canceled",
-  cancelled: "task.canceled",
-  canceled: "task.canceled",
-  "task.canceled": "task.canceled"
-};
-var CONTRACT_LEGACY_ACTIONS = {
-  "task.trigger": "trigger-agent",
-  "system.ping": "ping",
-  "task.claimed": "claim",
-  "task.started": "start",
-  "task.progress": "progress",
-  "task.completed": "complete",
-  "task.failed": "fail",
-  "task.canceled": "cancel"
-};
-function normalizeContractEvent(eventLike) {
-  if (!eventLike || typeof eventLike !== "string") return null;
-  const normalized = CONTRACT_EVENT_ALIASES[eventLike.trim().toLowerCase()];
-  return normalized || null;
-}
-function normalizeAttemptId(attemptLike) {
-  if (attemptLike === null || attemptLike === void 0) return void 0;
-  if (typeof attemptLike === "number" && Number.isInteger(attemptLike) && attemptLike > 0) {
-    return `${CONTRACT_ATTEMPT_PREFIX}${attemptLike}`;
-  }
-  if (typeof attemptLike !== "string") return void 0;
-  const trimmed = attemptLike.trim();
-  if (!trimmed) return void 0;
-  if (trimmed.startsWith(CONTRACT_ATTEMPT_PREFIX)) return trimmed;
-  if (/^\d+$/.test(trimmed)) return `${CONTRACT_ATTEMPT_PREFIX}${trimmed}`;
-  return trimmed;
-}
-function parseAttemptRunId(attemptLike) {
-  const attemptId = normalizeAttemptId(attemptLike);
-  if (!attemptId) return null;
-  const matched = attemptId.match(/^run[-_:]?(\d+)$/i);
-  if (!matched) return null;
-  const value = Number(matched[1]);
-  return Number.isInteger(value) && value > 0 ? value : null;
-}
-function hashContractPayload(payload) {
-  const normalized = payload && typeof payload === "object" ? payload : { value: payload ?? null };
-  return createHash("sha256").update(JSON.stringify(normalized)).digest("hex");
-}
-function createContractEventId() {
-  return randomUUID();
-}
-function buildContractSignatureMessage({
-  eventId,
-  eventType,
-  taskId,
-  attemptId,
-  timestamp,
-  payload
-}) {
-  return [
-    String(eventId || ""),
-    String(normalizeContractEvent(String(eventType || "")) || eventType || ""),
-    String(taskId || ""),
-    String(normalizeAttemptId(attemptId) || ""),
-    String(timestamp || ""),
-    hashContractPayload(payload ?? {})
-  ].join(".");
-}
-function signContractEvent(input) {
-  const signatureMessage = buildContractSignatureMessage(input);
-  const digest = createHmac(CONTRACT_SIGNATURE_ALGORITHM, input.secret).update(signatureMessage).digest("hex");
-  return `${CONTRACT_SIGNATURE_ALGORITHM}=${digest}`;
-}
-function canonicalEventToLegacyAction(eventLike) {
-  const normalized = normalizeContractEvent(eventLike);
-  if (!normalized) return null;
-  return CONTRACT_LEGACY_ACTIONS[normalized] || null;
-}
-function buildContractIdempotencyKey({
-  taskId,
-  eventType,
-  eventId,
-  attemptId,
-  machineId,
-  timestamp,
-  payload
-}) {
-  const canonicalEvent = normalizeContractEvent(eventType) || eventType;
-  if (eventId) {
-    const eventToken = createHash("sha256").update(String(eventId)).digest("hex");
-    return `${taskId}:${canonicalEvent}:event:${eventToken}`;
-  }
-  const hashInput = {
-    task_id: taskId,
-    event_type: canonicalEvent,
-    attempt_id: normalizeAttemptId(attemptId),
-    machine_id: machineId || null,
-    timestamp: timestamp || null,
-    payload_hash: hashContractPayload(payload ?? {})
-  };
-  const token = createHash("sha256").update(JSON.stringify(hashInput)).digest("hex");
-  return `${taskId}:${canonicalEvent}:hash:${token}`;
-}
-var ContractModule = class {
-  constructor(realtimexUrl, appName, appId, apiKey) {
-    this.cachedContract = null;
-    this.cachedCapabilities = null;
-    this.cachedCapabilityCatalogHash = null;
-    this.realtimexUrl = realtimexUrl.replace(/\/$/, "");
-    this.appName = appName;
-    this.appId = appId;
-    this.apiKey = apiKey;
-  }
-  async requestPermission(permission) {
-    try {
-      const response = await fetch(`${this.realtimexUrl}/api/local-apps/request-permission`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          app_id: this.appId,
-          app_name: this.appName,
-          permission
-        })
-      });
-      const data = await response.json();
-      return data.granted === true;
-    } catch {
-      return false;
-    }
-  }
-  async request(path, options = {}) {
-    const url = `${this.realtimexUrl}${path}`;
-    const headers = {
-      "Content-Type": "application/json",
-      ...options.headers
-    };
-    if (this.apiKey) headers.Authorization = `Bearer ${this.apiKey}`;
-    if (this.appId) headers["x-app-id"] = this.appId;
-    const response = await fetch(url, {
-      method: options.method || "GET",
-      headers,
-      body: options.body
-    });
-    const data = await response.json();
-    if (response.status === 403) {
-      const errorCode = data.error;
-      const permission = data.permission;
-      const message = data.message;
-      if (errorCode === "PERMISSION_REQUIRED" && permission) {
-        const granted = await this.requestPermission(permission);
-        if (granted) return this.request(path, options);
-        throw new PermissionDeniedError(permission, message);
-      }
-      if (errorCode === "PERMISSION_DENIED") {
-        throw new PermissionDeniedError(permission, message);
-      }
-    }
-    if (!response.ok) {
-      throw new Error(data.error || `Request failed: ${response.status}`);
-    }
-    return data;
-  }
-  async getLocalAppV1(forceRefresh = false) {
-    if (!forceRefresh && this.cachedContract) return this.cachedContract;
-    const data = await this.request("/contracts/local-app/v1");
-    this.cachedContract = data.contract;
-    if (Array.isArray(data.contract?.capabilities)) {
-      this.cachedCapabilities = data.contract.capabilities;
-      this.cachedCapabilityCatalogHash = data.contract.catalog_hash || null;
-    }
-    return data.contract;
-  }
-  async listCapabilities(forceRefresh = false) {
-    if (!forceRefresh && this.cachedCapabilities) return this.cachedCapabilities;
-    const data = await this.request(
-      "/contracts/local-app/v1/capabilities"
-    );
-    this.cachedCapabilities = Array.isArray(data.capabilities) ? data.capabilities : [];
-    this.cachedCapabilityCatalogHash = data.catalog_hash || null;
-    return this.cachedCapabilities;
-  }
-  async searchCapabilities(query) {
-    const normalizedQuery = String(query || "").trim();
-    if (!normalizedQuery) {
-      throw new Error("searchCapabilities requires a non-empty query");
-    }
-    const encodedQuery = encodeURIComponent(normalizedQuery);
-    const data = await this.request(
-      `/contracts/local-app/v1/capabilities/search?q=${encodedQuery}`
-    );
-    return Array.isArray(data.capabilities) ? data.capabilities : [];
-  }
-  async describeCapability(capabilityId) {
-    const normalizedCapabilityId = String(capabilityId || "").trim();
-    if (!normalizedCapabilityId) {
-      throw new Error("describeCapability requires a non-empty capability id");
-    }
-    const encodedCapabilityId = encodeURIComponent(normalizedCapabilityId);
-    const data = await this.request(
-      `/contracts/local-app/v1/capabilities/${encodedCapabilityId}`
-    );
-    return data.capability;
-  }
-  // Alias for agentic contract flow naming.
-  async search(query) {
-    return this.searchCapabilities(query);
-  }
-  // Alias for agentic contract flow naming.
-  async describe(capabilityId) {
-    return this.describeCapability(capabilityId);
-  }
-  async invoke(payload) {
-    const capabilityId = String(payload?.capability_id || "").trim();
-    if (!capabilityId) {
-      throw new Error("invoke requires payload.capability_id");
-    }
-    if (payload.auto_run && (!payload.agent_name || !payload.workspace_slug)) {
-      throw new Error("auto_run requires agent_name and workspace_slug");
-    }
-    const args = payload.args && typeof payload.args === "object" && !Array.isArray(payload.args) ? { ...payload.args } : {};
-    if (!args.capability) {
-      args.capability = capabilityId;
-    }
-    return this.request("/webhooks/realtimex", {
-      method: "POST",
-      body: JSON.stringify({
-        app_name: this.appName,
-        app_id: this.appId,
-        event: "task.trigger",
-        event_id: payload.event_id || createContractEventId(),
-        attempt_id: normalizeAttemptId(payload.attempt_id),
-        payload: {
-          raw_data: args,
-          auto_run: payload.auto_run ?? false,
-          agent_name: payload.agent_name,
-          workspace_slug: payload.workspace_slug,
-          thread_slug: payload.thread_slug,
-          prompt: payload.prompt ?? ""
-        }
-      })
-    });
-  }
-  getCachedCatalogHash() {
-    return this.cachedCapabilityCatalogHash;
-  }
-  clearCache() {
-    this.cachedContract = null;
-    this.cachedCapabilities = null;
-    this.cachedCapabilityCatalogHash = null;
-  }
-};
-
-// src/modules/webhook.ts
-var WebhookModule = class {
-  constructor(realtimexUrl, appName, appId, apiKey) {
-    this.realtimexUrl = realtimexUrl.replace(/\/$/, "");
-    this.appName = appName;
-    this.appId = appId;
-    this.apiKey = apiKey;
-  }
-  /**
-   * Request a single permission from Electron via internal API
-   */
-  async requestPermission(permission) {
-    try {
-      const response = await fetch(`${this.realtimexUrl}/api/local-apps/request-permission`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          app_id: this.appId,
-          app_name: this.appName,
-          permission
-        })
-      });
-      const data = await response.json();
-      return data.granted === true;
-    } catch (error) {
-      console.error("[SDK] Permission request failed:", error);
-      return false;
-    }
-  }
-  async request(path, options = {}) {
-    const url = `${this.realtimexUrl}${path}`;
-    const headers = {
-      "Content-Type": "application/json",
-      ...options.headers
-    };
-    if (this.apiKey) {
-      headers["Authorization"] = `Bearer ${this.apiKey}`;
-    }
-    if (this.appId) {
-      headers["x-app-id"] = this.appId;
-    }
-    const response = await fetch(url, {
-      ...options,
-      headers
-    });
-    const data = await response.json();
-    if (response.status === 403) {
-      const errorCode = data.error;
-      const permission = data.permission;
-      const message = data.message;
-      if (errorCode === "PERMISSION_REQUIRED" && permission) {
-        const granted = await this.requestPermission(permission);
-        if (granted) {
-          return this.request(path, options);
-        } else {
-          throw new PermissionDeniedError(permission, message);
-        }
-      }
-      if (errorCode === "PERMISSION_DENIED") {
-        throw new PermissionDeniedError(permission, message);
-      }
-    }
-    if (!response.ok) {
-      throw new Error(data.error || `Request failed: ${response.status}`);
-    }
-    return data;
-  }
-  async triggerAgent(payload) {
-    if (payload.auto_run && (!payload.agent_name || !payload.workspace_slug)) {
-      throw new Error("auto_run requires agent_name and workspace_slug");
-    }
-    return this.request("/webhooks/realtimex", {
-      method: "POST",
-      body: JSON.stringify({
-        app_name: this.appName,
-        app_id: this.appId,
-        event: "task.trigger",
-        event_id: payload.event_id || createContractEventId(),
-        attempt_id: normalizeAttemptId(payload.attempt_id),
-        payload: {
-          raw_data: payload.raw_data,
-          auto_run: payload.auto_run ?? false,
-          agent_name: payload.agent_name,
-          workspace_slug: payload.workspace_slug,
-          thread_slug: payload.thread_slug,
-          prompt: payload.prompt ?? ""
-        }
-      })
-    });
-  }
-  async ping() {
-    return this.request("/webhooks/realtimex", {
-      method: "POST",
-      body: JSON.stringify({
-        app_name: this.appName,
-        app_id: this.appId,
-        event: "system.ping",
-        event_id: createContractEventId()
-      })
-    });
-  }
-};
-
-// src/modules/task.ts
-var TaskModule = class {
-  constructor(realtimexUrl, appName, appId, apiKey) {
-    this.realtimexUrl = realtimexUrl.replace(/\/$/, "");
-    this.appName = appName;
-    this.appId = appId;
-    this.apiKey = apiKey;
-    this.callbackSecret = process.env.RTX_CONTRACT_CALLBACK_SECRET;
-    this.signCallbacksByDefault = process.env.RTX_CONTRACT_SIGN_CALLBACKS === "true";
-  }
-  /**
-   * Configure callback signing behavior.
-   */
-  configureContract(config) {
-    if (typeof config.callbackSecret === "string") {
-      this.callbackSecret = config.callbackSecret;
-    }
-    if (typeof config.signCallbacksByDefault === "boolean") {
-      this.signCallbacksByDefault = config.signCallbacksByDefault;
-    }
-  }
-  /**
-   * Claim a task before processing.
-   */
-  async claim(taskUuid, options = {}) {
-    return this._sendEvent("task.claimed", taskUuid, {}, options);
-  }
-  /**
-   * Alias for claim()
-   */
-  async claimed(taskUuid, options = {}) {
-    return this.claim(taskUuid, options);
-  }
-  /**
-   * Mark task as processing.
-   * Backward compatible signature: start(taskUuid, machineId?)
-   */
-  async start(taskUuid, machineIdOrOptions) {
-    return this._sendEvent("task.started", taskUuid, {}, this._normalizeOptions(machineIdOrOptions));
-  }
-  /**
-   * Report incremental task progress.
-   */
-  async progress(taskUuid, progressData = {}, options = {}) {
-    return this._sendEvent("task.progress", taskUuid, progressData, options);
-  }
-  /**
-   * Mark task as completed with result.
-   * Backward compatible signature: complete(taskUuid, result?, machineId?)
-   */
-  async complete(taskUuid, result = {}, machineIdOrOptions) {
-    return this._sendEvent("task.completed", taskUuid, { result }, this._normalizeOptions(machineIdOrOptions));
-  }
-  /**
-   * Mark task as failed with error.
-   * Backward compatible signature: fail(taskUuid, error, machineId?)
-   */
-  async fail(taskUuid, error, machineIdOrOptions) {
-    return this._sendEvent("task.failed", taskUuid, { error }, this._normalizeOptions(machineIdOrOptions));
-  }
-  /**
-   * Mark task as canceled.
-   */
-  async cancel(taskUuid, reason, options = {}) {
-    const payload = reason ? { error: reason } : {};
-    return this._sendEvent("task.canceled", taskUuid, payload, options);
-  }
-  _normalizeOptions(machineIdOrOptions) {
-    if (!machineIdOrOptions) return {};
-    if (typeof machineIdOrOptions === "string") {
-      return { machineId: machineIdOrOptions };
-    }
-    return machineIdOrOptions;
-  }
-  async _sendEvent(event, taskUuid, eventData = {}, options = {}) {
-    if (!taskUuid || !taskUuid.trim()) {
-      throw new Error("taskUuid is required");
-    }
-    const attemptId = normalizeAttemptId(options.attemptId);
-    const timestamp = options.timestamp || (/* @__PURE__ */ new Date()).toISOString();
-    const eventId = options.eventId || createContractEventId();
-    const callbackUrl = options.callbackUrl;
-    const targetUrl = callbackUrl || `${this.realtimexUrl}/webhooks/realtimex`;
-    const sendingToMainWebhook = !callbackUrl;
-    const includeAppAuth = sendingToMainWebhook || targetUrl.startsWith(this.realtimexUrl);
-    const payloadData = eventData && typeof eventData === "object" ? eventData : {};
-    const headers = { "Content-Type": "application/json" };
-    headers[CONTRACT_EVENT_ID_HEADER] = eventId;
-    if (includeAppAuth) {
-      if (this.apiKey) headers.Authorization = `Bearer ${this.apiKey}`;
-      if (this.appId) headers["x-app-id"] = this.appId;
-    }
-    const callbackSecret = options.callbackSecret || this.callbackSecret;
-    const shouldSign = options.sign ?? this.signCallbacksByDefault;
-    if (shouldSign) {
-      if (!callbackSecret) {
-        throw new Error(
-          "Callback signing is enabled but no callbackSecret is configured. Use task.configureContract({ callbackSecret }) or pass options.callbackSecret."
-        );
-      }
-      headers[CONTRACT_SIGNATURE_HEADER] = signContractEvent({
-        secret: callbackSecret,
-        eventId,
-        eventType: event,
-        taskId: taskUuid,
-        attemptId,
-        timestamp,
-        payload: payloadData
-      });
-    }
-    const requestBody = sendingToMainWebhook ? {
-      app_name: this.appName,
-      app_id: this.appId,
-      event,
-      event_id: eventId,
-      attempt_id: attemptId,
-      payload: {
-        task_uuid: taskUuid,
-        machine_id: options.machineId,
-        timestamp,
-        attempt_id: attemptId,
-        ...payloadData
-      }
-    } : {
-      event,
-      action: canonicalEventToLegacyAction(event),
-      event_id: eventId,
-      attempt_id: attemptId,
-      machine_id: options.machineId,
-      user_email: options.userEmail,
-      activity_id: options.activityId,
-      table_name: options.tableName,
-      timestamp,
-      data: payloadData
-    };
-    const response = await fetch(targetUrl, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(requestBody)
-    });
-    const responseData = await response.json();
-    if (!response.ok) throw new Error(responseData.error || `Failed to ${event}`);
-    return {
-      ...responseData,
-      task_uuid: responseData.task_uuid || responseData.task_id || taskUuid,
-      event_id: responseData.event_id || eventId,
-      attempt_id: responseData.attempt_id || attemptId,
-      event_type: responseData.event_type || event
-    };
-  }
-};
-
-// src/modules/port.ts
-import * as net from "net";
-var PortModule = class {
-  constructor(defaultPort = 8080) {
-    this.defaultPort = defaultPort;
-  }
-  /**
-   * Get suggested port from environment (RTX_PORT) or default
-   */
-  getSuggestedPort() {
-    const envPort = process.env.RTX_PORT;
-    return envPort ? parseInt(envPort, 10) : this.defaultPort;
-  }
-  /**
-   * Check if a port is available on a specific host
-   */
-  async isPortAvailableOn(port, host) {
-    return new Promise((resolve) => {
-      const server = net.createServer();
-      server.once("error", () => resolve(false));
-      server.once("listening", () => {
-        server.close();
-        resolve(true);
-      });
-      server.listen(port, host);
-    });
-  }
-  /**
-   * Check if a port is available (checks both IPv4 and IPv6)
-   * @param port - Port number to check
-   * @returns Promise resolving to true if port is available on ALL interfaces
-   */
-  async isPortAvailable(port) {
-    const ipv4Available = await this.isPortAvailableOn(port, "127.0.0.1");
-    if (!ipv4Available) return false;
-    const ipv6Available = await this.isPortAvailableOn(port, "::1");
-    if (!ipv6Available) return false;
-    const allInterfacesAvailable = await this.isPortAvailableOn(port, "0.0.0.0");
-    return allInterfacesAvailable;
-  }
-  /**
-   * Find an available port starting from the suggested port
-   * @param startPort - Starting port number (default: RTX_PORT or defaultPort)
-   * @param maxAttempts - Maximum ports to try (default: 100)
-   * @returns Promise resolving to an available port number
-   * @throws Error if no available port found in range
-   */
-  async findAvailablePort(startPort, maxAttempts = 100) {
-    const port = startPort ?? this.getSuggestedPort();
-    for (let i = 0; i < maxAttempts; i++) {
-      const currentPort = port + i;
-      if (await this.isPortAvailable(currentPort)) {
-        return currentPort;
-      }
-    }
-    throw new Error(`No available port found in range ${port}-${port + maxAttempts - 1}`);
-  }
-  /**
-   * Get a ready-to-use port
-   * Returns the suggested port if available, otherwise finds the next available port
-   * 
-   * @example
-   * ```typescript
-   * const sdk = new RealtimeXSDK();
-   * const port = await sdk.port.getPort();
-   * app.listen(port);
-   * ```
-   */
-  async getPort() {
-    const suggested = this.getSuggestedPort();
-    if (await this.isPortAvailable(suggested)) {
-      return suggested;
-    }
-    return this.findAvailablePort(suggested + 1);
-  }
-};
-
-// src/modules/llm.ts
-var LLMPermissionError = class extends PermissionRequiredError {
-  constructor(permission, code = "PERMISSION_REQUIRED") {
-    super(permission, void 0, code);
-    this.name = "LLMPermissionError";
-  }
-};
-var LLMProviderError = class extends Error {
-  constructor(message, code = "LLM_ERROR") {
-    super(message);
-    this.code = code;
-    this.name = "LLMProviderError";
-  }
-};
-var VectorStore = class {
-  constructor(baseUrl, appId, appName = "Local App", apiKey) {
-    this.baseUrl = baseUrl;
-    this.appId = appId;
-    this.appName = appName;
-    this.apiKey = apiKey;
-  }
-  get headers() {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.apiKey) {
-      headers["Authorization"] = `Bearer ${this.apiKey}`;
-    }
-    if (this.appId) {
-      headers["x-app-id"] = this.appId;
-    }
-    return headers;
-  }
-  /**
-   * Request a single permission from Electron via internal API
-   */
-  async requestPermission(permission) {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/local-apps/request-permission`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          app_id: this.appId,
-          app_name: this.appName,
-          permission
-        })
-      });
-      const data = await response.json();
-      return data.granted === true;
-    } catch (error) {
-      return false;
-    }
-  }
-  /**
-   * Internal request wrapper that handles automatic permission prompts
-   */
-  async request(method, endpoint, body) {
-    const response = await fetch(`${this.baseUrl}${endpoint}`, {
-      method,
-      headers: this.headers,
-      body: body ? JSON.stringify(body) : void 0
-    });
-    const data = await response.json();
-    if (data.code === "PERMISSION_REQUIRED") {
-      const permission = data.permission || "vectors.read";
-      const granted = await this.requestPermission(permission);
-      if (granted) {
-        return this.request(method, endpoint, body);
-      }
-      throw new PermissionDeniedError(permission);
-    }
-    if (!data.success && data.error) {
-      if (data.code === "LLM_ERROR") {
-        throw new LLMProviderError(data.error);
-      }
-      throw new Error(data.error);
-    }
-    return data;
-  }
-  /**
-   * Upsert (insert or update) vectors into storage
-   * 
-   * @example
-   * ```ts
-   * await sdk.llm.vectors.upsert([
-   *   { id: 'chunk-1', vector: embeddings[0], metadata: { text: 'Hello', documentId: 'doc-1' } }
-   * ], { workspaceId: 'ws-123' });
-   * ```
-   */
-  async upsert(vectors, options = {}) {
-    return this.request("POST", "/sdk/llm/vectors/upsert", {
-      vectors,
-      workspaceId: options.workspaceId
-    });
-  }
-  /**
-   * Query similar vectors by embedding
-   * 
-   * @example
-   * ```ts
-   * const results = await sdk.llm.vectors.query(queryVector, {
-   *   topK: 5,
-   *   filter: { documentId: 'doc-1' },
-   *   workspaceId: 'ws-123'
-   * });
-   * ```
-   */
-  async query(vector, options = {}) {
-    return this.request("POST", "/sdk/llm/vectors/query", {
-      vector,
-      topK: options.topK ?? 5,
-      filter: options.filter,
-      workspaceId: options.workspaceId
-    });
-  }
-  /**
-   * Delete vectors from storage
-   * 
-   * Note: Currently only supports deleteAll: true
-   * Use workspaceId to scope deletion to a specific workspace
-   * 
-   * @example
-   * ```ts
-   * await sdk.llm.vectors.delete({ deleteAll: true, workspaceId: 'ws-123' });
-   * ```
-   */
-  async delete(options) {
-    return this.request("POST", "/sdk/llm/vectors/delete", options);
-  }
-  /**
-   * List all available workspaces (namespaces) for this app
-   * 
-   * @example
-   * ```ts
-   * const { workspaces } = await sdk.llm.vectors.listWorkspaces();
-   * console.log('Workspaces:', workspaces);
-   * ```
-   */
-  async listWorkspaces() {
-    return this.request("GET", "/sdk/llm/vectors/workspaces");
-  }
-  /**
-   * Register a custom vector database configuration for this app
-   * 
-   * @example
-   * ```ts
-   * await sdk.llm.vectors.registerConfig('lancedb', { });
-   * ```
-   */
-  async registerConfig(provider, config) {
-    return this.request("POST", "/sdk/llm/vectors/register", {
-      provider,
-      config
-    });
-  }
-  /**
-   * List all supported vector database providers and their configuration requirements
-   */
-  async listProviders() {
-    return this.request("GET", "/sdk/llm/vectors/providers");
-  }
-  /**
-   * Get the current vector database configuration for this app
-   * 
-   * @example
-   * ```ts
-   * const { provider, config } = await sdk.llm.vectors.getConfig();
-   * console.log(`App is using ${provider}`);
-   * ```
-   */
-  async getConfig() {
-    return this.request("GET", "/sdk/llm/vectors/config");
-  }
-};
-var LLMModule = class {
-  constructor(baseUrl, appId, appName = "Local App", apiKey) {
-    this.baseUrl = baseUrl;
-    this.appId = appId;
-    this.appName = appName;
-    this.apiKey = apiKey;
-    this.vectors = new VectorStore(baseUrl, appId, appName, apiKey);
-  }
-  get headers() {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.apiKey) {
-      headers["Authorization"] = `Bearer ${this.apiKey}`;
-    }
-    if (this.appId) {
-      headers["x-app-id"] = this.appId;
-    }
-    return headers;
-  }
-  /**
-   * Request a single permission from Electron via internal API
-   */
-  async requestPermission(permission) {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/local-apps/request-permission`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          app_id: this.appId,
-          app_name: this.appName,
-          permission
-        })
-      });
-      const data = await response.json();
-      return data.granted === true;
-    } catch (error) {
-      return false;
-    }
-  }
-  /**
-   * Internal request wrapper that handles automatic permission prompts
-   */
-  async request(method, endpoint, body) {
-    const response = await fetch(`${this.baseUrl}${endpoint}`, {
-      method,
-      headers: this.headers,
-      body: body ? JSON.stringify(body) : void 0
-    });
-    const data = await response.json();
-    if (data.code === "PERMISSION_REQUIRED") {
-      const permission = data.permission || "llm.chat";
-      const granted = await this.requestPermission(permission);
-      if (granted) {
-        return this.request(method, endpoint, body);
-      }
-      throw new PermissionDeniedError(permission);
-    }
-    if (!data.success && data.error) {
-      if (data.code === "LLM_ERROR") {
-        throw new LLMProviderError(data.error);
-      }
-      throw new Error(data.error);
-    }
-    return data;
-  }
-  /**
-   * Get only configured chat (LLM) providers
-   * 
-   * @example
-   * ```ts
-   * const { providers } = await sdk.llm.chatProviders();
-   * console.log('Available chat models:', providers[0].models);
-   * ```
-   */
-  async chatProviders() {
-    return this.request("GET", "/sdk/llm/providers/chat");
-  }
-  /**
-   * Get only configured embedding providers
-   * 
-   * @example
-   * ```ts
-   * const { providers } = await sdk.llm.embedProviders();
-   * console.log('Available embedding models:', providers[0].models);
-   * ```
-   */
-  async embedProviders() {
-    return this.request("GET", "/sdk/llm/providers/embed");
-  }
-  /**
-   * Send a chat completion request (synchronous)
-   * 
-   * @example
-   * ```ts
-   * const response = await sdk.llm.chat([
-   *   { role: 'system', content: 'You are a helpful assistant.' },
-   *   { role: 'user', content: 'Hello!' }
-   * ], { model: 'gpt-4o', temperature: 0.7 });
-   * 
-   * console.log(response.response?.content);
-   * ```
-   */
-  async chat(messages, options = {}) {
-    return this.request("POST", "/sdk/llm/chat", {
-      messages,
-      model: options.model,
-      provider: options.provider,
-      temperature: options.temperature ?? 0.7,
-      max_tokens: options.max_tokens ?? 1e3,
-      response_format: options.response_format
-    });
-  }
-  /**
-   * Send a streaming chat completion request (SSE)
-   * 
-   * @example
-   * ```ts
-   * for await (const chunk of sdk.llm.chatStream([
-   *   { role: 'user', content: 'Tell me a story' }
-   * ])) {
-   *   process.stdout.write(chunk.textResponse || '');
-   * }
-   * ```
-   */
-  async *chatStream(messages, options = {}) {
-    const response = await fetch(`${this.baseUrl}/sdk/llm/chat/stream`, {
-      method: "POST",
-      headers: {
-        ...this.headers,
-        "Accept": "text/event-stream"
-      },
-      body: JSON.stringify({
-        messages,
-        model: options.model,
-        provider: options.provider,
-        temperature: options.temperature ?? 0.7,
-        max_tokens: options.max_tokens ?? 1e3,
-        response_format: options.response_format
-      })
-    });
-    if (!response.ok) {
-      const errorData = await response.json();
-      if (errorData.code === "PERMISSION_REQUIRED") {
-        const permission = errorData.permission || "llm.chat";
-        const granted = await this.requestPermission(permission);
-        if (granted) {
-          yield* this.chatStream(messages, options);
-          return;
-        }
-        throw new PermissionDeniedError(permission);
-      }
-      throw new LLMProviderError(errorData.error || "Stream request failed");
-    }
-    const reader = response.body?.getReader();
-    if (!reader) {
-      throw new LLMProviderError("Response body is not readable");
-    }
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let isErrorEvent = false;
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          const trimmedLine = line.trim();
-          if (!trimmedLine || trimmedLine.startsWith(":")) continue;
-          if (trimmedLine.startsWith("event: error")) {
-            isErrorEvent = true;
-            continue;
-          }
-          if (trimmedLine.startsWith("data: ")) {
-            const jsonStr = trimmedLine.slice(6);
-            if (jsonStr === "[DONE]") {
-              isErrorEvent = false;
-              continue;
-            }
-            try {
-              const data = JSON.parse(jsonStr);
-              if (isErrorEvent) {
-                isErrorEvent = false;
-                throw new LLMProviderError(
-                  data.error || "Stream error",
-                  data.code || "LLM_STREAM_ERROR"
-                );
-              }
-              const chunk = data;
-              if (chunk.error) {
-                throw new LLMProviderError(
-                  chunk.message || "Stream error"
-                );
-              }
-              yield chunk;
-            } catch (parseError) {
-              isErrorEvent = false;
-              if (jsonStr !== "[DONE]") {
-                console.warn("[LLM Stream] Parse error:", jsonStr);
-              }
-              if (parseError instanceof LLMProviderError) throw parseError;
-            }
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  /**
-   * Generate vector embeddings from text
-   * 
-   * @example
-   * ```ts
-   * // Single text
-   * const { embeddings } = await sdk.llm.embed('Hello world');
-   * 
-   * // Multiple texts
-   * const { embeddings } = await sdk.llm.embed(['Hello', 'World']);
-   * ```
-   */
-  async embed(input, options = {}) {
-    const inputArray = Array.isArray(input) ? input : [input];
-    return this.request("POST", "/sdk/llm/embed", {
-      input: inputArray,
-      provider: options.provider,
-      model: options.model
-    });
-  }
-  /**
-   * Helper: Embed text and store as vectors in one call
-   * 
-   * @example
-   * ```ts
-   * await sdk.llm.embedAndStore({
-   *   texts: ['Hello world', 'Goodbye world'],
-   *   documentId: 'doc-123',
-   *   workspaceId: 'ws-456'
-   * });
-   * ```
-   */
-  async embedAndStore(params) {
-    const { texts, documentId, workspaceId, idPrefix = "chunk", provider, model } = params;
-    const embedResult = await this.embed(texts, { provider, model });
-    if (!embedResult.success || !embedResult.embeddings) {
-      return {
-        success: false,
-        error: embedResult.error || "Embedding failed",
-        code: embedResult.code
-      };
-    }
-    let uniquePrefix = idPrefix;
-    if (idPrefix === "chunk") {
-      const randomSuffix = Math.random().toString(36).substring(2, 6);
-      uniquePrefix = `chunk_${randomSuffix}`;
-    }
-    const vectors = texts.map((text, i) => ({
-      id: `${uniquePrefix}_${i}`,
-      vector: embedResult.embeddings[i],
-      metadata: {
-        text,
-        documentId,
-        workspaceId,
-        embeddingModel: embedResult.model || model || "unknown"
-      }
-    }));
-    return this.vectors.upsert(vectors, { workspaceId });
-  }
-  /**
-   * Helper: Search similar documents by text query
-   * 
-   * @example
-   * ```ts
-   * const results = await sdk.llm.search('What is RealtimeX?', {
-   *   topK: 5,
-   *   workspaceId: 'ws-123'
-   * });
-   * 
-   * for (const result of results) {
-   *   console.log(result.metadata?.text, result.score);
-   * }
-   * ```
-   */
-  async search(query, options = {}) {
-    const embedResult = await this.embed(query, {
-      provider: options.provider,
-      model: options.model
-    });
-    if (!embedResult.success || !embedResult.embeddings?.[0]) {
-      throw new LLMProviderError("Failed to embed query");
-    }
-    const queryResult = await this.vectors.query(embedResult.embeddings[0], {
-      ...options,
-      model: options.model || embedResult.model
-    });
-    if (!queryResult.success) {
-      throw new LLMProviderError(queryResult.error || "Vector search failed");
-    }
-    return queryResult.results || [];
-  }
-};
-
-// src/modules/tts.ts
-var TTSModule = class {
-  constructor(realtimexUrl, appId, appName, apiKey) {
-    this.baseUrl = realtimexUrl.replace(/\/$/, "");
-    this.appId = appId;
-    this.appName = appName || process.env.RTX_APP_NAME || "Local App";
-    this.apiKey = apiKey;
-  }
-  get headers() {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.apiKey) {
-      headers["Authorization"] = `Bearer ${this.apiKey}`;
-    }
-    if (this.appId) {
-      headers["x-app-id"] = this.appId;
-    }
-    return headers;
-  }
-  /**
-   * Request a single permission from Electron via internal API
-   */
-  async requestPermission(permission) {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/local-apps/request-permission`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          app_id: this.appId,
-          app_name: this.appName,
-          permission
-        })
-      });
-      const data = await response.json();
-      return data.granted === true;
-    } catch (error) {
-      console.error("[SDK] Permission request failed:", error);
-      return false;
-    }
-  }
-  /**
-   * Internal request wrapper that handles automatic permission prompts
-   */
-  async request(method, endpoint, body, isStream = false) {
-    const response = await fetch(`${this.baseUrl}${endpoint}`, {
-      method,
-      headers: this.headers,
-      body: body ? JSON.stringify(body) : void 0
-    });
-    if (!response.ok) {
-      const data = await response.json();
-      if (data.code === "PERMISSION_REQUIRED") {
-        const permission = data.permission || "tts.generate";
-        const granted = await this.requestPermission(permission);
-        if (granted) {
-          return this.request(method, endpoint, body, isStream);
-        }
-        throw new PermissionDeniedError(permission);
-      }
-      throw new Error(data.error || `Request failed: ${response.status}`);
-    }
-    if (isStream) {
-      return response.body;
-    }
-    const contentType = response.headers.get("content-type");
-    if (contentType && contentType.includes("application/json")) {
-      return response.json();
-    }
-    return response.arrayBuffer();
-  }
-  /**
-   * Generate speech from text (returns full buffer)
-   * 
-   * @example
-   * ```ts
-   * const buffer = await sdk.tts.speak("Hello world");
-   * // Play buffer...
-   * ```
-   */
-  async speak(text, options = {}) {
-    return this.request("POST", "/sdk/tts", {
-      text,
-      ...options
-    });
-  }
-  /**
-   * Generate speech from text with streaming (yields decoded audio chunks)
-   * Uses SSE internally but returns decoded ArrayBuffer chunks for easy playback.
-   * 
-   * @example
-   * ```ts
-   * for await (const chunk of sdk.tts.speakStream("Hello world")) {
-   *   // chunk.audio is ArrayBuffer (already decoded!)
-   *   const blob = new Blob([chunk.audio], { type: chunk.mimeType });
-   *   const audio = new Audio(URL.createObjectURL(blob));
-   *   await audio.play();
-   * }
-   * ```
-   */
-  async *speakStream(text, options = {}) {
-    const response = await fetch(`${this.baseUrl}/sdk/tts/stream`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({ text, ...options })
-    });
-    if (!response.ok) {
-      const data = await response.json();
-      if (data.code === "PERMISSION_REQUIRED") {
-        const permission = data.permission || "tts.generate";
-        const granted = await this.requestPermission(permission);
-        if (granted) {
-          yield* this.speakStream(text, options);
-          return;
-        }
-        throw new PermissionDeniedError(permission);
-      }
-      throw new Error(data.error || `Streaming failed: ${response.status}`);
-    }
-    const reader = response.body?.getReader();
-    if (!reader) throw new Error("No response body");
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let eventType = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          const trimmedLine = line.trim();
-          if (!trimmedLine) continue;
-          if (trimmedLine.startsWith("event:")) {
-            eventType = trimmedLine.slice(6).trim();
-          } else if (trimmedLine.startsWith("data:")) {
-            const eventData = trimmedLine.slice(5).trim();
-            if (eventType === "chunk" && eventData) {
-              try {
-                const parsed = JSON.parse(eventData);
-                const binaryString = atob(parsed.audio);
-                const bytes = new Uint8Array(binaryString.length);
-                for (let i = 0; i < binaryString.length; i++) {
-                  bytes[i] = binaryString.charCodeAt(i);
-                }
-                yield {
-                  index: parsed.index,
-                  total: parsed.total,
-                  audio: bytes.buffer,
-                  mimeType: parsed.mimeType
-                };
-              } catch (e) {
-                console.warn("[TTS SDK] Failed to parse chunk:", e);
-              }
-            } else if (eventType === "error" && eventData) {
-              try {
-                const err = JSON.parse(eventData);
-                throw new Error(err.error || "TTS streaming error");
-              } catch (e) {
-                if (e instanceof Error && e.message !== "TTS streaming error") {
-                  throw e;
-                }
-              }
-            }
-            eventType = "";
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  /**
-   * List available TTS providers with configuration options
-   */
-  async listProviders() {
-    const data = await this.request("GET", "/sdk/tts/providers");
-    return data.providers || [];
-  }
-};
-
-// src/modules/stt.ts
-var STTModule = class extends ApiModule {
-  /**
-   * Get available STT providers and their models.
-   * @returns Promise resolving to list of providers
-   */
-  async listProviders() {
-    try {
-      const response = await this.apiCall("GET", "/sdk/stt/providers");
-      if (!response.success) {
-        throw new Error(response.error || "Failed to fetch providers");
-      }
-      return response.providers;
-    } catch (error) {
-      throw new Error(`STT providers fetch failed: ${error.message}`);
-    }
-  }
-  /**
-   * Listen to microphone and transcribe speech to text.
-   * Performed on the client device (Electron) via the RealtimeX Hub.
-   * 
-   * @param options Configuration options for listening
-   * @returns Promise resolving to the transcribed text
-   */
-  async listen(options) {
-    try {
-      return await this.apiCall("POST", "/sdk/stt/listen", {
-        body: JSON.stringify(options)
-      });
-    } catch (error) {
-      throw new Error(`STT listen failed: ${error.message}`);
-    }
-  }
-};
-
-// src/modules/agent.ts
-var AgentModule = class {
-  constructor(httpClient) {
-    this.httpClient = httpClient;
-  }
-  /**
-   * Create a new agent session
-   *
-   * @example
-   * ```typescript
-   * const session = await sdk.agent.createSession({
-   *   workspace_slug: 'my-workspace',
-   *   agent_name: '@agent'
-   * });
-   * ```
-   */
-  async createSession(options) {
-    const response = await this.httpClient.fetch("/sdk/agent/session", {
-      method: "POST",
-      body: JSON.stringify(options || {})
-    });
-    const data = await response.json();
-    if (!response.ok) {
-      throw new Error(data.error || "Failed to create session");
-    }
-    return data.session;
-  }
-  /**
-   * Chat within a session (synchronous)
-   *
-   * @example
-   * ```typescript
-   * const response = await sdk.agent.chat(sessionId, 'Hello agent!');
-   * console.log(response.text);
-   * ```
-   */
-  async chat(sessionId, message) {
-    const response = await this.httpClient.fetch(`/sdk/agent/session/${sessionId}/chat`, {
-      method: "POST",
-      body: JSON.stringify({ message })
-    });
-    const data = await response.json();
-    if (!response.ok) {
-      throw new Error(data.error || "Chat request failed");
-    }
-    return data.response;
-  }
-  /**
-   * Stream chat within a session
-   * Returns an async iterator for SSE events
-   *
-   * @example
-   * ```typescript
-   * for await (const event of sdk.agent.streamChat(sessionId, 'Tell me a story')) {
-   *   if (event.type === 'agentThought') {
-   *     console.log('Thinking:', event.data.thought);
-   *   } else if (event.type === 'textResponse') {
-   *     console.log('Response:', event.data.textResponse);
-   *   }
-   * }
-   * ```
-   */
-  async *streamChat(sessionId, message) {
-    const response = await this.httpClient.fetch(`/sdk/agent/session/${sessionId}/chat/stream`, {
-      method: "POST",
-      body: JSON.stringify({ message })
-    });
-    if (!response.ok) {
-      const data = await response.json();
-      throw new Error(data.error || "Stream request failed");
-    }
-    if (!response.body) {
-      throw new Error("Response body is null");
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          if (line.startsWith("data: ")) {
-            const data = JSON.parse(line.slice(6));
-            yield {
-              type: data.type,
-              data
-            };
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  /**
-   * Get session information
-   *
-   * @example
-   * ```typescript
-   * const info = await sdk.agent.getSession(sessionId);
-   * console.log(`Messages sent: ${info.message_count}`);
-   * ```
-   */
-  async getSession(sessionId) {
-    const response = await this.httpClient.fetch(`/sdk/agent/session/${sessionId}`, {
-      method: "GET"
-    });
-    const data = await response.json();
-    if (!response.ok) {
-      throw new Error(data.error || "Failed to get session info");
-    }
-    return data.session;
-  }
-  /**
-   * Close and delete a session
-   * Sessions auto-expire after 1 hour, but you can close them manually
-   *
-   * @example
-   * ```typescript
-   * await sdk.agent.closeSession(sessionId);
-   * ```
-   */
-  async closeSession(sessionId) {
-    const response = await this.httpClient.fetch(`/sdk/agent/session/${sessionId}`, {
-      method: "DELETE"
-    });
-    const data = await response.json();
-    if (!response.ok) {
-      throw new Error(data.error || "Failed to close session");
-    }
-  }
-  /**
-   * Helper: Create session and send first message in one call
-   * This is the simplest way to start chatting with an agent
-   *
-   * @example
-   * ```typescript
-   * const { session, response } = await sdk.agent.startChat('Hello agent!');
-   * console.log(response.text);
-   *
-   * // Continue chatting in the same session
-   * const reply = await sdk.agent.chat(session.session_id, 'Tell me more');
-   * ```
-   */
-  async startChat(message, options) {
-    const session = await this.createSession(options);
-    const response = await this.chat(session.session_id, message);
-    return { session, response };
-  }
-};
-
-// src/modules/acpAgent.ts
-function encodeSessionKey(sessionKey) {
-  return encodeURIComponent(sessionKey);
-}
-async function parseJsonResponse(response, fallbackError) {
-  const data = await response.json();
-  if (!response.ok) throw new Error(data.error || fallbackError);
-  return data;
-}
-var AcpAgentModule = class {
-  constructor(httpClient) {
-    this.httpClient = httpClient;
-  }
-  /** List available CLI agents. Pass includeModels to get model lists per agent. */
-  async listAgents(opts) {
-    const qs = opts?.includeModels ? "?includeModels=true" : "";
-    const response = await this.httpClient.fetch(`/sdk/acp/agents${qs}`);
-    const data = await parseJsonResponse(
-      response,
-      "Failed to list agents"
-    );
-    return data.agents;
-  }
-  /** Create and initialize a new ACP session. Spawns the CLI agent process. */
-  async createSession(options) {
-    const response = await this.httpClient.fetch("/sdk/acp/session", {
-      method: "POST",
-      body: JSON.stringify(options)
-    });
-    const data = await parseJsonResponse(
-      response,
-      "Failed to create session"
-    );
-    return data.session;
-  }
-  /** Get session status and runtime options. */
-  async getSession(sessionKey) {
-    const response = await this.httpClient.fetch(
-      `/sdk/acp/session/${encodeSessionKey(sessionKey)}`
-    );
-    const data = await parseJsonResponse(
-      response,
-      "Failed to get session"
-    );
-    return data.session;
-  }
-  /** List active ACP sessions owned by this app. */
-  async listSessions() {
-    const response = await this.httpClient.fetch("/sdk/acp/sessions");
-    const data = await parseJsonResponse(
-      response,
-      "Failed to list sessions"
-    );
-    return data.sessions;
-  }
-  /** Update runtime options (applied on next turn). */
-  async patchSession(sessionKey, patch) {
-    const response = await this.httpClient.fetch(
-      `/sdk/acp/session/${encodeSessionKey(sessionKey)}`,
-      { method: "PATCH", body: JSON.stringify(patch) }
-    );
-    await parseJsonResponse(response, "Failed to update session");
-  }
-  /** Close session and stop the agent process. */
-  async closeSession(sessionKey, reason) {
-    const response = await this.httpClient.fetch(
-      `/sdk/acp/session/${encodeSessionKey(sessionKey)}`,
-      {
-        method: "DELETE",
-        body: reason ? JSON.stringify({ reason }) : void 0
-      }
-    );
-    await parseJsonResponse(response, "Failed to close session");
-  }
-  /**
-   * Synchronous turn — waits for completion, returns full response.
-   * Requires approvalPolicy set on the session (via create or patchSession).
-   */
-  async chat(sessionKey, message, attachments) {
-    const body = { message };
-    if (attachments?.length) body.attachments = attachments;
-    const response = await this.httpClient.fetch(
-      `/sdk/acp/session/${encodeSessionKey(sessionKey)}/chat`,
-      { method: "POST", body: JSON.stringify(body) }
-    );
-    const data = await parseJsonResponse(
-      response,
-      "Chat request failed"
-    );
-    return data.response;
-  }
-  /**
-   * Streaming turn via SSE. Yields events as they arrive.
-   *
-   * Uses named SSE events (event: + data: lines). The event type comes
-   * from the `event:` line, not from inside the JSON payload.
-   *
-   * @example
-   * ```typescript
-   * for await (const event of sdk.acpAgent.streamChat(key, 'Explain this')) {
-   *   if (event.type === 'text_delta') console.log(event.data.text);
-   *   if (event.type === 'permission_request') {
-   *     await sdk.acpAgent.resolvePermission(key, {
-   *       requestId: event.data.requestId as string,
-   *       optionId: 'allow_once',
-   *     });
-   *   }
-   * }
-   * ```
-   */
-  async *streamChat(sessionKey, message, attachments) {
-    const body = { message };
-    if (attachments?.length) body.attachments = attachments;
-    const response = await this.httpClient.fetch(
-      `/sdk/acp/session/${encodeSessionKey(sessionKey)}/chat/stream`,
-      { method: "POST", body: JSON.stringify(body) }
-    );
-    if (!response.ok) {
-      const data = await response.json();
-      throw new Error(data.error || "Stream request failed");
-    }
-    if (!response.body) {
-      throw new Error("Response body is null");
-    }
-    yield* parseNamedSSEStream(response.body);
-  }
-  /** Cancel the active turn on a session. */
-  async cancelTurn(sessionKey, reason) {
-    const response = await this.httpClient.fetch(
-      `/sdk/acp/session/${encodeSessionKey(sessionKey)}/cancel`,
-      {
-        method: "POST",
-        body: reason ? JSON.stringify({ reason }) : void 0
-      }
-    );
-    await parseJsonResponse(response, "Failed to cancel turn");
-  }
-  /** Resolve a pending permission request (call while SSE stream is active). */
-  async resolvePermission(sessionKey, decision) {
-    const response = await this.httpClient.fetch(
-      `/sdk/acp/session/${encodeSessionKey(sessionKey)}/permission`,
-      { method: "POST", body: JSON.stringify(decision) }
-    );
-    return parseJsonResponse(response, "Failed to resolve permission");
-  }
-  /** Convenience: create session + first sync chat in one call. */
-  async startChat(message, options) {
-    const session = await this.createSession(options);
-    const chatResponse = await this.chat(session.session_key, message);
-    return { session, response: chatResponse };
-  }
-};
-async function* parseNamedSSEStream(body) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let currentEvent = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (line.startsWith("event: ")) {
-          currentEvent = line.slice(7).trim();
-        } else if (line.startsWith("data: ")) {
-          const jsonStr = line.slice(6);
-          const eventType = currentEvent || void 0;
-          currentEvent = "";
-          if (!eventType) continue;
-          try {
-            const data = JSON.parse(jsonStr);
-            yield { type: eventType, data };
-          } catch {
-          }
-        } else if (line === "") {
-          currentEvent = "";
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-// src/modules/mcp.ts
-var MCPModule = class extends ApiModule {
-  constructor(realtimexUrl, appId, appName, apiKey) {
-    super(realtimexUrl, appId, appName, apiKey);
-  }
-  /**
-   * List configured MCP servers.
-   * @param provider - Filter by provider: 'local', 'remote', or 'all' (default: 'all')
-   * @returns Array of MCP server objects
-   */
-  async getServers(provider = "all") {
-    const params = provider !== "all" ? `?provider=${provider}` : "";
-    const data = await this.apiCall("GET", `/sdk/mcp/servers${params}`);
-    return data.servers;
-  }
-  /**
-   * List available tools for a specific MCP server.
-   * @param serverName - The server name (slug)
-   * @param provider - Provider: 'local' or 'remote' (default: 'local')
-   * @returns Array of tool objects with name, description, and input schema
-   */
-  async getTools(serverName, provider = "local") {
-    const data = await this.apiCall(
-      "GET",
-      `/sdk/mcp/servers/${encodeURIComponent(serverName)}/tools?provider=${provider}`
-    );
-    return data.tools;
-  }
-  /**
-   * Execute a tool on an MCP server.
-   * @param serverName - The server name (slug)
-   * @param toolName - The tool name to execute
-   * @param args - Arguments to pass to the tool (matches tool's input_schema)
-   * @param provider - Provider: 'local' or 'remote' (default: 'local')
-   * @returns Tool execution result
-   */
-  async executeTool(serverName, toolName, args = {}, provider = "local") {
-    const data = await this.apiCall(
-      "POST",
-      `/sdk/mcp/servers/${encodeURIComponent(serverName)}/tools/${encodeURIComponent(toolName)}/execute?provider=${provider}`,
-      {
-        body: JSON.stringify({ arguments: args })
-      }
-    );
-    return data.result;
-  }
-};
-
-// src/modules/http.ts
-var HttpClient = class {
-  constructor(baseUrl, appId, apiKey) {
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.appId = appId;
-    this.apiKey = apiKey;
-  }
-  getAppHeaders() {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.appId) headers["x-app-id"] = this.appId;
-    if (this.apiKey) headers["x-api-key"] = this.apiKey;
-    return headers;
-  }
-  async getAccessToken() {
-    if (this.accessToken) return this.accessToken;
-    try {
-      const res = await fetch(`${this.baseUrl}/sdk/auth/token`, {
-        headers: this.getAppHeaders()
-      });
-      const data = await res.json();
-      if (res.ok && data.token) {
-        this.accessToken = data.token;
-        return data.token;
-      }
-    } catch (e) {
-    }
-    return "";
-  }
-  async fetch(endpoint, options = {}) {
-    const url = `${this.baseUrl}${endpoint}`;
-    let token = await this.getAccessToken();
-    const makeRequest = (authToken) => {
-      const headers = {
-        ...this.getAppHeaders(),
-        ...options.headers || {}
-      };
-      if (authToken) {
-        headers["Authorization"] = `Bearer ${authToken}`;
-      }
-      return fetch(url, { ...options, headers });
-    };
-    let response = await makeRequest(token);
-    if (response.status === 401) {
-      console.log("[RealtimeX SDK] 401 Unauthorized, refreshing access token...");
-      this.accessToken = void 0;
-      const newToken = await this.getAccessToken();
-      if (newToken && newToken !== token) {
-        console.log("[RealtimeX SDK] Retrying request with new token");
-        response = await makeRequest(newToken);
-      }
-    }
-    return response;
-  }
-};
-
-// src/core/errors/ContractErrors.ts
-var ContractError = class extends Error {
-  constructor(code, message, details) {
-    super(message);
-    this.name = this.constructor.name;
-    this.code = code;
-    this.details = details;
-  }
-};
-var ContractValidationError = class extends ContractError {
-  constructor(message, details) {
-    super("contract_validation_error", message, details);
-  }
-};
-var ToolValidationError = class extends ContractError {
-  constructor(message, details) {
-    super("tool_validation_error", message, details);
-  }
-};
-var ToolNotFoundError = class extends ContractError {
-  constructor(toolName, details) {
-    super("tool_not_found", `Tool not found: ${toolName}`, details);
-  }
-};
-var ScopeDeniedError = class extends ContractError {
-  constructor(permission, details) {
-    super("scope_denied", `Missing required permission: ${permission}`, details);
-  }
-};
-var RuntimeTransportError = class extends ContractError {
-  constructor(message, statusCode, details) {
-    super("runtime_transport_error", message, details);
-    this.statusCode = statusCode;
-  }
-};
-
-// src/core/auth/ScopeGuard.ts
-var ScopeGuard = class {
-  constructor(scopes = []) {
-    this.scopes = new Set(scopes.filter((scope) => scope.trim().length > 0));
-  }
-  can(permission) {
-    if (!permission) return true;
-    if (this.scopes.size === 0) return true;
-    return this.scopes.has(permission);
-  }
-  assert(permission) {
-    if (!permission) return;
-    if (!this.can(permission)) {
-      throw new ScopeDeniedError(permission);
-    }
-  }
-};
-
-// src/core/contract/ContractCache.ts
-var ContractCache = class {
-  constructor(ttlMs = 3e4) {
-    this.entries = /* @__PURE__ */ new Map();
-    this.ttlMs = ttlMs > 0 ? ttlMs : null;
-  }
-  get(key) {
-    const entry = this.entries.get(key);
-    if (!entry) return null;
-    if (entry.expiresAt !== null && entry.expiresAt <= Date.now()) {
-      this.entries.delete(key);
-      return null;
-    }
-    return entry.value;
-  }
-  set(key, value) {
-    const expiresAt = this.ttlMs === null ? null : Date.now() + this.ttlMs;
-    this.entries.set(key, { value, expiresAt });
-  }
-  clear(key) {
-    if (key) {
-      this.entries.delete(key);
-      return;
-    }
-    this.entries.clear();
-  }
-};
-
-// src/core/contract/ContractValidator.ts
-var LOCAL_APP_CONTRACT_VERSION2 = "local-app-contract/v1";
-var DEFAULT_SUPPORTED_EVENTS = [
-  "task.trigger",
-  "system.ping",
-  "task.claimed",
-  "task.started",
-  "task.progress",
-  "task.completed",
-  "task.failed",
-  "task.canceled"
-];
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function asStringArray(value) {
-  if (!Array.isArray(value)) return [];
-  return value.filter((item) => typeof item === "string" && item.trim().length > 0);
-}
-function asStringRecord(value) {
-  if (!isRecord(value)) return void 0;
-  const entries = Object.entries(value).filter(
-    ([key, item]) => key.trim().length > 0 && typeof item === "string"
-  );
-  if (entries.length === 0) return void 0;
-  return entries.reduce((accumulator, [key, item]) => {
-    accumulator[key] = item;
-    return accumulator;
-  }, {});
-}
-function normalizeStrictness(value) {
-  return value === "strict" ? "strict" : "compatible";
-}
-function normalizeCallbackRules(value) {
-  if (!isRecord(value)) return void 0;
-  const callback = {};
-  if (typeof value.event_id_header === "string") callback.event_id_header = value.event_id_header;
-  if (typeof value.signature_header === "string") callback.signature_header = value.signature_header;
-  if (typeof value.signature_algorithm === "string") callback.signature_algorithm = value.signature_algorithm;
-  if (typeof value.signature_message === "string") callback.signature_message = value.signature_message;
-  if (typeof value.attempt_id_format === "string") callback.attempt_id_format = value.attempt_id_format;
-  if (typeof value.idempotency === "string") callback.idempotency = value.idempotency;
-  return Object.keys(callback).length > 0 ? callback : void 0;
-}
-function normalizeTrigger(value) {
-  if (!isRecord(value)) {
-    return { event: "task.trigger" };
-  }
-  const event = value.event === "task.trigger" ? "task.trigger" : "task.trigger";
-  const route = typeof value.route === "string" && value.route.trim().length > 0 ? value.route : void 0;
-  const payloadTemplate = isRecord(value.payload_template) ? value.payload_template : void 0;
-  return {
-    event,
-    route,
-    payload_template: payloadTemplate
-  };
-}
-function normalizeCapability(value) {
-  if (!isRecord(value)) {
-    throw new ContractValidationError("Invalid capability: expected object");
-  }
-  const capabilityId = typeof value.capability_id === "string" ? value.capability_id.trim() : "";
-  const name = typeof value.name === "string" ? value.name.trim() : "";
-  const description = typeof value.description === "string" ? value.description.trim() : "";
-  const permission = typeof value.permission === "string" ? value.permission.trim() : "";
-  if (!capabilityId || !name || !description || !permission) {
-    throw new ContractValidationError("Invalid capability: missing required fields", { capability: value });
-  }
-  if (!isRecord(value.input_schema)) {
-    throw new ContractValidationError("Invalid capability input_schema: expected JSON schema object", {
-      capability_id: capabilityId
-    });
-  }
-  return {
-    capability_id: capabilityId,
-    name,
-    description,
-    input_schema: value.input_schema,
-    output_schema: isRecord(value.output_schema) ? value.output_schema : void 0,
-    permission,
-    trigger: normalizeTrigger(value.trigger)
-  };
-}
-function normalizeCapabilities(value) {
-  if (value === void 0 || value === null) return void 0;
-  if (!Array.isArray(value)) {
-    throw new ContractValidationError("Invalid capabilities: expected array");
-  }
-  return value.map(normalizeCapability);
-}
-function extractContractRecord(payload) {
-  if (!isRecord(payload)) {
-    throw new ContractValidationError("Invalid contract response: expected object payload");
-  }
-  if (isRecord(payload.contract)) {
-    return payload.contract;
-  }
-  return payload;
-}
-function resolveContractVersion(contract) {
-  if (typeof contract.contract_version === "string") return contract.contract_version;
-  if (typeof contract.version === "string") return contract.version;
-  if (typeof contract.id === "string") return contract.id;
-  return "";
-}
-function normalizeLocalAppContractV1(payload) {
-  const contract = extractContractRecord(payload);
-  const version = resolveContractVersion(contract);
-  if (!version) {
-    throw new ContractValidationError("Missing contract version in discovery response");
-  }
-  if (version !== LOCAL_APP_CONTRACT_VERSION2) {
-    throw new ContractValidationError("Unsupported contract version", {
-      expected: LOCAL_APP_CONTRACT_VERSION2,
-      received: version
-    });
-  }
-  const supportedContractEvents = asStringArray(contract.supported_contract_events).length > 0 ? asStringArray(contract.supported_contract_events) : asStringArray(contract.supported_events).length > 0 ? asStringArray(contract.supported_events) : DEFAULT_SUPPORTED_EVENTS;
-  return {
-    contract_version: LOCAL_APP_CONTRACT_VERSION2,
-    strictness: normalizeStrictness(contract.strictness),
-    supported_contract_events: supportedContractEvents,
-    supported_legacy_events: asStringArray(contract.supported_legacy_events),
-    aliases: asStringRecord(contract.aliases),
-    status_map: asStringRecord(contract.status_map),
-    legacy_action_map: asStringRecord(contract.legacy_action_map),
-    callback: normalizeCallbackRules(contract.callback),
-    capabilities: normalizeCapabilities(contract.capabilities)
-  };
-}
-
-// src/core/contract/ContractClient.ts
-var ContractClient = class {
-  constructor(httpClient, options = {}) {
-    this.httpClient = httpClient;
-    this.cache = options.cache || new ContractCache();
-    this.cacheKey = options.cacheKey || "local-app-contract/v1";
-  }
-  async getLocalAppV1(forceRefresh = false) {
-    if (!forceRefresh) {
-      const cached = this.cache.get(this.cacheKey);
-      if (cached) return cached;
-    }
-    const response = await this.httpClient.get("/contracts/local-app/v1");
-    const normalized = normalizeLocalAppContractV1(response);
-    this.cache.set(this.cacheKey, normalized);
-    return normalized;
-  }
-  clearCache() {
-    this.cache.clear(this.cacheKey);
-  }
-};
-
-// src/core/transport/HttpClient.ts
-function toRecordHeaders(input = {}) {
-  if (input instanceof Headers) {
-    const normalized = {};
-    input.forEach((value, key) => {
-      normalized[key] = value;
-    });
-    return normalized;
-  }
-  if (Array.isArray(input)) {
-    return Object.fromEntries(input);
-  }
-  return { ...input };
-}
-var ContractHttpClient = class {
-  constructor(config) {
-    this.baseUrl = config.baseUrl.replace(/\/$/, "");
-    this.appId = config.appId;
-    this.appName = config.appName;
-    this.apiKey = config.apiKey;
-    this.fetchImpl = config.fetchImpl || fetch;
-  }
-  async get(path, headers = {}) {
-    return this.request(path, {
-      method: "GET",
-      headers
-    });
-  }
-  async post(path, body, headers = {}) {
-    return this.request(path, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body)
-    });
-  }
-  async request(path, options = {}) {
-    const url = `${this.baseUrl}${path}`;
-    const headers = this.buildHeaders(options.headers);
-    let response;
-    try {
-      response = await this.fetchImpl(url, {
-        ...options,
-        headers
-      });
-    } catch (error) {
-      throw new RuntimeTransportError("Failed to reach RealtimeX server", void 0, {
-        cause: error,
-        url
-      });
-    }
-    const payload = await this.parseResponse(response);
-    if (!response.ok) {
-      const errorMessage = payload && typeof payload === "object" && "error" in payload && typeof payload.error === "string" ? payload.error : `Request failed with status ${response.status}`;
-      throw new RuntimeTransportError(errorMessage, response.status, payload);
-    }
-    return payload;
-  }
-  buildHeaders(extraHeaders = {}) {
-    const headers = {
-      "Content-Type": "application/json",
-      ...toRecordHeaders(extraHeaders)
-    };
-    if (this.apiKey) {
-      headers.Authorization = `Bearer ${this.apiKey}`;
-    }
-    if (this.appId) {
-      headers["x-app-id"] = this.appId;
-    }
-    if (this.appName) {
-      headers["x-app-name"] = this.appName;
-    }
-    return headers;
-  }
-  async parseResponse(response) {
-    const contentType = response.headers.get("content-type") || "";
-    if (contentType.includes("application/json")) {
-      try {
-        return await response.json();
-      } catch {
-        return {};
-      }
-    }
-    const text = await response.text();
-    if (!text) return {};
-    try {
-      return JSON.parse(text);
-    } catch {
-      return { text };
-    }
-  }
-};
-
-// src/core/tooling/SchemaNormalizer.ts
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function deepClone(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-function normalizeSchema(schema) {
-  if (!schema || !isRecord2(schema)) {
-    return {
-      type: "object",
-      properties: {},
-      additionalProperties: true
-    };
-  }
-  const normalized = deepClone(schema);
-  if (typeof normalized.type !== "string" && !Array.isArray(normalized.type)) {
-    normalized.type = "object";
-  }
-  if (normalized.type === "object" && !isRecord2(normalized.properties)) {
-    normalized.properties = {};
-  }
-  if (Array.isArray(normalized.required)) {
-    normalized.required = normalized.required.filter(
-      (field) => typeof field === "string" && field.trim().length > 0
-    );
-  }
-  return normalized;
-}
-
-// src/core/tooling/ToolNamePolicy.ts
-function normalizeToken(value) {
-  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-}
-function toStableToolName(capabilityId, namespace) {
-  const normalizedCapability = normalizeToken(capabilityId.replace(/\./g, "_"));
-  const normalizedNamespace = namespace ? normalizeToken(namespace) : "";
-  if (!normalizedCapability) {
-    return normalizedNamespace ? `${normalizedNamespace}_tool` : "tool";
-  }
-  const combined = normalizedNamespace && !normalizedCapability.startsWith(`${normalizedNamespace}_`) ? `${normalizedNamespace}_${normalizedCapability}` : normalizedCapability;
-  return /^[a-z]/.test(combined) ? combined : `tool_${combined}`;
-}
-
-// src/core/tooling/ToolProjector.ts
-var ToolProjector = class {
-  project(input) {
-    const capabilities = input.contract.capabilities || [];
-    const names = /* @__PURE__ */ new Set();
-    return capabilities.map((capability) => {
-      const baseName = toStableToolName(capability.capability_id, input.namespace || input.appId);
-      const uniqueName = this.ensureUniqueToolName(baseName, names);
-      return {
-        tool_name: uniqueName,
-        title: capability.name,
-        description: capability.description,
-        input_schema: normalizeSchema(capability.input_schema),
-        output_schema: capability.output_schema,
-        permission: capability.permission,
-        capability_id: capability.capability_id,
-        trigger: capability.trigger
-      };
-    });
-  }
-  ensureUniqueToolName(baseName, names) {
-    if (!names.has(baseName)) {
-      names.add(baseName);
-      return baseName;
-    }
-    let index = 2;
-    while (names.has(`${baseName}_${index}`)) {
-      index += 1;
-    }
-    const uniqueName = `${baseName}_${index}`;
-    names.add(uniqueName);
-    return uniqueName;
-  }
-};
-
-// src/core/runtime/ExecutionStore.ts
-var ExecutionStore = class {
-  constructor() {
-    this.registries = /* @__PURE__ */ new Map();
-  }
-  registerTools(registryKey, tools) {
-    const registry = /* @__PURE__ */ new Map();
-    for (const tool of tools) {
-      registry.set(tool.tool_name, tool);
-    }
-    this.registries.set(registryKey, registry);
-  }
-  hasRegistry(registryKey) {
-    return this.registries.has(registryKey);
-  }
-  getTool(registryKey, toolName) {
-    return this.registries.get(registryKey)?.get(toolName);
-  }
-  clear(registryKey) {
-    if (registryKey) {
-      this.registries.delete(registryKey);
-      return;
-    }
-    this.registries.clear();
-  }
-};
-
-// src/core/runtime/LifecycleReporter.ts
-var LifecycleReporter = class {
-  constructor() {
-    this.handlers = /* @__PURE__ */ new Set();
-  }
-  onEvent(handler) {
-    this.handlers.add(handler);
-    return () => {
-      this.handlers.delete(handler);
-    };
-  }
-  emit(event) {
-    for (const handler of this.handlers) {
-      try {
-        handler(event);
-      } catch {
-      }
-    }
-  }
-};
-
-// src/core/runtime/RetryPolicy.ts
-function defaultShouldRetry(error) {
-  if (error && typeof error === "object") {
-    const status = error.statusCode;
-    if (typeof status === "number") {
-      return status >= 500 || status === 429;
-    }
-  }
-  return true;
-}
-var RetryPolicy = class {
-  constructor(options = {}) {
-    this.maxAttempts = Math.max(1, options.maxAttempts ?? 3);
-    this.baseDelayMs = Math.max(0, options.baseDelayMs ?? 150);
-    this.maxDelayMs = Math.max(this.baseDelayMs, options.maxDelayMs ?? 2e3);
-    this.shouldRetry = options.shouldRetry || ((error) => defaultShouldRetry(error));
-  }
-  async execute(operation) {
-    let lastError = null;
-    for (let attempt = 1; attempt <= this.maxAttempts; attempt += 1) {
-      try {
-        return await operation(attempt);
-      } catch (error) {
-        lastError = error;
-        const canRetry = attempt < this.maxAttempts && this.shouldRetry(error, attempt);
-        if (!canRetry) throw error;
-        const delayMs = Math.min(this.maxDelayMs, this.baseDelayMs * 2 ** (attempt - 1));
-        if (delayMs > 0) {
-          await new Promise((resolve) => setTimeout(resolve, delayMs));
-        }
-      }
-    }
-    throw lastError instanceof Error ? lastError : new Error("Retry operation failed");
-  }
-};
-
-// src/core/runtime/ContractRuntime.ts
-var LIFECYCLE_EVENTS = /* @__PURE__ */ new Set([
-  "task.claimed",
-  "task.started",
-  "task.progress",
-  "task.completed",
-  "task.failed",
-  "task.canceled"
-]);
-var DEFAULT_PROVIDER = "gemini";
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function toRecord(value) {
-  return isRecord3(value) ? value : {};
-}
-function resolveToolCallId(input) {
-  if (typeof input.tool_call_id === "string" && input.tool_call_id.trim().length > 0) {
-    return input.tool_call_id;
-  }
-  const payload = isRecord3(input.payload) ? input.payload : void 0;
-  if (payload && typeof payload.tool_call_id === "string" && payload.tool_call_id.trim().length > 0) {
-    return payload.tool_call_id;
-  }
-  const data = isRecord3(input.data) ? input.data : void 0;
-  if (data && typeof data.tool_call_id === "string" && data.tool_call_id.trim().length > 0) {
-    return data.tool_call_id;
-  }
-  return void 0;
-}
-var ContractRuntime = class {
-  constructor(options) {
-    if (!options.baseUrl) {
-      throw new ContractValidationError("ContractRuntime requires baseUrl");
-    }
-    this.appId = options.appId;
-    this.appName = options.appName;
-    this.defaultNamespace = options.namespace;
-    this.httpClient = new ContractHttpClient({
-      baseUrl: options.baseUrl,
-      appId: options.appId,
-      appName: options.appName,
-      apiKey: options.apiKey,
-      fetchImpl: options.fetchImpl
-    });
-    this.contractClient = new ContractClient(this.httpClient, {
-      cache: new ContractCache(options.cacheTtlMs ?? 3e4)
-    });
-    this.toolProjector = new ToolProjector();
-    this.executionStore = new ExecutionStore();
-    this.lifecycleReporter = new LifecycleReporter();
-    this.scopeGuard = new ScopeGuard(options.permissions || []);
-    this.retryPolicy = new RetryPolicy(options.retry);
-  }
-  async getContract(appId) {
-    this.assertAppContext(appId);
-    return this.contractClient.getLocalAppV1(false);
-  }
-  async getTools(input) {
-    this.assertAppContext(input.appId);
-    const contract = await this.contractClient.getLocalAppV1(false);
-    const tools = this.toolProjector.project({
-      contract,
-      provider: input.provider,
-      appId: input.appId,
-      namespace: input.namespace || this.defaultNamespace || input.appId
-    });
-    this.executionStore.registerTools(
-      this.buildRegistryKey(input.appId, input.provider, input.namespace),
-      tools
-    );
-    return tools;
-  }
-  async executeToolCall(call, context) {
-    try {
-      this.assertAppContext(context.appId);
-      const provider = context.provider || DEFAULT_PROVIDER;
-      const namespace = context.namespace || this.defaultNamespace || context.appId;
-      const registryKey = this.buildRegistryKey(context.appId, provider, namespace);
-      if (!this.executionStore.hasRegistry(registryKey)) {
-        await this.getTools({
-          appId: context.appId,
-          provider,
-          namespace
-        });
-      }
-      const tool = this.executionStore.getTool(registryKey, call.tool_name);
-      if (!tool) {
-        throw new ToolNotFoundError(call.tool_name, {
-          registryKey
-        });
-      }
-      this.scopeGuard.assert(tool.permission);
-      const validationErrors = this.validateToolArgs(tool, call.args);
-      if (validationErrors.length > 0) {
-        throw new ToolValidationError("Tool input validation failed", {
-          tool_name: call.tool_name,
-          errors: validationErrors
-        });
-      }
-      const eventId = context.idempotencyKey || call.tool_call_id;
-      const requestBody = this.buildTriggerRequestBody(call, context, tool, eventId);
-      const response = await this.retryPolicy.execute(
-        () => this.httpClient.post(tool.trigger.route || "/webhooks/realtimex", requestBody)
-      );
-      if (response.success === false) {
-        throw new RuntimeTransportError(response.error || "Failed to trigger task", void 0, response);
-      }
-      const taskId = this.resolveTaskId(response);
-      const attemptId = normalizeAttemptId(response.attempt_id);
-      this.tryEmitLifecycleEvent({
-        tool_call_id: call.tool_call_id,
-        task_id: taskId,
-        attempt_id: attemptId,
-        event_type: response.event_type,
-        event_id: response.event_id,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        payload: toRecord(response)
-      });
-      if (taskId) {
-        return {
-          status: "queued",
-          tool_call_id: call.tool_call_id,
-          task_id: taskId,
-          attempt_id: attemptId,
-          output: {
-            message: response.message || "Task accepted"
-          }
-        };
-      }
-      return {
-        status: "completed",
-        tool_call_id: call.tool_call_id,
-        output: toRecord(response)
-      };
-    } catch (error) {
-      return this.toFailedResult(call.tool_call_id, error);
-    }
-  }
-  onExecutionEvent(handler) {
-    return this.lifecycleReporter.onEvent(handler);
-  }
-  ingestExecutionEvent(input) {
-    const eventTypeRaw = typeof input.event_type === "string" && input.event_type || typeof input.event === "string" && input.event || "";
-    const normalized = normalizeContractEvent(eventTypeRaw);
-    if (!normalized || !LIFECYCLE_EVENTS.has(normalized)) {
-      return null;
-    }
-    const taskId = typeof input.task_id === "string" && input.task_id || typeof input.task_uuid === "string" && input.task_uuid || "";
-    if (!taskId) return null;
-    const event = {
-      tool_call_id: resolveToolCallId(input) || taskId,
-      task_id: taskId,
-      attempt_id: normalizeAttemptId(input.attempt_id),
-      event_type: normalized,
-      event_id: typeof input.event_id === "string" && input.event_id || `${taskId}:${normalized}:${Date.now()}`,
-      timestamp: typeof input.timestamp === "string" && input.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-      payload: toRecord(input.payload || input.data)
-    };
-    this.lifecycleReporter.emit(event);
-    return event;
-  }
-  clearCache() {
-    this.contractClient.clearCache();
-    this.executionStore.clear();
-  }
-  assertAppContext(appId) {
-    if (!appId || appId.trim().length === 0) {
-      throw new ContractValidationError("appId is required");
-    }
-    if (this.appId && this.appId !== appId) {
-      throw new ContractValidationError("Runtime appId mismatch", {
-        runtime_app_id: this.appId,
-        requested_app_id: appId
-      });
-    }
-  }
-  buildRegistryKey(appId, provider, namespace) {
-    const resolvedNamespace = namespace || this.defaultNamespace || appId;
-    return `${appId}:${provider}:${resolvedNamespace}`;
-  }
-  resolveTaskId(response) {
-    if (typeof response.task_uuid === "string" && response.task_uuid.trim().length > 0) {
-      return response.task_uuid;
-    }
-    if (typeof response.task_id === "string" && response.task_id.trim().length > 0) {
-      return response.task_id;
-    }
-    return void 0;
-  }
-  buildTriggerRequestBody(call, context, tool, eventId) {
-    const payloadTemplate = isRecord3(tool.trigger.payload_template) ? tool.trigger.payload_template : {};
-    const templateRawData = isRecord3(payloadTemplate.raw_data) ? payloadTemplate.raw_data : {};
-    const payload = {
-      ...payloadTemplate,
-      raw_data: {
-        ...templateRawData,
-        capability_id: tool.capability_id,
-        tool_name: call.tool_name,
-        tool_call_id: call.tool_call_id,
-        args: call.args,
-        context: {
-          app_id: context.appId,
-          user_id: context.userId,
-          workspace_id: context.workspaceId || null,
-          request_id: context.requestId || null,
-          metadata: context.metadata || null
-        }
-      }
-    };
-    if (typeof payload.auto_run !== "boolean") {
-      payload.auto_run = false;
-    }
-    return {
-      app_name: this.appName,
-      // In API-key dev mode, app_id should be omitted unless explicitly configured
-      // on the runtime. Passing an unknown app_id causes webhook trigger rejection.
-      app_id: this.appId || void 0,
-      event: tool.trigger.event,
-      event_id: eventId,
-      payload
-    };
-  }
-  validateToolArgs(tool, args) {
-    const errors = [];
-    if (!isRecord3(args)) {
-      errors.push("args must be an object");
-      return errors;
-    }
-    const requiredFields = Array.isArray(tool.input_schema.required) ? tool.input_schema.required.filter((field) => typeof field === "string") : [];
-    for (const field of requiredFields) {
-      const value = args[field];
-      if (value === void 0 || value === null || typeof value === "string" && value.trim().length === 0) {
-        errors.push(`Missing required field: ${field}`);
-      }
-    }
-    const properties = isRecord3(tool.input_schema.properties) ? tool.input_schema.properties : {};
-    for (const [field, schemaValue] of Object.entries(properties)) {
-      if (!(field in args)) continue;
-      if (!isRecord3(schemaValue)) continue;
-      const typeValue = schemaValue.type;
-      if (typeof typeValue === "string") {
-        if (!this.matchesType(args[field], typeValue)) {
-          errors.push(`Invalid type for ${field}: expected ${typeValue}`);
-        }
-      }
-      if (Array.isArray(typeValue)) {
-        const valid = typeValue.some(
-          (item) => typeof item === "string" && this.matchesType(args[field], item)
-        );
-        if (!valid) {
-          errors.push(
-            `Invalid type for ${field}: expected one of ${typeValue.filter((item) => typeof item === "string").join(", ")}`
-          );
-        }
-      }
-    }
-    return errors;
-  }
-  matchesType(value, expectedType) {
-    switch (expectedType) {
-      case "string":
-        return typeof value === "string";
-      case "number":
-        return typeof value === "number" && Number.isFinite(value);
-      case "integer":
-        return typeof value === "number" && Number.isInteger(value);
-      case "boolean":
-        return typeof value === "boolean";
-      case "object":
-        return isRecord3(value);
-      case "array":
-        return Array.isArray(value);
-      case "null":
-        return value === null;
-      default:
-        return true;
-    }
-  }
-  tryEmitLifecycleEvent(input) {
-    if (!input.task_id || !input.event_type) return;
-    const normalized = normalizeContractEvent(input.event_type);
-    if (!normalized || !LIFECYCLE_EVENTS.has(normalized)) {
-      return;
-    }
-    this.lifecycleReporter.emit({
-      tool_call_id: input.tool_call_id,
-      task_id: input.task_id,
-      attempt_id: normalizeAttemptId(input.attempt_id),
-      event_type: normalized,
-      event_id: input.event_id || `${input.task_id}:${normalized}:${Date.now()}`,
-      timestamp: input.timestamp,
-      payload: input.payload
-    });
-  }
-  toFailedResult(toolCallId, error) {
-    if (error instanceof ContractError) {
-      const retryable = error instanceof RuntimeTransportError ? error.statusCode === void 0 || error.statusCode >= 500 || error.statusCode === 429 : false;
-      return {
-        status: "failed",
-        tool_call_id: toolCallId,
-        error: {
-          code: error.code,
-          message: error.message,
-          retryable
-        }
-      };
-    }
-    if (error instanceof Error) {
-      return {
-        status: "failed",
-        tool_call_id: toolCallId,
-        error: {
-          code: "runtime_error",
-          message: error.message,
-          retryable: true
-        }
-      };
-    }
-    return {
-      status: "failed",
-      tool_call_id: toolCallId,
-      error: {
-        code: "runtime_error",
-        message: "Unknown runtime error",
-        retryable: true
-      }
-    };
-  }
-};
-
-// src/modules/database.ts
-var DatabaseModule = class {
-  constructor(realtimexUrl, appId, apiKey) {
-    this.baseUrl = realtimexUrl.replace(/\/$/, "");
-    this.appId = appId;
-    this.apiKey = apiKey;
-  }
-  getHeaders() {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.apiKey) {
-      headers["Authorization"] = `Bearer ${this.apiKey}`;
-    }
-    if (this.appId) {
-      headers["x-app-id"] = this.appId;
-    }
-    return headers;
-  }
-  /**
-   * Get the Supabase database configuration for this app.
-   * Returns URL, anonKey, mode, and tables.
-   *
-   * @example
-   * ```ts
-   * const config = await sdk.database.getConfig();
-   * const supabase = createClient(config.url, config.anonKey);
-   * ```
-   */
-  async getConfig() {
-    const response = await fetch(`${this.baseUrl}/sdk/database/config`, {
-      method: "GET",
-      headers: this.getHeaders()
-    });
-    const data = await response.json();
-    if (!response.ok) {
-      throw new Error(data.error || "Failed to get database config");
-    }
-    return data.config;
-  }
-};
-
-// src/modules/auth.ts
-var AuthModule = class {
-  constructor(realtimexUrl, appId, apiKey) {
-    this.baseUrl = realtimexUrl.replace(/\/$/, "");
-    this.appId = appId;
-    this.apiKey = apiKey;
-  }
-  getHeaders() {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.apiKey) {
-      headers["Authorization"] = `Bearer ${this.apiKey}`;
-    }
-    if (this.appId) {
-      headers["x-app-id"] = this.appId;
-    }
-    return headers;
-  }
-  /**
-   * Push a Supabase access token to the Main App.
-   * This enables Main App to use the token for:
-   * - Realtime subscriptions (bypass RLS)
-   * - CRUD operations on rtx_activities (bypass RLS)
-   *
-   * @param token - Supabase JWT from supabase.auth.signIn()
-   *
-   * @example
-   * ```ts
-   * const { data } = await supabase.auth.signInWithPassword({ email, password });
-   * await sdk.auth.syncSupabaseToken(data.session.access_token);
-   * ```
-   */
-  async syncSupabaseToken(token) {
-    if (!token || typeof token !== "string") {
-      throw new Error("Token must be a non-empty string");
-    }
-    const response = await fetch(`${this.baseUrl}/sdk/auth/sync-supabase-token`, {
-      method: "POST",
-      headers: this.getHeaders(),
-      body: JSON.stringify({ token })
-    });
-    const data = await response.json();
-    if (!response.ok) {
-      throw new Error(data.error || "Failed to sync Supabase token");
-    }
-    return data;
-  }
-  /**
-   * Retrieve the current Keycloak access token from Main App.
-   * This is the existing Token Vending Machine endpoint.
-   *
-   * @returns The access token info, or null if no token is available.
-   */
-  async getAccessToken() {
-    const response = await fetch(`${this.baseUrl}/sdk/auth/token`, {
-      method: "GET",
-      headers: this.getHeaders()
-    });
-    const data = await response.json();
-    if (response.status === 404) {
-      return null;
-    }
-    if (!response.ok) {
-      throw new Error(data.error || "Failed to get access token");
-    }
-    return data;
-  }
-};
-
-// src/modules/credentials.ts
-var CredentialsModule = class {
-  constructor(httpClient) {
-    this.httpClient = httpClient;
-  }
-  /** List available credentials (names and types, no values). */
-  async list() {
-    const response = await this.httpClient.fetch("/sdk/credentials");
-    const data = await response.json();
-    if (!response.ok) {
-      throw new Error(data?.error || "Failed to list credentials");
-    }
-    return data.credentials || [];
-  }
-  /** Get a credential's decrypted payload by name. */
-  async get(name) {
-    const response = await this.httpClient.fetch(
-      `/sdk/credentials/${encodeURIComponent(name)}`
-    );
-    const data = await response.json();
-    if (!response.ok) {
-      throw new Error(data?.error || `Failed to get credential: ${name}`);
-    }
-    return data.credential;
-  }
-};
-
-// src/core/auth/AuthProvider.ts
-var StaticAuthProvider = class {
-  constructor(options = {}) {
-    this.appId = options.appId;
-    this.appName = options.appName;
-    this.apiKey = options.apiKey;
-  }
-  buildHeaders(baseHeaders = {}) {
-    const headers = { ...baseHeaders };
-    if (this.apiKey) {
-      headers.Authorization = `Bearer ${this.apiKey}`;
-    }
-    if (this.appId) {
-      headers["x-app-id"] = this.appId;
-    }
-    if (this.appName) {
-      headers["x-app-name"] = this.appName;
-    }
-    return headers;
-  }
-};
-
-// src/adapters/gemini/GeminiToolAdapter.ts
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function parseArgs(value) {
-  if (isRecord4(value)) return value;
-  if (typeof value === "string") {
-    try {
-      const parsed = JSON.parse(value);
-      return isRecord4(parsed) ? parsed : {};
-    } catch {
-      return {};
-    }
-  }
-  return {};
-}
-var GeminiToolAdapter = class {
-  toProviderTools(tools) {
-    return tools.map((tool) => ({
-      name: tool.tool_name,
-      description: tool.description,
-      parameters: tool.input_schema
-    }));
-  }
-  fromProviderToolCall(call) {
-    return {
-      tool_call_id: call.id,
-      tool_name: call.name,
-      args: parseArgs(call.args)
-    };
-  }
-  toProviderResult(result) {
-    return {
-      tool_call_id: result.tool_call_id || result.task_id || "unknown",
-      status: result.status,
-      payload: result.status === "failed" ? { error: result.error } : {
-        ...result.output || {},
-        task_id: result.task_id,
-        attempt_id: result.attempt_id
-      }
-    };
-  }
-};
-
-// src/adapters/claude/ClaudeToolAdapter.ts
-var ClaudeToolAdapter = class {
-  toProviderTools(tools) {
-    return tools.map((tool) => ({
-      name: tool.tool_name,
-      description: tool.description,
-      input_schema: tool.input_schema
-    }));
-  }
-  fromProviderToolCall(call) {
-    return {
-      tool_call_id: call.id,
-      tool_name: call.name,
-      args: call.input || {}
-    };
-  }
-  toProviderResult(result) {
-    const contentPayload = result.status === "failed" ? { error: result.error } : {
-      ...result.output || {},
-      task_id: result.task_id,
-      attempt_id: result.attempt_id
-    };
-    return {
-      type: "tool_result",
-      tool_use_id: result.tool_call_id || result.task_id || "unknown",
-      content: JSON.stringify(contentPayload),
-      is_error: result.status === "failed" ? true : void 0
-    };
-  }
-};
-
-// src/adapters/codex/CodexToolAdapter.ts
-function isRecord5(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function parseArguments(value) {
-  if (isRecord5(value)) return value;
-  if (typeof value === "string") {
-    try {
-      const parsed = JSON.parse(value);
-      return isRecord5(parsed) ? parsed : {};
-    } catch {
-      return {};
-    }
-  }
-  return {};
-}
-var CodexToolAdapter = class {
-  toProviderTools(tools) {
-    return tools.map((tool) => ({
-      type: "function",
-      function: {
-        name: tool.tool_name,
-        description: tool.description,
-        parameters: tool.input_schema
-      }
-    }));
-  }
-  fromProviderToolCall(call) {
-    return {
-      tool_call_id: call.id,
-      tool_name: call.function.name,
-      args: parseArguments(call.function.arguments)
-    };
-  }
-  toProviderResult(result) {
-    const outputPayload = result.status === "failed" ? { error: result.error } : {
-      ...result.output || {},
-      task_id: result.task_id,
-      attempt_id: result.attempt_id
-    };
-    return {
-      tool_call_id: result.tool_call_id || result.task_id || "unknown",
-      output: JSON.stringify(outputPayload),
-      is_error: result.status === "failed" ? true : void 0
-    };
-  }
-};
-
-// src/acp/ACPEventMapper.ts
-function getErrorMessage(error) {
-  if (error instanceof Error) return error.message;
-  if (typeof error === "string") return error;
-  return "Unknown error";
-}
-function buildRealtimeXMeta(input) {
-  return {
-    realtimex: {
-      tool_call_id: input.reference.toolCallId,
-      task_id: input.taskId,
-      attempt_id: input.attemptId,
-      event_id: input.eventId,
-      contract_version: "local-app-contract/v1",
-      contract_event: input.contractEvent,
-      cancelled: input.cancelled === true ? true : void 0,
-      app_id: input.reference.appId,
-      user_id: input.reference.userId,
-      workspace_id: input.reference.workspaceId,
-      provider: input.reference.provider,
-      namespace: input.reference.namespace
-    }
-  };
-}
-var ACPEventMapper = class {
-  createReference(invocation, context) {
-    return {
-      sessionId: context.sessionId,
-      toolCallId: invocation.toolCallId,
-      appId: context.appId,
-      userId: context.userId,
-      workspaceId: context.workspaceId,
-      provider: context.provider,
-      namespace: context.namespace,
-      title: invocation.title || invocation.toolName,
-      kind: invocation.kind || "execute"
-    };
-  }
-  buildPendingUpdate(invocation, reference) {
-    return {
-      sessionId: reference.sessionId,
-      update: {
-        type: "tool_call",
-        toolCallId: invocation.toolCallId,
-        title: reference.title,
-        kind: reference.kind,
-        status: "pending",
-        rawInput: invocation.args,
-        _meta: buildRealtimeXMeta({
-          reference,
-          contractEvent: "task.trigger"
-        })
-      }
-    };
-  }
-  buildResultUpdate(result, reference) {
-    const status = this.mapExecutionResultStatus(result);
-    const taskId = result.task_id;
-    const attemptId = result.attempt_id;
-    const contractEvent = status === "completed" ? "task.completed" : status === "failed" ? "task.failed" : "task.started";
-    const rawOutput = status === "failed" ? {
-      error: result.error || {
-        code: "runtime_error",
-        message: "Unknown runtime error",
-        retryable: true
-      }
-    } : {
-      ...result.output || {},
-      task_id: taskId,
-      attempt_id: attemptId
-    };
-    return {
-      sessionId: reference.sessionId,
-      update: {
-        type: "tool_call_update",
-        toolCallId: reference.toolCallId,
-        status,
-        content: [
-          {
-            type: "text",
-            text: status === "in_progress" ? "Task queued" : status === "completed" ? "Task completed" : "Task failed"
-          }
-        ],
-        rawOutput,
-        _meta: buildRealtimeXMeta({
-          reference,
-          taskId,
-          attemptId,
-          contractEvent
-        })
-      }
-    };
-  }
-  buildLifecycleUpdate(event, reference) {
-    const status = this.mapContractEventStatus(event.event_type);
-    if (!status) return null;
-    const payload = event.payload || {};
-    const progressText = this.resolveEventText(event.event_type, payload);
-    const cancelled = event.event_type === "task.canceled";
-    return {
-      sessionId: reference.sessionId,
-      update: {
-        type: "tool_call_update",
-        toolCallId: reference.toolCallId,
-        status,
-        content: progressText ? [
-          {
-            type: "text",
-            text: progressText
-          }
-        ] : void 0,
-        rawOutput: payload,
-        _meta: buildRealtimeXMeta({
-          reference,
-          taskId: event.task_id,
-          attemptId: event.attempt_id,
-          eventId: event.event_id,
-          contractEvent: event.event_type,
-          cancelled
-        })
-      }
-    };
-  }
-  buildNotifyFailureUpdate(reference, error) {
-    return {
-      sessionId: reference.sessionId,
-      update: {
-        type: "tool_call_update",
-        toolCallId: reference.toolCallId,
-        status: "failed",
-        content: [
-          {
-            type: "text",
-            text: `Adapter notify failed: ${getErrorMessage(error)}`
-          }
-        ],
-        rawOutput: {
-          error: {
-            code: "acp_notify_failed",
-            message: getErrorMessage(error)
-          }
-        },
-        _meta: buildRealtimeXMeta({
-          reference,
-          contractEvent: "adapter.notify_failed"
-        })
-      }
-    };
-  }
-  mapContractEventStatus(eventType) {
-    switch (eventType) {
-      case "task.claimed":
-      case "task.started":
-      case "task.progress":
-        return "in_progress";
-      case "task.completed":
-        return "completed";
-      case "task.failed":
-      case "task.canceled":
-        return "failed";
-      default:
-        return null;
-    }
-  }
-  mapExecutionResultStatus(result) {
-    switch (result.status) {
-      case "completed":
-        return "completed";
-      case "failed":
-        return "failed";
-      case "queued":
-        return "in_progress";
-      default:
-        return "failed";
-    }
-  }
-  resolveEventText(eventType, payload) {
-    const payloadMessage = typeof payload.message === "string" ? payload.message : typeof payload.error === "string" ? payload.error : void 0;
-    if (payloadMessage) return payloadMessage;
-    switch (eventType) {
-      case "task.claimed":
-        return "Task claimed";
-      case "task.started":
-        return "Task started";
-      case "task.progress":
-        return "Task in progress";
-      case "task.completed":
-        return "Task completed";
-      case "task.failed":
-        return "Task failed";
-      case "task.canceled":
-        return "Task canceled";
-      default:
-        return void 0;
-    }
-  }
-};
-
-// src/acp/ACPPermissionBridge.ts
-function isRecord6(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizePermissionOptions(invocation, buildPermissionOptions) {
-  const built = buildPermissionOptions ? buildPermissionOptions(invocation) : void 0;
-  if (built && built.length > 0) return built;
-  return [
-    {
-      id: "allow_once",
-      label: "Allow once",
-      kind: "allow_once"
-    },
-    {
-      id: "deny_once",
-      label: "Deny",
-      kind: "deny_once"
-    }
-  ];
-}
-function parseDecision(response) {
-  if (typeof response === "boolean") return response;
-  if (!isRecord6(response)) return false;
-  if (typeof response.allow === "boolean") return response.allow;
-  const decision = typeof response.decision === "string" && response.decision || typeof response.outcome === "string" && response.outcome || typeof response.selected === "string" && response.selected || "";
-  const normalized = decision.trim().toLowerCase();
-  if (!normalized) return false;
-  return normalized === "allow" || normalized === "allow_once" || normalized === "allow_always" || normalized === "approved" || normalized === "granted";
-}
-var ACPPermissionBridge = class {
-  constructor(options) {
-    this.notifier = options.notifier;
-    this.enabled = options.enabled;
-    this.buildPermissionOptions = options.buildPermissionOptions;
-  }
-  async requestToolPermission(invocation, context) {
-    if (!this.enabled) return true;
-    if (!this.notifier.request) {
-      return false;
-    }
-    const options = normalizePermissionOptions(invocation, this.buildPermissionOptions);
-    try {
-      const response = await this.notifier.request("session/request_permission", {
-        sessionId: context.sessionId,
-        title: invocation.title || invocation.toolName,
-        description: `Allow tool ${invocation.toolName} to run?`,
-        options,
-        metadata: {
-          tool_call_id: invocation.toolCallId,
-          tool_name: invocation.toolName,
-          app_id: context.appId
-        }
-      });
-      return parseDecision(response);
-    } catch {
-      return false;
-    }
-  }
-};
-
-// src/acp/ACPTelemetry.ts
-var ACPTelemetry = class {
-  constructor(sink) {
-    this.sink = sink;
-  }
-  emit(event) {
-    if (!this.sink) return;
-    try {
-      const output = this.sink.emit(event);
-      if (output && typeof output.then === "function") {
-        void output.catch(() => {
-        });
-      }
-    } catch {
-    }
-  }
-};
-
-// src/acp/ACPContractAdapter.ts
-function isRecord7(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function getString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
-}
-function resolveTaskId(payload) {
-  return getString(payload.task_id) || getString(payload.task_uuid);
-}
-function resolveToolCallId2(payload) {
-  const direct = getString(payload.tool_call_id);
-  if (direct) return direct;
-  if (isRecord7(payload.payload)) {
-    const nestedPayload = getString(payload.payload.tool_call_id);
-    if (nestedPayload) return nestedPayload;
-  }
-  if (isRecord7(payload.data)) {
-    const nestedData = getString(payload.data.tool_call_id);
-    if (nestedData) return nestedData;
-  }
-  return void 0;
-}
-function isTerminalStatus(status) {
-  return status === "completed" || status === "failed";
-}
-var ACPContractAdapter = class {
-  constructor(options) {
-    this.taskReferences = /* @__PURE__ */ new Map();
-    this.toolCallReferences = /* @__PURE__ */ new Map();
-    this.runtime = options.runtime;
-    this.notifier = options.notifier;
-    this.mapper = new ACPEventMapper();
-    this.permissionBridge = new ACPPermissionBridge({
-      notifier: options.notifier,
-      enabled: options.requestPermission === true,
-      buildPermissionOptions: options.buildPermissionOptions
-    });
-    this.telemetry = new ACPTelemetry(options.telemetry);
-    this.runtimeUnsubscribe = this.runtime.onExecutionEvent((event) => {
-      void this.handleRuntimeEvent(event);
-    });
-  }
-  dispose() {
-    this.runtimeUnsubscribe();
-    this.taskReferences.clear();
-    this.toolCallReferences.clear();
-  }
-  async executeTool(invocation, context) {
-    const reference = this.mapper.createReference(invocation, context);
-    this.rememberReference(reference);
-    await this.notify(this.mapper.buildPendingUpdate(invocation, reference));
-    const permissionGranted = await this.permissionBridge.requestToolPermission(
-      invocation,
-      context
-    );
-    this.telemetry.emit({
-      phase: "permission",
-      result: permissionGranted ? "ok" : "failed",
-      sessionId: context.sessionId,
-      toolCallId: invocation.toolCallId,
-      toolName: invocation.toolName
-    });
-    if (!permissionGranted) {
-      const result2 = {
-        status: "failed",
-        tool_call_id: invocation.toolCallId,
-        error: {
-          code: "permission_denied",
-          message: `Permission denied for ${invocation.toolName}`,
-          retryable: false
-        }
-      };
-      await this.notify(this.mapper.buildResultUpdate(result2, reference));
-      this.cleanupReference(reference, result2);
-      return result2;
-    }
-    const result = await this.runtime.executeToolCall(
-      {
-        tool_call_id: invocation.toolCallId,
-        tool_name: invocation.toolName,
-        args: invocation.args
-      },
-      {
-        appId: context.appId,
-        userId: context.userId,
-        workspaceId: context.workspaceId,
-        provider: context.provider,
-        namespace: context.namespace
-      }
-    );
-    const normalizedResult = {
-      ...result,
-      tool_call_id: result.tool_call_id || invocation.toolCallId
-    };
-    if (normalizedResult.task_id) {
-      this.taskReferences.set(normalizedResult.task_id, reference);
-    }
-    await this.notify(this.mapper.buildResultUpdate(normalizedResult, reference));
-    this.telemetry.emit({
-      phase: "execute",
-      result: normalizedResult.status === "failed" ? "failed" : "ok",
-      sessionId: reference.sessionId,
-      toolCallId: reference.toolCallId,
-      toolName: invocation.toolName,
-      taskId: normalizedResult.task_id,
-      attemptId: normalizedResult.attempt_id,
-      status: normalizedResult.status === "queued" ? "in_progress" : normalizedResult.status === "completed" ? "completed" : normalizedResult.status === "failed" ? "failed" : void 0,
-      error: normalizedResult.error?.message
-    });
-    this.cleanupReference(reference, normalizedResult);
-    return normalizedResult;
-  }
-  ingestContractCallback(payload, context) {
-    const initialTaskId = resolveTaskId(payload);
-    const initialToolCallId = resolveToolCallId2(payload);
-    if (initialTaskId) {
-      const existingByTask = this.taskReferences.get(initialTaskId);
-      const existingByCall = initialToolCallId ? this.toolCallReferences.get(initialToolCallId) : void 0;
-      const reference = existingByTask || existingByCall || {
-        sessionId: context.sessionId,
-        toolCallId: initialToolCallId || initialTaskId,
-        appId: "unknown",
-        userId: "unknown",
-        title: initialToolCallId || initialTaskId,
-        kind: "other"
-      };
-      this.taskReferences.set(initialTaskId, reference);
-      this.toolCallReferences.set(reference.toolCallId, reference);
-    }
-    const event = this.runtime.ingestExecutionEvent(payload);
-    this.telemetry.emit({
-      phase: "ingest",
-      result: event ? "ok" : "skipped",
-      sessionId: context.sessionId,
-      toolCallId: event?.tool_call_id,
-      taskId: event?.task_id,
-      attemptId: event?.attempt_id,
-      eventId: event?.event_id,
-      eventType: event?.event_type
-    });
-    return event;
-  }
-  async handleRuntimeEvent(event) {
-    const reference = this.resolveReferenceForEvent(event);
-    if (!reference) {
-      this.telemetry.emit({
-        phase: "runtime_event",
-        result: "skipped",
-        toolCallId: event.tool_call_id,
-        taskId: event.task_id,
-        attemptId: event.attempt_id,
-        eventId: event.event_id,
-        eventType: event.event_type
-      });
-      return;
-    }
-    this.taskReferences.set(event.task_id, reference);
-    const update = this.mapper.buildLifecycleUpdate(event, reference);
-    if (!update) {
-      this.telemetry.emit({
-        phase: "runtime_event",
-        result: "skipped",
-        sessionId: reference.sessionId,
-        toolCallId: reference.toolCallId,
-        taskId: event.task_id,
-        attemptId: event.attempt_id,
-        eventId: event.event_id,
-        eventType: event.event_type
-      });
-      return;
-    }
-    await this.notify(update);
-    this.telemetry.emit({
-      phase: "runtime_event",
-      result: "ok",
-      sessionId: reference.sessionId,
-      toolCallId: reference.toolCallId,
-      taskId: event.task_id,
-      attemptId: event.attempt_id,
-      eventId: event.event_id,
-      eventType: event.event_type,
-      status: update.update.status
-    });
-    if (isTerminalStatus(update.update.status)) {
-      this.taskReferences.delete(event.task_id);
-      this.toolCallReferences.delete(reference.toolCallId);
-    }
-  }
-  resolveReferenceForEvent(event) {
-    const byTask = this.taskReferences.get(event.task_id);
-    if (byTask) return byTask;
-    const byToolCall = this.toolCallReferences.get(event.tool_call_id);
-    if (byToolCall) return byToolCall;
-    return void 0;
-  }
-  rememberReference(reference) {
-    this.toolCallReferences.set(reference.toolCallId, reference);
-  }
-  cleanupReference(reference, result) {
-    const status = result.status === "queued" ? "in_progress" : result.status === "completed" ? "completed" : result.status === "failed" ? "failed" : "failed";
-    if (!isTerminalStatus(status)) return;
-    this.toolCallReferences.delete(reference.toolCallId);
-    if (result.task_id) {
-      this.taskReferences.delete(result.task_id);
-    }
-  }
-  async notify(update) {
-    try {
-      await this.notifier.notify("session/update", update);
-      this.telemetry.emit({
-        phase: "notify",
-        result: "ok",
-        sessionId: update.sessionId,
-        toolCallId: update.update.toolCallId,
-        status: update.update.status,
-        metadata: {
-          type: update.update.type
-        }
-      });
-    } catch (error) {
-      const reference = this.toolCallReferences.get(update.update.toolCallId);
-      this.telemetry.emit({
-        phase: "notify",
-        result: "failed",
-        sessionId: update.sessionId,
-        toolCallId: update.update.toolCallId,
-        status: update.update.status,
-        error: error instanceof Error ? error.message : "Unknown notify error"
-      });
-      if (!reference) return;
-      const failureUpdate = this.mapper.buildNotifyFailureUpdate(reference, error);
-      try {
-        await this.notifier.notify("session/update", failureUpdate);
-      } catch {
-      }
-    }
-  }
-};
+} from "./chunk-ORAAYW4C.mjs";
 
 // src/index.ts
 var _RealtimeXSDK = class _RealtimeXSDK {
   constructor(config = {}) {
     const envAppId = this.getEnvVar("RTX_APP_ID");
-    const envAppName = this.getEnvVar("RTX_APP_NAME");
     const envApiKey = this.getEnvVar("RTX_API_KEY");
     this.appId = config.realtimex?.appId || envAppId || "";
-    this.appName = config.realtimex?.appName || envAppName;
     this.apiKey = config.realtimex?.apiKey || envApiKey;
-    this.permissions = config.permissions || [];
     this.realtimexUrl = config.realtimex?.url || _RealtimeXSDK.DEFAULT_REALTIMEX_URL;
-    this.httpClient = new HttpClient(this.realtimexUrl, this.appId, this.apiKey);
-    this.activities = new ActivitiesModule(this.realtimexUrl, this.appId, this.appName, this.apiKey);
-    this.webhook = new WebhookModule(this.realtimexUrl, this.appName, this.appId, this.apiKey);
-    this.api = new ApiModule(this.realtimexUrl, this.appId, this.appName, this.apiKey);
-    this.task = new TaskModule(this.realtimexUrl, this.appName, this.appId, this.apiKey);
-    if (config.contract) {
-      this.task.configureContract(config.contract);
-    }
-    this.port = new PortModule(config.defaultPort);
-    this.llm = new LLMModule(this.realtimexUrl, this.appId, this.appName, this.apiKey);
-    this.tts = new TTSModule(this.realtimexUrl, this.appId, this.appName, this.apiKey);
-    this.stt = new STTModule(this.realtimexUrl, this.appId, this.appName, this.apiKey);
-    this.agent = new AgentModule(this.httpClient);
-    this.acpAgent = new AcpAgentModule(this.httpClient);
-    this.mcp = new MCPModule(this.realtimexUrl, this.appId, this.appName, this.apiKey);
-    this.contract = new ContractModule(this.realtimexUrl, this.appName, this.appId, this.apiKey);
-    this.contractRuntime = new ContractRuntime({
-      baseUrl: this.realtimexUrl,
-      appId: this.appId || void 0,
-      appName: this.appName,
-      apiKey: this.apiKey,
-      permissions: this.permissions
-    });
-    this.database = new DatabaseModule(this.realtimexUrl, this.appId, this.apiKey);
-    this.auth = new AuthModule(this.realtimexUrl, this.appId, this.apiKey);
-    this.credentials = new CredentialsModule(this.httpClient);
-    this.v1 = this.apiKey || this.appId ? new V1ApiNamespace(this.realtimexUrl, this.apiKey ?? "", this.appId || void 0) : void 0;
-    this.desktopRuntimeSessions = this.v1?.desktopRuntimeSessions;
-    this.desktopBrowser = this.v1?.desktopBrowser;
-    if (this.permissions.length > 0 && this.appId && !this.apiKey) {
-      this.register().catch((err) => {
-        console.error("[RealtimeX SDK] Auto-registration failed:", err.message);
-      });
-    }
-  }
-  /**
-   * Register app with RealtimeX hub and request declared permissions upfront.
-   * This is called automatically if permissions are provided in constructor.
-   */
-  async register(permissions) {
-    const perms = permissions || this.permissions;
-    if (perms.length === 0) return;
-    try {
-      const response = await fetch(`${this.realtimexUrl.replace(/\/$/, "")}/sdk/register`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          app_id: this.appId,
-          app_name: this.appName,
-          permissions: perms
-        })
-      });
-      const data = await response.json();
-      if (!response.ok) {
-        throw new Error(data.error || "Registration failed");
-      }
-      console.log(`[RealtimeX SDK] App registered successfully (${data.message})`);
-    } catch (error) {
-      throw new Error(`Failed to register app: ${error.message}`);
-    }
+    this.v1 = new V1ApiNamespace(
+      this.realtimexUrl,
+      this.apiKey ?? "",
+      this.appId || void 0
+    );
   }
-  /**
-   * Get environment variable (works in Node.js and browser)
-   */
   getEnvVar(name) {
     if (typeof process !== "undefined" && process.env) {
       return process.env[name];
@@ -3698,125 +31,16 @@ var _RealtimeXSDK = class _RealtimeXSDK {
     }
     return void 0;
   }
-  /**
-   * Ping RealtimeX server to verify connection and authentication.
-   * Works in both development (API Key) and production (App ID) modes.
-   */
-  async ping() {
-    try {
-      const headers = { "Content-Type": "application/json" };
-      if (this.apiKey) {
-        headers["Authorization"] = `Bearer ${this.apiKey}`;
-      }
-      if (this.appId) {
-        headers["x-app-id"] = this.appId;
-      }
-      const response = await fetch(`${this.realtimexUrl.replace(/\/$/, "")}/sdk/ping`, {
-        method: "GET",
-        headers
-      });
-      const data = await response.json();
-      if (!response.ok) {
-        throw new Error(data.error || "Ping failed");
-      }
-      return data;
-    } catch (error) {
-      throw new Error(`Connection failed: ${error.message}`);
-    }
-  }
-  /**
-   * Get the absolute path to the data directory for this app.
-   * Path: ~/.realtimex.ai/Resources/local-apps/{appId}
-   */
-  async getAppDataDir() {
-    try {
-      const headers = { "Content-Type": "application/json" };
-      if (this.apiKey) {
-        headers["Authorization"] = `Bearer ${this.apiKey}`;
-      }
-      if (this.appId) {
-        headers["x-app-id"] = this.appId;
-      }
-      const response = await fetch(`${this.realtimexUrl.replace(/\/$/, "")}/sdk/local-apps/data-dir`, {
-        method: "GET",
-        headers
-      });
-      const data = await response.json();
-      if (!response.ok) {
-        throw new Error(data.error || "Failed to get data directory");
-      }
-      return data.dataDir;
-    } catch (error) {
-      throw new Error(`Failed to get app data directory: ${error.message}`);
-    }
-  }
 };
 _RealtimeXSDK.DEFAULT_REALTIMEX_URL = "http://localhost:3001";
 var RealtimeXSDK = _RealtimeXSDK;
 export {
-  ACPContractAdapter,
-  ACPEventMapper,
-  ACPPermissionBridge,
-  ACPTelemetry,
-  AcpAgentModule,
-  ActivitiesModule,
-  AgentModule,
-  ApiModule,
-  AuthModule,
   AuthenticationError,
-  CONTRACT_ATTEMPT_PREFIX,
-  CONTRACT_EVENT_ID_HEADER,
-  CONTRACT_SIGNATURE_ALGORITHM,
-  CONTRACT_SIGNATURE_HEADER,
-  ClaudeToolAdapter,
-  CodexToolAdapter,
-  ContractCache,
-  ContractClient,
-  ContractError,
-  ContractHttpClient,
-  ContractModule,
-  ContractRuntime,
-  ContractValidationError,
-  DatabaseModule,
   DeveloperApiClient,
   DeveloperApiError,
-  GeminiToolAdapter,
-  LLMModule,
-  LLMPermissionError,
-  LLMProviderError,
-  LOCAL_APP_CONTRACT_VERSION,
-  MCPModule,
   NotFoundError,
-  PermissionDeniedError,
-  PermissionRequiredError,
-  PortModule,
   RealtimeXSDK,
-  RetryPolicy,
-  RuntimeTransportError,
-  STTModule,
-  ScopeDeniedError,
-  ScopeGuard,
   ServerError,
-  StaticAuthProvider,
-  TTSModule,
-  TaskModule,
-  ToolNotFoundError,
-  ToolProjector,
-  ToolValidationError,
   V1ApiNamespace,
-  ValidationError,
-  VectorStore,
-  WebhookModule,
-  buildContractIdempotencyKey,
-  buildContractSignatureMessage,
-  canonicalEventToLegacyAction,
-  createContractEventId,
-  hashContractPayload,
-  normalizeAttemptId,
-  normalizeContractEvent,
-  normalizeLocalAppContractV1,
-  normalizeSchema,
-  parseAttemptRunId,
-  signContractEvent,
-  toStableToolName
+  ValidationError
 };