@cef-ai/widget-runtime 0.2.0

package/dist/vault-client.js

@@ -0,0 +1,122 @@
+// packages/widget-runtime/src/vault-client.ts
+import { AgentNotConnectedError } from './types.js';
+/**
+ * Normalise the raw result from cubbies.query into a uniform QueryResult.
+ * The platform returns `{columns: string[], rows: unknown[][]}` (positional).
+ * Tolerates an array-of-objects shape for forward compatibility.
+ */
+function normaliseQueryResult(raw) {
+    if (raw && typeof raw === 'object' && 'columns' in raw && 'rows' in raw) {
+        const cols = raw.columns;
+        const rows = raw.rows;
+        if (Array.isArray(cols) && Array.isArray(rows)) {
+            return { columns: cols.map(String), rows: rows, meta: { rowCount: rows.length } };
+        }
+    }
+    if (Array.isArray(raw)) {
+        // Array of row objects — derive columns from first row keys.
+        const keys = raw.length > 0 ? Object.keys(raw[0]) : [];
+        const rows = raw.map((r) => keys.map((k) => r[k]));
+        return { columns: keys, rows, meta: { rowCount: raw.length } };
+    }
+    // Fallback: empty result.
+    console.warn('[widget-runtime] unrecognized cubby query result shape; treating as empty', raw);
+    return { columns: [], rows: [], meta: { rowCount: 0 } };
+}
+/**
+ * Map a cubbies.query rejection to AgentNotConnectedError when the error
+ * indicates a 404 / agent-not-connected condition.
+ */
+function mapQueryError(err, agentId) {
+    if (err && typeof err === 'object') {
+        const status = err.status;
+        const message = err.message;
+        if (status === 404 ||
+            (typeof message === 'string' && /not.?connected|404/i.test(message))) {
+            throw new AgentNotConnectedError(agentId);
+        }
+    }
+    throw err;
+}
+export function createVaultClient(manifest, makeSdk) {
+    let sdk;
+    let vaultP;
+    let agentHandleP;
+    const getSdk = () => (sdk ?? (sdk = makeSdk()));
+    const getVault = () => {
+        // `onboard: false` preserves the old lightweight ensure(): claim the vault
+        // with a wallet-built delegation token, skipping the gateway onboarding
+        // status/bootstrap round-trip (widgets assume a provisioned wallet).
+        vaultP ?? (vaultP = getSdk().vault.ensure({ onboard: false }).catch((err) => {
+            vaultP = undefined;
+            throw err;
+        }));
+        return vaultP;
+    };
+    // Memoised agent-connection handle for cubby reads. Cached so polling
+    // queries don't re-fetch the connection record on every call (matching the
+    // single-request-per-query cost of the prior path). Reset on (re)connect
+    // and on read failure so a stale handle can't pin a disconnected state.
+    const getAgentHandle = () => {
+        agentHandleP ?? (agentHandleP = getVault()
+            .then((vault) => vault.agents.get(manifest.agentId))
+            .catch((err) => {
+            agentHandleP = undefined;
+            throw err;
+        }));
+        return agentHandleP;
+    };
+    const resolveSql = (ref) => manifest.queries.find((q) => q.id === ref)?.sql ?? ref;
+    return {
+        async query(ref, params) {
+            // Cubby reads go through vault-sdk's agentId-keyed endpoint. This was
+            // briefly routed via @cef-ai/client-sdk because vault-sdk@0.5.0
+            // percent-encoded the agentId ':' → '%3A' → 404; fixed in 0.5.1.
+            let raw;
+            try {
+                const handle = await getAgentHandle();
+                // vault-sdk 2.x throws synchronously from `.cubby(alias)` when the
+                // alias isn't in the connection's declared aliases (e.g. the agent
+                // isn't connected yet, so the handle carries no aliases). Map that to
+                // AgentNotConnectedError instead of letting an opaque throw escape.
+                let cubbyHandle;
+                try {
+                    cubbyHandle = handle.cubby(manifest.cubbyAlias);
+                }
+                catch {
+                    throw new AgentNotConnectedError(manifest.agentId);
+                }
+                raw = await cubbyHandle.query(resolveSql(ref), params ?? []);
+            }
+            catch (err) {
+                agentHandleP = undefined; // force a fresh handle on the next read
+                if (err instanceof AgentNotConnectedError)
+                    throw err;
+                mapQueryError(err, manifest.agentId);
+            }
+            return normaliseQueryResult(raw);
+        },
+        async publish(type, payload, context) {
+            const vault = await getVault();
+            return vault.scope(manifest.scope).publish({ type, context: context ?? '', payload });
+        },
+        async connectAgent() {
+            const vault = await getVault();
+            // 2.x connect is card-only: pass the agentId + scope straight through.
+            // The vault-api resolves the manifest from the DDC registry and the SDK
+            // signs the GAR agreement internally — no marketplace.getAgent() fetch.
+            await vault.agents.connect({ agentId: manifest.agentId, scope: manifest.scope });
+            agentHandleP = undefined; // drop any cached pre-connect handle
+        },
+        async agentStatus() {
+            try {
+                const vault = await getVault();
+                const handle = await vault.agents.get(manifest.agentId);
+                return handle.status === 'active' ? 'connected' : 'disconnected';
+            }
+            catch {
+                return 'disconnected';
+            }
+        },
+    };
+}