@thyn-ai/sqai 0.1.11 → 0.1.13

package/dist/index.d.cts

@@ -1,9 +1,5 @@
-import { MojoRuntimeConfig, MojoRuntime, QueryResponse, ResolveResponse, Runtime, ResolvedPlan, QueryWithMetadataResponse, VerifyResponse } from 'algenta-sdk';
-export { QueryResponse, ResolveResponse, ResolvedPlan } from 'algenta-sdk';
-
 /** Capability contract: the generated, hash-pinned inventory of everything
- * SQAI exposes. Loaded from the vendored contracts/algenta-capabilities.json
- * (synced hash-verified from the generator). SQAI keeps no
+ * SQAI exposes. Loaded from the vendored capability contract. SQAI keeps no
  * handwritten operation lists — this file is the only authority. */
 interface CapabilitySignatureParam {
     name: string;
@@ -73,7 +69,7 @@ type SqaiMode = "local" | "api" | "deployment";
 
 /** Application policy: pre-execution validation the model can never override.
  *
- * SQAI validates; Algenta calculates. Package capability = the contract's
+ * SQAI validates; the managed runtime calculates. Package capability = the contract's
  * all-readonly surface; application policy = the subset enabled here; a model
  * request = one operation inside that subset.
  */
@@ -86,147 +82,7 @@ interface SqaiPolicy {
     allowedFunctions?: "all-readonly" | string[];
 }
 
-/** Embedded trust root for signed managed-runtime bundles.
- *
- * The provisioner only installs bundles whose manifest signature (RS256 —
- * RSASSA-PKCS1-v1_5 + SHA-256 over the exact shipped manifest bytes) verifies
- * against one of these keys. Revocation and rollback protection live here so
- * a single release-process edit rotates the whole trust posture:
- *
- *   - TRUSTED_KEYS       the accepted verification keys (key_id + PEM)
- *   - REVOKED_KEY_IDS    key_ids that must never verify again
- *   - MIN_ACCEPTED_RUNTIME_VERSION
- *                        the rollback floor: bundle manifests whose
- *                        runtime_bundle_version compares below this are
- *                        rejected (reason `rollback_protected`)
- *
- * Tests (and the release process) can override every value through
- * RuntimeProvisioner options — nothing here is reachable from user input.
- */
-interface TrustedKey {
-    key_id: string;
-    algorithm: "RS256";
-    public_key_pem: string;
-    /** ISO-8601 instant; key is not accepted before it. */
-    valid_from?: string;
-    /** ISO-8601 instant; key is not accepted after it. */
-    valid_to?: string;
-}
-
-/** Managed-runtime provisioning: zero-setup for the computation plane.
- *
- * The query plane never touches this module. On first computation-plane call:
- *   1. Reuse a healthy daemon whose version matches the contract pin.
- *   2. Otherwise verify + spawn the installed bundle for this platform.
- *   3. Otherwise download the contract-pinned bundle (tarball sha256 + RS256
- *      manifest against the embedded trust root — see runtime/trust.ts and
- *      runtime/bundle.ts), extract atomically, spawn.
- *
- * Concurrency hardening: a per-version lock file (`<cacheDir>/<version>.lock`
- * with `{pid, created_at}`) serializes installers across processes — fresh
- * locks are poll-waited (max 90s) while re-checking for a completed install,
- * stale locks (>10 min) are removed. Downloads land in `tmp-<random>` names,
- * verification happens BEFORE extraction, extraction lands in a `tmp-<random>`
- * directory that is atomically renamed into place, and every failure cleans
- * its temp state — a partial install is never left behind.
- */
-
-interface RuntimeStatus {
-    available: boolean;
-    runtime_available: boolean;
-    engine: string | null;
-    module_count: number;
-    platform: string;
-    managed: boolean;
-}
-/** A runtime bundle resolved for a specific module filter (build-on-provision). */
-interface FilteredBundle {
-    url: string;
-    sha256: string;
-    version: string;
-    cacheKey: string;
-}
-interface ProvisionerOptions {
-    contract: CapabilityContract;
-    autoInstall: boolean;
-    /**
-     * Build-on-provision: the developer's module filter. All 4,762 functions are
-     * available in the contract; only the selected modules are compiled + installed.
-     * Empty/undefined → the default pinned bundle (contract.runtime_bundle).
-     */
-    runtimeModules?: string[];
-    /** Build service that compiles a bundle for an exact filter (POST /v1/runtime/build). */
-    buildServiceUrl?: string;
-    /** Injection points for tests. */
-    runtimeFactory?: (config?: MojoRuntimeConfig) => MojoRuntime;
-    downloadBundle?: (url: string, destination: string) => Promise<void>;
-    /** Resolve a filtered bundle (default: POST to buildServiceUrl). Test injection. */
-    resolveFilteredBundle?: (modules: string[], platformKey: string) => Promise<FilteredBundle>;
-    /** Bundle cache directory (default: OS user cache — runtimeCacheDir()). */
-    cacheDir?: string;
-    /** Trust-root overrides (default: the embedded trust root). */
-    trustedKeys?: TrustedKey[];
-    revokedKeyIds?: string[];
-    minAcceptedRuntimeVersion?: string;
-    /** Lock policy overrides. */
-    lockFreshMs?: number;
-    lockWaitTimeoutMs?: number;
-    lockPollIntervalMs?: number;
-}
-declare function currentPlatformKey(): string;
-declare function runtimeCacheDir(): string;
-declare class RuntimeProvisioner {
-    private readonly options;
-    private readonly trustRoot;
-    private runtime;
-    private ensurePromise;
-    constructor(options: ProvisionerOptions);
-    /** Lazily resolve a usable runtime; concurrent callers share one attempt. */
-    ensure(): Promise<MojoRuntime>;
-    status(): Promise<RuntimeStatus>;
-    stop(): Promise<void>;
-    private newRuntime;
-    private ensureLocalLoginKey;
-    private cacheDir;
-    /** Normalized module filter (sorted, unique, non-empty) or null for the default bundle. */
-    private filterModules;
-    /** Ask the build service to compile + sign a bundle for exactly these modules. */
-    private resolveFilteredBundle;
-    /**
-     * The filter's cache key, computed IDENTICALLY to the build service
-     * (sha256("mods|platform|version")[:20], mods = sorted+unique, comma-joined).
-     * Lets the reuse fast-path find an already-running filtered daemon without a
-     * build-service round-trip. The build service's returned key is authoritative
-     * for install; this only has to match for the reuse optimization to hit.
-     */
-    private localCacheKey;
-    /**
-     * Deterministic per-filter daemon endpoint so a filtered runtime never collides
-     * with the default (or another filter's) daemon on the shared default socket.
-     */
-    private filterEndpoint;
-    private static readonly DAEMON_ENDPOINT_ENV;
-    /** Point the about-to-be-spawned daemon at a filter-specific socket/port/dir. */
-    private applyDaemonEndpointEnv;
-    private restoreEnv;
-    private doEnsure;
-    private provisionError;
-    private wrapVerificationError;
-    private manifestExpectations;
-    /** Verify an existing install if present; returns null when absent/invalid. */
-    private verifiedInstallOrNull;
-    private acquireLock;
-    private lockIsStale;
-    /** Serialize installers on `<cacheDir>/<installKey>.lock`; returns the verified install. */
-    private ensureInstalled;
-    /** Holder-of-the-lock path: download → verify → extract → atomic rename. */
-    private downloadVerifyExtract;
-    /** Spawn the installed bundle's daemon through MojoRuntime autoStart. */
-    private spawnInstalled;
-}
-
 /** Public SQAI types. */
-
 /** Contract-derived wire value: everything the computation plane can
  * transport. The wire schema transports; the capability contract authorizes. */
 type SqaiValue = null | boolean | number | string | SqaiValue[] | {
@@ -327,7 +183,132 @@ interface QueryFilterSpec {
     time_filter?: string;
     conditions?: QueryFilterCondition[];
 }
-/** The caller/model-authored resolve-spec — Algenta names verbatim. */
+interface QueryCandidate {
+    source: string;
+    column: string;
+    role: string;
+    magnitude?: string | null;
+    formula?: string | null;
+    confidence: number;
+    score_components?: Record<string, number>;
+    notes?: string[];
+}
+interface ResolvedPlan {
+    source_name: string;
+    metric_column: string;
+    aggregation: string;
+    group_column?: string | null;
+    join_path?: Record<string, unknown> | null;
+    filter?: QueryFilterSpec | null;
+    limit?: number | null;
+    order?: string;
+    constraints?: Record<string, unknown>;
+    schema_revision: string;
+}
+interface ResolveResponse {
+    resolved_plan?: ResolvedPlan | null;
+    confidence: number;
+    plan: string[];
+    explanation: string[];
+    resolved_column: string;
+    resolved_role: string;
+    resolved_source: string;
+    candidates: QueryCandidate[];
+    source_scores: Record<string, number>;
+    latency_ms: number;
+    decision_path: string;
+    plan_hash?: string | null;
+    schema_revision: string;
+    validated: boolean;
+    deterministic_scope: string;
+    confidence_source: string;
+    clarification_required?: boolean;
+    rejection_reason?: string | null;
+    request_id?: string | null;
+    intent_signature: string;
+    source_set?: string[];
+    join_path?: Array<Record<string, unknown>>;
+    planner_mode?: string | null;
+}
+interface QueryResponse {
+    query_id: string;
+    result: unknown;
+    result_type: string;
+    confidence: number;
+    plan: string[];
+    resolved_column: string;
+    resolved_role: string;
+    resolved_source: string;
+    row_count: number;
+    candidates: QueryCandidate[];
+    source_scores: Record<string, number>;
+    ambiguous: boolean;
+    exact_spec: boolean;
+    explanation: string[];
+    latency_ms: number;
+    decision_path: string;
+    plan_hash: string;
+    schema_revision?: string | null;
+    validated: boolean;
+    deterministic_scope: string;
+    confidence_source: string;
+    clarification_required?: boolean;
+    rejection_reason?: string | null;
+    request_id?: string | null;
+    source_set?: string[];
+    join_path?: Array<Record<string, unknown>>;
+    planner_mode?: string | null;
+}
+interface QueryExecutionMetadata {
+    request_id?: string | null;
+    latency_ms?: number | null;
+    tokens_in?: number | null;
+    tokens_out?: number | null;
+    cost_usd?: number | null;
+    cache_hit?: boolean | null;
+}
+interface QueryWithMetadataResponse {
+    data: QueryResponse;
+    metadata: QueryExecutionMetadata;
+    headers?: Record<string, string> | null;
+}
+interface VerifyResponse {
+    valid: boolean;
+    errors: string[];
+    suggestions: string[];
+    resolved: Record<string, string>;
+    valid_dimensions?: string[];
+    valid_measures?: string[];
+    source_behavior?: string;
+    latency_ms: number;
+    verified?: boolean;
+    request_id?: string | null;
+    schema_revision?: string | null;
+    plan_hash?: string | null;
+    verification_mode?: string;
+    rejection_reason?: string | null;
+}
+interface SourceRegistrationResponse {
+    source_id?: string | null;
+    dataset_id?: string | null;
+    name?: string | null;
+    dataset_name?: string | null;
+    status: string;
+    ingest_mode?: string | null;
+    schema?: Record<string, unknown> | null;
+    source_schema?: Record<string, unknown> | null;
+    planner_cache_hit?: boolean | null;
+    planner_schema_revision?: string | null;
+    planner_prewarm_ms?: number | null;
+    latency_ms?: number | null;
+    row_count?: number | null;
+    typed_fields?: Array<{
+        name: string;
+        type: string;
+    }> | null;
+    [key: string]: unknown;
+}
+/** The caller/model-authored resolve-spec. */
 interface QuerySpec {
     metric: string;
     aggregation?: "sum" | "avg" | "count" | "min" | "max";
@@ -444,16 +425,23 @@ interface ResultStoreConfig {
     maxTenantResultBytes?: number;
 }
 
-/** Computation dispatch: delegate a validated computation to Algenta.
+/** Computation dispatch: delegate a validated computation to the runtime.
  *
- * Local mode → the managed runtime daemon via algenta-sdk's MojoRuntime.
  * deployment / api mode → POST {baseUrl}/v1/libraries/execute.
  * SQAI performs no calculation of its own in either path.
  */
 
+interface LocalComputeRuntime {
+    execute(module: string, functionName: string, args?: SqaiValue, requestId?: string, timeoutSeconds?: number): Promise<{
+        result: unknown;
+        latency_ms: number;
+        engine_used: string;
+        request_id?: string | null;
+    }>;
+}
 type DispatchTarget = {
     kind: "local";
-    runtime: MojoRuntime;
+    runtime: LocalComputeRuntime;
 } | {
     kind: "http";
     baseUrl: string;
@@ -461,14 +449,165 @@ type DispatchTarget = {
     fetchImpl?: typeof fetch;
 };
 
-/** The SQAI client: a thin, policy-checked facade over the Algenta runtime.
+/** Embedded trust root for signed managed-runtime bundles.
+ *
+ * The provisioner only installs bundles whose manifest signature (RS256 —
+ * RSASSA-PKCS1-v1_5 + SHA-256 over the exact shipped manifest bytes) verifies
+ * against one of these keys. Revocation and rollback protection live here so
+ * a single release-process edit rotates the whole trust posture:
+ *
+ *   - TRUSTED_KEYS       the accepted verification keys (key_id + PEM)
+ *   - REVOKED_KEY_IDS    key_ids that must never verify again
+ *   - MIN_ACCEPTED_RUNTIME_VERSION
+ *                        the rollback floor: bundle manifests whose
+ *                        runtime_bundle_version compares below this are
+ *                        rejected (reason `rollback_protected`)
+ *
+ * Tests (and the release process) can override every value through
+ * RuntimeProvisioner options — nothing here is reachable from user input.
+ */
+interface TrustedKey {
+    key_id: string;
+    algorithm: "RS256";
+    public_key_pem: string;
+    /** ISO-8601 instant; key is not accepted before it. */
+    valid_from?: string;
+    /** ISO-8601 instant; key is not accepted after it. */
+    valid_to?: string;
+}
+
+/** Managed-runtime provisioning: zero-setup for the computation plane.
+ *
+ * The query plane never touches this module. On first computation-plane call:
+ *   1. Reuse a healthy daemon whose version matches the contract pin.
+ *   2. Otherwise verify + spawn the installed bundle for this platform.
+ *   3. Otherwise download the contract-pinned bundle (tarball sha256 + RS256
+ *      manifest against the embedded trust root — see runtime/trust.ts and
+ *      runtime/bundle.ts), extract atomically, spawn.
+ *
+ * Concurrency hardening: a per-version lock file (`<cacheDir>/<version>.lock`
+ * with `{pid, created_at}`) serializes installers across processes — fresh
+ * locks are poll-waited (max 90s) while re-checking for a completed install,
+ * stale locks (>10 min) are removed. Downloads land in `tmp-<random>` names,
+ * verification happens BEFORE extraction, extraction lands in a `tmp-<random>`
+ * directory that is atomically renamed into place, and every failure cleans
+ * its temp state — a partial install is never left behind.
+ */
+
+interface RuntimeStatus {
+    available: boolean;
+    runtime_available: boolean;
+    engine: string | null;
+    module_count: number;
+    platform: string;
+    managed: boolean;
+}
+interface ManagedRuntimeConfig {
+    mode?: "local";
+    tcpAddress?: string;
+    timeout?: number;
+    autoStart?: boolean;
+    daemonCommand?: string[];
+}
+interface ManagedRuntime extends LocalComputeRuntime {
+    health(): Promise<{
+        runtime_available: boolean;
+        engine: string;
+        module_count: number;
+    }>;
+}
+/** A runtime bundle resolved for a specific module filter (build-on-provision). */
+interface FilteredBundle {
+    url: string;
+    sha256: string;
+    version: string;
+    cacheKey: string;
+}
+interface ProvisionerOptions {
+    contract: CapabilityContract;
+    autoInstall: boolean;
+    /**
+     * Build-on-provision: the developer's module filter. All 4,762 functions are
+     * available in the contract; only the selected modules are compiled + installed.
+     * Empty/undefined → the default pinned bundle (contract.runtime_bundle).
+     */
+    runtimeModules?: string[];
+    /** Build service that compiles a bundle for an exact filter (POST /v1/runtime/build). */
+    buildServiceUrl?: string;
+    /** Injection points for tests. */
+    runtimeFactory?: (config?: ManagedRuntimeConfig) => ManagedRuntime;
+    downloadBundle?: (url: string, destination: string) => Promise<void>;
+    /** Resolve a filtered bundle (default: POST to buildServiceUrl). Test injection. */
+    resolveFilteredBundle?: (modules: string[], platformKey: string) => Promise<FilteredBundle>;
+    /** Bundle cache directory (default: OS user cache — runtimeCacheDir()). */
+    cacheDir?: string;
+    /** Trust-root overrides (default: the embedded trust root). */
+    trustedKeys?: TrustedKey[];
+    revokedKeyIds?: string[];
+    minAcceptedRuntimeVersion?: string;
+    /** Lock policy overrides. */
+    lockFreshMs?: number;
+    lockWaitTimeoutMs?: number;
+    lockPollIntervalMs?: number;
+}
+declare function currentPlatformKey(): string;
+declare function runtimeCacheDir(): string;
+declare class RuntimeProvisioner {
+    private readonly options;
+    private readonly trustRoot;
+    private runtime;
+    private ensurePromise;
+    constructor(options: ProvisionerOptions);
+    /** Lazily resolve a usable runtime; concurrent callers share one attempt. */
+    ensure(): Promise<ManagedRuntime>;
+    status(): Promise<RuntimeStatus>;
+    stop(): Promise<void>;
+    private newRuntime;
+    private ensureLocalLoginKey;
+    private cacheDir;
+    /** Normalized module filter (sorted, unique, non-empty) or null for the default bundle. */
+    private filterModules;
+    /** Ask the build service to compile + sign a bundle for exactly these modules. */
+    private resolveFilteredBundle;
+    /**
+     * The filter's cache key, computed IDENTICALLY to the build service
+     * (sha256("mods|platform|version")[:20], mods = sorted+unique, comma-joined).
+     * Lets the reuse fast-path find an already-running filtered daemon without a
+     * build-service round-trip. The build service's returned key is authoritative
+     * for install; this only has to match for the reuse optimization to hit.
+     */
+    private localCacheKey;
+    /**
+     * Deterministic per-filter daemon endpoint so a filtered runtime never collides
+     * with the default (or another filter's) daemon on the shared default socket.
+     */
+    private filterEndpoint;
+    private static readonly DAEMON_ENDPOINT_ENV;
+    /** Point the about-to-be-spawned daemon at a filter-specific socket/port/dir. */
+    private applyDaemonEndpointEnv;
+    private restoreEnv;
+    private doEnsure;
+    private provisionError;
+    private wrapVerificationError;
+    private manifestExpectations;
+    /** Verify an existing install if present; returns null when absent/invalid. */
+    private verifiedInstallOrNull;
+    private acquireLock;
+    private lockIsStale;
+    /** Serialize installers on `<cacheDir>/<installKey>.lock`; returns the verified install. */
+    private ensureInstalled;
+    /** Holder-of-the-lock path: download → verify → extract → atomic rename. */
+    private downloadVerifyExtract;
+    /** Spawn the installed bundle's daemon through managed runtime auto-start. */
+    private spawnInstalled;
+}
+
+/** The SQAI client: a thin, policy-checked facade over the runtime.
  *
  * Query plane   — connect / resolve / query / verify / ask, in-process.
  * Computation   — validate against the capability contract, resolve bindings
  *                 through the upstream aligned extraction primitive, delegate
  *                 to the managed runtime, pass results through verbatim.
- *
- * SQAI reimplements nothing: every discrepancy is fixed upstream in Algenta.
  */
 
 interface SqaiConfig {
@@ -494,14 +633,14 @@ interface SqaiConfig {
     runtimeModules?: string[];
     /** Build service endpoint for filtered bundles. Env: SQAI_BUILD_SERVICE_URL. */
     buildServiceUrl?: string;
-    /** BYO substrate (tests). */
-    runtime?: Runtime;
+    /** BYO runtime (tests / custom SQAI deployments). */
+    runtime?: unknown;
     /** BYO computation dispatch target (tests / custom SQAI deployments). */
     computeTarget?: DispatchTarget;
 }
 declare class SQAI {
     readonly mode: SqaiMode;
-    private readonly algentaRuntime;
+    private readonly runtimeClient;
     private readonly rawRuntime;
     private readonly policy;
     private readonly tenantId;
@@ -595,9 +734,8 @@ declare const SQAI_ERROR_CODES: readonly ["unsupported_operation", "seed_require
  * canonically serialized result.
  *
  * Both are domain-separated and rendered with the cross-language canonical
- * JSON (algenta-sdk canonicalJson === algenta-core canonical_json, locked by
- * the upstream conformance suite), so TypeScript and Python produce identical
- * hashes for identical work.
+ * JSON locked by the upstream conformance suite, so TypeScript and Python
+ * produce identical hashes for identical work.
  */
 
 interface InvocationIdentity {
@@ -649,9 +787,9 @@ declare class ResultStore {
  *
  * Authenticates via the shared accounts portal (OAuth 2.0 device grant, RFC 8628), resolves-or-creates
  * the caller's org on the free `sqai_developer` tier, and mints a control-plane API key. The key is
- * cached under ~/.sqai and handed to the local runtime daemon (as ALGENTA_API_KEY), which exchanges it
+ * cached under ~/.sqai and handed to the local runtime daemon, which exchanges it
  * once for a platform-signed, device-bound offline license — then everything runs locally, no query-time
- * network. Same device tech telys/algenta use; only the product literals differ.
+ * network.
  *
  * Free forever on 1 machine. Paid tiers (sqai_pro / sqai_team) add devices/seats/commercial use via the
  * accounts billing portal — never a cloud service. Login is licensing-only; no data leaves the machine.
@@ -659,7 +797,7 @@ declare class ResultStore {
 declare class LoginError extends Error {
 }
 declare function sqaiHome(): string;
-/** Resolve the SQAI API key for the runtime: $SQAI_API_KEY / $ALGENTA_API_KEY, else the cached key. */
+/** Resolve the SQAI API key for the runtime: $SQAI_API_KEY, legacy env, else the cached key. */
 declare function readCachedApiKey(): Promise<string | undefined>;
 interface LoginResult {
     device_id: string;
@@ -676,8 +814,8 @@ declare function logout(): void;
 
 /** Computation-plane validation: dynamic, against the embedded capability
  * contract. The zod wire schema (in @thyn-ai/sqai-ai-sdk) only transports values;
- * everything here authorizes them. SQAI computes nothing — a validated
- * computation is delegated to Algenta verbatim.
+ * everything here authorizes them. SQAI computes nothing; a validated
+ * computation is delegated to the managed runtime verbatim.
  *
  * Argument assembly: every signature parameter is supplied through EXACTLY one
  * of args (positional), kwargs (by name), or bindings (by name or index).
@@ -700,4 +838,4 @@ interface ValidatedComputation {
 declare function lookupCapability(index: ContractIndex, module: string, functionName: string): CapabilityEntry;
 declare function validateComputation(spec: ComputationSpec, index: ContractIndex, policy: SqaiPolicy | undefined, resolvedBindings: ResolvedBindingValue[]): ValidatedComputation;
 
-export { type AskOutcome, type BindingProvenance, type CapabilityContract, type CapabilityEntry, type CapabilityMatch, type ColumnExtract, type ComputationBinding, type ComputationSpec, type ComputeResult, ContractIndex, type DeterminismEnvelope, type InvocationIdentity, LoginError, type LoginResult, type QueryFilterCondition, type QueryFilterSpec, type QuerySpec, type ResolvedBindingValue, ResultStore, type ResultStoreConfig, RuntimeProvisioner, type RuntimeStatus, SQAI, SQAI_CONNECTOR_TYPES, SQAI_CONNECTOR_TYPE_ALIASES, SQAI_ERROR_CODES, type SqaiConfig, type SqaiConnectorBrowseResult, type SqaiConnectorConfig, type SqaiConnectorCreateRequest, type SqaiConnectorInfo, type SqaiConnectorListResult, type SqaiConnectorPreview, type SqaiConnectorTestResult, type SqaiConnectorType, type SqaiConnectorUpdateRequest, SqaiError, type SqaiErrorSource, type SqaiIntent, type SqaiManagedConnectOptions, type SqaiOutcome, type SqaiPolicy, type SqaiResultRecord, type SqaiSource, type SqaiValue, type ValidatedComputation, computationHash, createSQAI, currentPlatformKey, invocationHash, isReadOnlyEligible, login, logout, lookupCapability, readCachedApiKey, runtimeCacheDir, sqaiHome, validateComputation };
+export { type AskOutcome, type BindingProvenance, type CapabilityContract, type CapabilityEntry, type CapabilityMatch, type ColumnExtract, type ComputationBinding, type ComputationSpec, type ComputeResult, ContractIndex, type DeterminismEnvelope, type InvocationIdentity, LoginError, type LoginResult, type QueryFilterCondition, type QueryFilterSpec, type QueryResponse, type QuerySpec, type QueryWithMetadataResponse, type ResolveResponse, type ResolvedBindingValue, type ResolvedPlan, ResultStore, type ResultStoreConfig, RuntimeProvisioner, type RuntimeStatus, SQAI, SQAI_CONNECTOR_TYPES, SQAI_CONNECTOR_TYPE_ALIASES, SQAI_ERROR_CODES, type SourceRegistrationResponse, type SqaiConfig, type SqaiConnectorBrowseResult, type SqaiConnectorConfig, type SqaiConnectorCreateRequest, type SqaiConnectorInfo, type SqaiConnectorListResult, type SqaiConnectorPreview, type SqaiConnectorTestResult, type SqaiConnectorType, type SqaiConnectorUpdateRequest, SqaiError, type SqaiErrorSource, type SqaiIntent, type SqaiManagedConnectOptions, type SqaiOutcome, type SqaiPolicy, type SqaiResultRecord, type SqaiSource, type SqaiValue, type ValidatedComputation, type VerifyResponse, computationHash, createSQAI, currentPlatformKey, invocationHash, isReadOnlyEligible, login, logout, lookupCapability, readCachedApiKey, runtimeCacheDir, sqaiHome, validateComputation };