@thyn-ai/sqai 0.1.4 → 0.1.6

package/dist/index.js

@@ -112,13 +112,13 @@ var SQAI_ERROR_CODES = [
   "contract_mismatch",
   "invalid_intent"
 ];
-var RETRYABLE_ALGENTA_CODES = /* @__PURE__ */ new Set([
+var RETRYABLE_ENGINE_CODES = /* @__PURE__ */ new Set([
   "network_error",
   "timeout",
   "rate_limited",
   "service_unavailable"
 ]);
-function fromAlgentaError(error) {
+function fromEngineError(error) {
   if (error instanceof SqaiError) {
     return error;
   }
@@ -128,7 +128,7 @@ function fromAlgentaError(error) {
   const details = errorLike.details && typeof errorLike.details === "object" ? errorLike.details : {};
   return new SqaiError(code, message, {
     source: "engine",
-    retryable: RETRYABLE_ALGENTA_CODES.has(code),
+    retryable: RETRYABLE_ENGINE_CODES.has(code),
     details
   });
 }
@@ -137,12 +137,14 @@ function fromAlgentaError(error) {
 var DEFAULT_BUILD_SERVICE_URL = "https://sqai-buildservice.fly.dev";
 function readEnv(env = process.env) {
   const apiKey = (env.SQAI_API_KEY ?? "").trim() || void 0;
-  const engineUrl = (env.SQAI_ENGINE_URL ?? "").trim() || void 0;
+  const deploymentUrl = (env.SQAI_DEPLOYMENT_URL ?? "").trim() || void 0;
+  const legacyEngineUrl = (env.SQAI_ENGINE_URL ?? "").trim() || void 0;
+  const engineUrl = deploymentUrl ?? legacyEngineUrl;
   const autoInstall = (env.SQAI_RUNTIME_AUTO_INSTALL ?? "").trim() !== "0";
   const modulesRaw = (env.SQAI_RUNTIME_MODULES ?? "").split(",").map((m) => m.trim()).filter((m) => m.length > 0);
   const runtimeModules = modulesRaw.length > 0 ? modulesRaw : void 0;
   const buildServiceUrl = (env.SQAI_BUILD_SERVICE_URL ?? "").trim() || DEFAULT_BUILD_SERVICE_URL;
-  return { apiKey, engineUrl, autoInstall, runtimeModules, buildServiceUrl };
+  return { apiKey, engineUrl, deploymentUrl, autoInstall, runtimeModules, buildServiceUrl };
 }
 function inferMode(explicit, resolved) {
   if (explicit) {
@@ -151,9 +153,6 @@ function inferMode(explicit, resolved) {
   if (resolved.engineUrl) {
     return "self_hosted";
   }
-  if (resolved.apiKey) {
-    return "api";
-  }
   return "local";
 }
 
@@ -315,22 +314,180 @@ var ResultStore = class {
 };
 
 // src/runtime/provision.ts
-import { homedir, platform as osPlatform, arch as osArch } from "os";
-import { join as join2 } from "path";
-import { createWriteStream, existsSync, promises as fs2 } from "fs";
-import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
+import { homedir as homedir2, platform as osPlatform, arch as osArch } from "os";
+import { join as join3 } from "path";
+import { createWriteStream, existsSync as existsSync2, promises as fs2 } from "fs";
+import { createHash as createHash4, randomBytes as randomBytes2 } from "crypto";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 import { MojoRuntime } from "algenta-sdk";
 
+// src/runtime/auth.ts
+import { createHash as createHash2, createPrivateKey, createPublicKey, generateKeyPairSync } from "crypto";
+import { readFileSync, writeFileSync, mkdirSync, chmodSync, existsSync, rmSync } from "fs";
+import { homedir, hostname } from "os";
+import { join } from "path";
+var CLIENT_ID = "sqai-cli";
+var SCOPE = "sqai";
+var PRODUCT = "sqai";
+var DEFAULT_PLAN = "sqai_developer";
+var DEFAULT_ACCOUNTS_URL = "https://accounts.thyn.ai";
+var DEFAULT_API_URL = "https://api.sqai.com";
+var LoginError = class extends Error {
+};
+function sqaiHome() {
+  return process.env.SQAI_HOME ?? join(homedir(), ".sqai");
+}
+var p = (name) => join(sqaiHome(), name);
+var apiKeyPath = () => p("api_key");
+var tokenPath = () => p("token");
+var deviceIdPath = () => p("device_id");
+var accountsUrl = () => (process.env.SQAI_ACCOUNTS_URL ?? DEFAULT_ACCOUNTS_URL).replace(/\/$/, "");
+var apiUrl = () => (process.env.SQAI_API_URL ?? DEFAULT_API_URL).replace(/\/$/, "");
+function readSecret(path) {
+  try {
+    const v = readFileSync(path, "utf8").trim();
+    return v || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readCachedApiKey() {
+  return process.env.SQAI_API_KEY ?? process.env.ALGENTA_API_KEY ?? readSecret(apiKeyPath());
+}
+function cache(path, value) {
+  mkdirSync(sqaiHome(), { recursive: true });
+  writeFileSync(path, value.trim() + "\n", "utf8");
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
+function deviceId() {
+  const existing = readSecret(deviceIdPath());
+  if (existing) return existing;
+  const value = createHash2("sha256").update(`${hostname()}:${Date.now()}:${Math.random()}`).digest("hex");
+  cache(deviceIdPath(), value);
+  return value;
+}
+async function request(method, url, opts = {}) {
+  const headers = { Accept: "application/json", "User-Agent": "sqai-cli" };
+  if (opts.body !== void 0) headers["Content-Type"] = "application/json";
+  if (opts.bearer) headers["Authorization"] = `Bearer ${opts.bearer}`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method,
+      headers,
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0
+    });
+  } catch (e) {
+    throw new LoginError(`${method} ${url}: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  let json = {};
+  try {
+    json = await res.json();
+  } catch {
+    json = {};
+  }
+  return { status: res.status, json };
+}
+async function deviceAuthorize(accounts, openBrowser, maxWaitMs = 3e5) {
+  const { json: start } = await request("POST", `${accounts}/oauth/device/code`, {
+    body: { client_id: CLIENT_ID, scope: SCOPE }
+  });
+  const deviceCode = start.device_code;
+  const userCode = start.user_code;
+  const verify = start.verification_uri_complete || start.verification_uri;
+  const interval = Number(start.interval ?? 5);
+  if (!deviceCode || !userCode || !verify) throw new LoginError("accounts device-code response missing fields");
+  process.stdout.write(`
+  Open ${verify}
+  and enter code:  ${userCode}
+
+`);
+  if (openBrowser) await tryOpenBrowser(verify);
+  const deadline = Date.now() + maxWaitMs;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, interval * 1e3));
+    const { status, json: tok } = await request("POST", `${accounts}/oauth/device/token`, {
+      body: {
+        client_id: CLIENT_ID,
+        device_code: deviceCode,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+      }
+    });
+    const access = tok.access_token;
+    if (access) return access;
+    const error = tok.error;
+    if (error === "authorization_pending" || error === "slow_down" || status === 400 || status === 428) continue;
+    throw new LoginError(`device authorization failed: ${error ?? `HTTP ${status}`}`);
+  }
+  throw new LoginError("timed out waiting for device authorization");
+}
+async function tryOpenBrowser(url) {
+  try {
+    const { spawn: spawn2 } = await import("child_process");
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    spawn2(cmd, [url], { stdio: "ignore", detached: true, shell: process.platform === "win32" }).unref();
+  } catch {
+  }
+}
+async function createApiKey(api, accessToken, plan) {
+  const { status, json } = await request("POST", `${api}/v1/products/${PRODUCT}/onboard`, {
+    bearer: accessToken,
+    body: { name: CLIENT_ID, product: PRODUCT, plan }
+  });
+  const key = json.raw_key || json.key || json.api_key;
+  if (status >= 400 || !key) {
+    const detail = json.error && typeof json.error === "object" ? json.error.message : void 0;
+    throw new LoginError(`could not create API key (HTTP ${status})${detail ? `: ${detail}` : ""}`);
+  }
+  return key;
+}
+async function login(opts = {}) {
+  const plan = opts.plan ?? DEFAULT_PLAN;
+  const accounts = accountsUrl();
+  const api = apiUrl();
+  let token = opts.accessToken ?? process.env.SQAI_TOKEN;
+  if (token) {
+    process.stdout.write("using supplied token (headless)\n");
+  } else {
+    process.stdout.write(`authenticating via ${accounts} \u2026
+`);
+    token = await deviceAuthorize(accounts, opts.openBrowser ?? true);
+  }
+  cache(tokenPath(), token);
+  process.stdout.write("creating your free SQAI Developer API key \u2026\n");
+  const apiKey = await createApiKey(api, token, plan);
+  cache(apiKeyPath(), apiKey);
+  deviceId();
+  process.stdout.write(
+    "\n  \u2713 sqai login complete \u2014 the local runtime will provision a device-bound offline license on first use.\n  SQAI runs fully on your machine; no data leaves it.\n\n"
+  );
+  return {
+    device_id: deviceId(),
+    plan,
+    api_key_prefix: apiKey.includes("_") ? `${apiKey.split("_", 1)[0]}_\u2026` : `${apiKey.slice(0, 6)}\u2026`
+  };
+}
+function logout() {
+  for (const path of [tokenPath(), apiKeyPath()]) {
+    try {
+      rmSync(path);
+    } catch {
+    }
+  }
+}
+
 // src/runtime/bundle.ts
 import { spawn } from "child_process";
-import { createHash as createHash2, timingSafeEqual } from "crypto";
+import { createHash as createHash3, timingSafeEqual } from "crypto";
 import { createReadStream, promises as fs } from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 
 // src/runtime/trust.ts
-import { createPublicKey, verify as cryptoVerify } from "crypto";
+import { createPublicKey as createPublicKey2, verify as cryptoVerify } from "crypto";
 var RELEASE_1_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
 MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA7m4G1dEMi5FppLa5hu9N
 4pUyoGELPaN5X7bO+9Qktgbv21+c8I4sQCufKouZEVNMNluKNrWcQ5dSwOuVxxS9
@@ -429,7 +586,7 @@ function keyValidNow(key, nowMs) {
 }
 function signatureVerifies(manifestBytes, signature, publicKeyPem) {
   try {
-    const key = createPublicKey(publicKeyPem);
+    const key = createPublicKey2(publicKeyPem);
     if (key.asymmetricKeyType !== "rsa") {
       return false;
     }
@@ -613,7 +770,7 @@ async function hashTarMember(tarball, member, cap) {
     const child = spawn("tar", ["-xOf", tarball, "--", member], {
       stdio: ["ignore", "pipe", "pipe"]
     });
-    const digest = createHash2("sha256");
+    const digest = createHash3("sha256");
     let total = 0;
     let overflow = false;
     child.stdout.on("data", (chunk) => {
@@ -673,7 +830,7 @@ async function extractTarball(tarball, destinationDir) {
 }
 function sha256File(path) {
   return new Promise((resolve, reject) => {
-    const digest = createHash2("sha256");
+    const digest = createHash3("sha256");
     const stream = createReadStream(path);
     stream.on("data", (chunk) => digest.update(chunk));
     stream.on("error", reject);
@@ -685,6 +842,9 @@ function digestsEqual(actualHex, expectedHex) {
   const expected = Buffer.from(expectedHex.toLowerCase(), "utf-8");
   return actual.length === expected.length && timingSafeEqual(actual, expected);
 }
+function isGeneratedBytecodeCache(path) {
+  return path.split("/").includes("__pycache__") && path.endsWith(".pyc") && isSafeRelativePath(path);
+}
 function parseVerifiedManifest(manifestBytes) {
   let manifest;
   try {
@@ -833,7 +993,7 @@ async function verifyBundleTarball(tarball, expectations) {
   return manifest;
 }
 async function listFilesRecursively(root, relative = "") {
-  const entries = await fs.readdir(join(root, relative), { withFileTypes: true });
+  const entries = await fs.readdir(join2(root, relative), { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const relPath = relative === "" ? entry.name : `${relative}/${entry.name}`;
@@ -857,8 +1017,8 @@ async function listFilesRecursively(root, relative = "") {
   return files;
 }
 async function verifyInstalledBundleDir(installDir, expectations) {
-  const manifestPath = join(installDir, MANIFEST_NAME);
-  const signaturePath = join(installDir, MANIFEST_SIG_NAME);
+  const manifestPath = join2(installDir, MANIFEST_NAME);
+  const signaturePath = join2(installDir, MANIFEST_SIG_NAME);
   let manifestBytes;
   let signature;
   try {
@@ -893,12 +1053,15 @@ async function verifyInstalledBundleDir(installDir, expectations) {
     }
     const entry = byPath.get(relPath);
     if (entry === void 0) {
+      if (isGeneratedBytecodeCache(relPath)) {
+        continue;
+      }
       throw new BundleVerificationError(
         "unlisted_member",
         `installed file not listed in signed manifest: '${relPath}'`
       );
     }
-    const absolute = join(installDir, relPath);
+    const absolute = join2(installDir, relPath);
     const stat = await fs.lstat(absolute);
     if (stat.nlink > 1) {
       throw new BundleVerificationError(
@@ -963,20 +1126,20 @@ function currentPlatformKey() {
 function cacheDirFor(brand) {
   const os = osPlatform();
   if (os === "darwin") {
-    return join2(homedir(), "Library", "Caches", brand, "runtime");
+    return join3(homedir2(), "Library", "Caches", brand, "runtime");
   }
   if (os === "win32") {
-    const localAppData = process.env.LOCALAPPDATA ?? join2(homedir(), "AppData", "Local");
-    return join2(localAppData, brand, "runtime");
+    const localAppData = process.env.LOCALAPPDATA ?? join3(homedir2(), "AppData", "Local");
+    return join3(localAppData, brand, "runtime");
   }
-  const xdgCache = process.env.XDG_CACHE_HOME ?? join2(homedir(), ".cache");
-  return join2(xdgCache, brand.toLowerCase(), "runtime");
+  const xdgCache = process.env.XDG_CACHE_HOME ?? join3(homedir2(), ".cache");
+  return join3(xdgCache, brand.toLowerCase(), "runtime");
 }
 function runtimeCacheDir() {
   const current = cacheDirFor("SQAI");
-  if (!existsSync(current)) {
+  if (!existsSync2(current)) {
     const legacy = cacheDirFor("Algenta");
-    if (legacy !== current && existsSync(legacy)) {
+    if (legacy !== current && existsSync2(legacy)) {
       return legacy;
     }
   }
@@ -1061,6 +1224,21 @@ var RuntimeProvisioner = class _RuntimeProvisioner {
     }
     return new MojoRuntime(config ?? {});
   }
+  async ensureLocalLoginKey() {
+    if (this.options.runtimeFactory || process.env.ALGENTA_API_KEY || process.env.DE_API_KEY) {
+      return;
+    }
+    const key = await readCachedApiKey();
+    if (key) {
+      process.env.ALGENTA_API_KEY = key;
+      return;
+    }
+    throw new SqaiError(
+      "login_required",
+      "Local compute requires a free SQAI device login. Run `sqai login` once, or set SQAI_API_KEY in this process.",
+      { details: { reason: "login_key_missing" } }
+    );
+  }
   cacheDir() {
     return this.options.cacheDir ?? runtimeCacheDir();
   }
@@ -1125,7 +1303,7 @@ var RuntimeProvisioner = class _RuntimeProvisioner {
   localCacheKey(modules, platformKey) {
     const canonical = modules.join(",");
     const version = this.options.contract.runtime_bundle.version;
-    return createHash3("sha256").update(`${canonical}|${platformKey}|${version}`).digest("hex").slice(0, 20);
+    return createHash4("sha256").update(`${canonical}|${platformKey}|${version}`).digest("hex").slice(0, 20);
   }
   /**
    * Deterministic per-filter daemon endpoint so a filtered runtime never collides
@@ -1134,7 +1312,7 @@ var RuntimeProvisioner = class _RuntimeProvisioner {
   filterEndpoint(cacheKey) {
     const seed = parseInt(cacheKey.slice(0, 6), 16) || 0;
     const port = 50100 + seed % 800;
-    return { sock: join2(this.cacheDir(), `${cacheKey}.sock`), tcp: `127.0.0.1:${port}` };
+    return { sock: join3(this.cacheDir(), `${cacheKey}.sock`), tcp: `127.0.0.1:${port}` };
   }
   static DAEMON_ENDPOINT_ENV = [
     "ALGENTA_DAEMON_SOCK",
@@ -1151,7 +1329,7 @@ var RuntimeProvisioner = class _RuntimeProvisioner {
     process.env.ALGENTA_DAEMON_SOCK = endpoint.sock;
     process.env.ALGENTA_DAEMON_TCP = endpoint.tcp;
     process.env.ALGENTA_MOJO_SOCK = `${endpoint.sock}.worker`;
-    process.env.ALGENTA_RUNTIME_DIR = join2(installDir, ".runtime");
+    process.env.ALGENTA_RUNTIME_DIR = join3(installDir, ".runtime");
     return saved;
   }
   restoreEnv(saved) {
@@ -1166,6 +1344,7 @@ var RuntimeProvisioner = class _RuntimeProvisioner {
   async doEnsure() {
     const platformKey = currentPlatformKey();
     const filter = this.filterModules();
+    await this.ensureLocalLoginKey();
     const probeEndpoint = filter ? this.filterEndpoint(this.localCacheKey(filter, platformKey)) : void 0;
     const runtime = this.newRuntime(probeEndpoint ? { tcpAddress: probeEndpoint.tcp } : void 0);
     try {
@@ -1193,7 +1372,7 @@ var RuntimeProvisioner = class _RuntimeProvisioner {
         const supported = Object.keys(bundle.platforms);
         throw new SqaiError(
           "unsupported_platform",
-          supported.length === 0 ? "No managed runtime bundle is published yet for any platform. Start a local Algenta runtime daemon, or set SQAI_ENGINE_URL / SQAI_API_KEY to use a hosted engine." : `No managed runtime bundle is published for '${platformKey}'.`,
+          supported.length === 0 ? "No managed runtime bundle is published yet for any platform. Run `sqai login`, or set SQAI_DEPLOYMENT_URL / SQAI_API_KEY for a managed SQAI deployment." : `No managed runtime bundle is published for '${platformKey}'.`,
           { details: { platform: platformKey, supported } }
         );
       }
@@ -1266,9 +1445,9 @@ var RuntimeProvisioner = class _RuntimeProvisioner {
   }
   /** Verify an existing install if present; returns null when absent/invalid. */
   async verifiedInstallOrNull(platformKey, version, removeOnFailure, installKey = version) {
-    const installDir = join2(this.cacheDir(), installKey);
+    const installDir = join3(this.cacheDir(), installKey);
     try {
-      await fs2.access(join2(installDir, MANIFEST_NAME));
+      await fs2.access(join3(installDir, MANIFEST_NAME));
     } catch {
       return null;
     }
@@ -1301,12 +1480,22 @@ var RuntimeProvisioner = class _RuntimeProvisioner {
   }
   async lockIsStale(lockPath) {
     const freshMs = this.options.lockFreshMs ?? LOCK_FRESH_MS;
+    const ageFromMtime = async () => {
+      try {
+        const stat = await fs2.stat(lockPath);
+        return Date.now() - stat.mtimeMs;
+      } catch (error) {
+        const code = error.code;
+        return code === "ENOENT" ? null : Number.POSITIVE_INFINITY;
+      }
+    };
     try {
       const raw = await fs2.readFile(lockPath, "utf-8");
       const parsed = JSON.parse(raw);
       const createdAt = typeof parsed.created_at === "string" ? Date.parse(parsed.created_at) : NaN;
       if (!Number.isFinite(createdAt)) {
-        return true;
+        const age = await ageFromMtime();
+        return age !== null && age >= freshMs;
       }
       return Date.now() - createdAt >= freshMs;
     } catch (error) {
@@ -1314,7 +1503,8 @@ var RuntimeProvisioner = class _RuntimeProvisioner {
       if (code === "ENOENT") {
         return false;
       }
-      return true;
+      const age = await ageFromMtime();
+      return age !== null && age >= freshMs;
     }
   }
   /** Serialize installers on `<cacheDir>/<installKey>.lock`; returns the verified install. */
@@ -1325,7 +1515,7 @@ var RuntimeProvisioner = class _RuntimeProvisioner {
     if (existing) {
       return existing;
     }
-    const lockPath = join2(cacheDir, `${installKey}.lock`);
+    const lockPath = join3(cacheDir, `${installKey}.lock`);
     const waitTimeoutMs = this.options.lockWaitTimeoutMs ?? LOCK_WAIT_TIMEOUT_MS;
     const pollIntervalMs = this.options.lockPollIntervalMs ?? LOCK_POLL_INTERVAL_MS;
     const deadline = Date.now() + waitTimeoutMs;
@@ -1371,9 +1561,9 @@ var RuntimeProvisioner = class _RuntimeProvisioner {
   async downloadVerifyExtract(platformKey, version, platformBundle, installKey = version) {
     const cacheDir = this.cacheDir();
     const token = randomBytes2(6).toString("hex");
-    const tarballPath = join2(cacheDir, `tmp-${token}.tgz`);
-    const extractDir = join2(cacheDir, `tmp-${token}`);
-    const installDir = join2(cacheDir, installKey);
+    const tarballPath = join3(cacheDir, `tmp-${token}.tgz`);
+    const extractDir = join3(cacheDir, `tmp-${token}`);
+    const installDir = join3(cacheDir, installKey);
     const url = resolveBundleUrl(platformBundle.url, version, platformKey);
     try {
       const download = this.options.downloadBundle ?? defaultDownloadBundle;
@@ -1448,10 +1638,11 @@ var RuntimeProvisioner = class _RuntimeProvisioner {
       throw this.wrapVerificationError(error, platformKey, version);
     }
     const daemonCommand = [
-      join2(installed.installDir, ...entryRelative.split("/")),
+      join3(installed.installDir, ...entryRelative.split("/")),
       "start",
       "--foreground"
     ];
+    await this.ensureLocalLoginKey();
     const managed = this.newRuntime(
       endpoint ? { autoStart: true, daemonCommand, tcpAddress: endpoint.tcp } : { autoStart: true, daemonCommand }
     );
@@ -1486,7 +1677,7 @@ var RuntimeProvisioner = class _RuntimeProvisioner {
     }
     try {
       await fs2.writeFile(
-        join2(this.cacheDir(), "state.json"),
+        join3(this.cacheDir(), "state.json"),
         JSON.stringify(
           { pid: null, version, started_at: (/* @__PURE__ */ new Date()).toISOString() },
           null,
@@ -1520,7 +1711,7 @@ async function dispatchComputation(target, entry, argsVector, seed, requestId, t
         request_id: response.request_id ?? requestId
       };
     } catch (error) {
-      throw fromAlgentaError(error);
+      throw fromEngineError(error);
     }
   }
   return dispatchHttp(target, module, functionName, args, requestId);
@@ -1557,7 +1748,7 @@ async function dispatchHttp(target, module, functionName, args, requestId) {
   } catch (error) {
     throw new SqaiError(
       "compute_runtime_unavailable",
-      `The hosted compute endpoint is unreachable: ${error.message}. Check SQAI_ENGINE_URL / SQAI_API_KEY.`,
+      `The SQAI deployment endpoint is unreachable: ${error.message}. Check SQAI_DEPLOYMENT_URL / SQAI_API_KEY.`,
       { retryable: true }
     );
   }
@@ -1740,7 +1931,7 @@ var SQAI = class {
     const env = readEnv();
     this.mode = inferMode(config.mode, env);
     this.apiKey = config.apiKey ?? env.apiKey;
-    this.engineUrl = config.engineUrl ?? env.engineUrl;
+    this.engineUrl = config.deploymentUrl ?? config.engineUrl ?? env.engineUrl;
     this.tenantId = config.tenantId ?? null;
     this.policy = config.policy;
     this.configuredTarget = config.computeTarget;
@@ -1768,7 +1959,7 @@ var SQAI = class {
     this.algentaRuntime = this.rawRuntime;
   }
   // ── Query plane ────────────────────────────────────────────────────────────
-  async connect(source, options = {}) {
+  async connect(source = null, options = {}) {
     try {
       const registration = await this.algentaRuntime.connect(source, options);
       const mapped = mapSource(registration);
@@ -1787,7 +1978,84 @@ var SQAI = class {
       this.sources.set(mapped.name, mapped);
       return mapped;
     } catch (error) {
-      throw error instanceof SqaiError ? error : fromAlgentaError(error);
+      throw error instanceof SqaiError ? error : fromEngineError(error);
+    }
+  }
+  async createConnector(request2) {
+    const createConnector = this.algentaRuntime.createConnector;
+    if (typeof createConnector !== "function") {
+      throw unsupportedSubstrateOperation("createConnector");
+    }
+    try {
+      return await createConnector.call(this.algentaRuntime, request2);
+    } catch (error) {
+      throw fromEngineError(error);
+    }
+  }
+  async listConnectors(options = {}) {
+    const listConnectors = this.algentaRuntime.listConnectors;
+    if (typeof listConnectors !== "function") {
+      throw unsupportedSubstrateOperation("listConnectors");
+    }
+    try {
+      return await listConnectors.call(this.algentaRuntime, options);
+    } catch (error) {
+      throw fromEngineError(error);
+    }
+  }
+  async getConnector(connectorId) {
+    const getConnector = this.algentaRuntime.getConnector;
+    if (typeof getConnector !== "function") {
+      throw unsupportedSubstrateOperation("getConnector");
+    }
+    try {
+      return await getConnector.call(this.algentaRuntime, connectorId);
+    } catch (error) {
+      throw fromEngineError(error);
+    }
+  }
+  async updateConnector(connectorId, request2) {
+    const updateConnector = this.algentaRuntime.updateConnector;
+    if (typeof updateConnector !== "function") {
+      throw unsupportedSubstrateOperation("updateConnector");
+    }
+    try {
+      return await updateConnector.call(this.algentaRuntime, connectorId, request2);
+    } catch (error) {
+      throw fromEngineError(error);
+    }
+  }
+  async testConnector(connectorIdOrConnector) {
+    const testConnector = this.algentaRuntime.testConnector;
+    if (typeof testConnector !== "function") {
+      throw unsupportedSubstrateOperation("testConnector");
+    }
+    try {
+      return await testConnector.call(this.algentaRuntime, connectorIdOrConnector);
+    } catch (error) {
+      throw fromEngineError(error);
+    }
+  }
+  async browseConnector(connectorIdOrConnector) {
+    const browseConnector = this.algentaRuntime.browseConnector;
+    if (typeof browseConnector !== "function") {
+      throw unsupportedSubstrateOperation("browseConnector");
+    }
+    try {
+      return await browseConnector.call(this.algentaRuntime, connectorIdOrConnector);
+    } catch (error) {
+      throw fromEngineError(error);
+    }
+  }
+  async deleteConnector(connectorId) {
+    const deleteConnector = this.algentaRuntime.deleteConnector;
+    if (typeof deleteConnector !== "function") {
+      throw unsupportedSubstrateOperation("deleteConnector");
+    }
+    try {
+      await deleteConnector.call(this.algentaRuntime, connectorId);
+    } catch (error) {
+      throw fromEngineError(error);
     }
   }
   listSources() {
@@ -1798,28 +2066,28 @@ var SQAI = class {
     try {
       return await this.algentaRuntime.resolve(spec);
     } catch (error) {
-      throw fromAlgentaError(error);
+      throw fromEngineError(error);
     }
   }
   async query(plan) {
     try {
       return await this.algentaRuntime.query(plan);
     } catch (error) {
-      throw fromAlgentaError(error);
+      throw fromEngineError(error);
     }
   }
   async queryWithMetadata(plan) {
     try {
       return await this.algentaRuntime.queryWithMetadata(plan);
     } catch (error) {
-      throw fromAlgentaError(error);
+      throw fromEngineError(error);
     }
   }
   async verify(plan) {
     try {
       return await this.algentaRuntime.verify(plan);
     } catch (error) {
-      throw fromAlgentaError(error);
+      throw fromEngineError(error);
     }
   }
   async ask(spec) {
@@ -1841,14 +2109,14 @@ var SQAI = class {
     if (typeof this.algentaRuntime.extractColumns !== "function") {
       throw new SqaiError(
         "unsupported_operation",
-        "The installed algenta-sdk build does not provide extractColumns; upgrade the substrate.",
-        { details: { required: "algenta-sdk extractColumns" } }
+        "The installed SQAI package does not provide extractColumns; upgrade SQAI.",
+        { details: { required: "sqai.extractColumns" } }
       );
     }
     try {
       return await this.algentaRuntime.extractColumns(sourceName, columns, options);
     } catch (error) {
-      throw fromAlgentaError(error);
+      throw fromEngineError(error);
     }
   }
   // ── Computation plane ──────────────────────────────────────────────────────
@@ -1978,7 +2246,7 @@ var SQAI = class {
           "API mode requires SQAI_API_KEY for the computation plane."
         );
       }
-      return { kind: "http", baseUrl: "https://api.algenta.ai", apiKey: this.apiKey };
+      return { kind: "http", baseUrl: "https://api.sqai.com", apiKey: this.apiKey };
     }
     const runtime = await this.provisioner.ensure();
     return { kind: "local", runtime };
@@ -2036,6 +2304,13 @@ var SQAI = class {
 function createSQAI(config = {}) {
   return new SQAI(config);
 }
+function unsupportedSubstrateOperation(operation) {
+  return new SqaiError(
+    "unsupported_operation",
+    `The installed SQAI package does not provide ${operation}; upgrade SQAI.`,
+    { details: { required: `sqai.${operation}` } }
+  );
+}
 function mapSource(registration) {
   const record = registration;
   return {
@@ -2049,11 +2324,60 @@ function mapSource(registration) {
     status: String(registration.status ?? "ready")
   };
 }
+
+// src/types.ts
+var SQAI_CONNECTOR_TYPES = [
+  "s3",
+  "gcs",
+  "azure",
+  "clickhouse",
+  "bigquery",
+  "snowflake",
+  "redshift",
+  "postgres",
+  "postgresql",
+  "sqlite",
+  "mysql",
+  "mssql",
+  "oracle",
+  "neo4j",
+  "redis",
+  "elastic",
+  "elasticsearch",
+  "rest",
+  "rest_api",
+  "file",
+  "file_upload",
+  "github_repo",
+  "gitlab_repo",
+  "bitbucket_repo",
+  "local_repo",
+  "repo_archive"
+];
+var SQAI_CONNECTOR_TYPE_ALIASES = {
+  postgresql: "postgres",
+  click_house: "clickhouse",
+  redis_cache: "redis",
+  elastic: "elasticsearch",
+  rest_api: "rest",
+  file_upload: "file",
+  github: "github_repo",
+  github_repository: "github_repo",
+  gitlab: "gitlab_repo",
+  gitlab_repository: "gitlab_repo",
+  bitbucket: "bitbucket_repo",
+  bitbucket_repository: "bitbucket_repo",
+  local_repository: "local_repo",
+  archive_repository: "repo_archive"
+};
 export {
   ContractIndex,
+  LoginError,
   ResultStore,
   RuntimeProvisioner,
   SQAI,
+  SQAI_CONNECTOR_TYPES,
+  SQAI_CONNECTOR_TYPE_ALIASES,
   SQAI_ERROR_CODES,
   SqaiError,
   computationHash,
@@ -2061,8 +2385,11 @@ export {
   currentPlatformKey,
   invocationHash,
   isReadOnlyEligible,
+  login,
+  logout,
   lookupCapability,
+  readCachedApiKey,
   runtimeCacheDir,
+  sqaiHome,
   validateComputation
 };
-//# sourceMappingURL=index.js.map