@cef-ai/widget-runtime 2.2.1 → 2.3.1

package/dist/entry.js

@@ -7,7 +7,7 @@ import { createCefWalletGate } from './cef-wallet.js';
 import { autoSignIn } from './sign-in-ui.js';
 import { currentLinkContext } from './share-link.js';
 import { createIdentityResolver } from './resolve-identity.js';
-import { createVaultClient } from './vault-client.js';
+import { createVaultClient, openHostVault } from './vault-client.js';
 import { toVaultSdkConfig } from './vault-sdk-config.js';
 import { createWidgetRuntime } from './runtime.js';
 import { captureAndUploadAudio, createVaultObjectUploader } from './audio/capture-upload.js';
@@ -155,19 +155,15 @@ function boot() {
                 const id = await resolveSigningIdentity();
                 const vaultSdkSigner = toVaultSdkSigner(id.publicKey, id.sigType, id.sign);
                 // Same delegation preference as the vault client: an upload that signs
-                // per chunk on a keyless session is a ceremony per chunk.
-                // Same config builder as the main vault client above — in particular
-                // the same `chainUrl`, since this `ensure({ onboard: false })` runs
-                // the vault-delegate grant step too.
+                // per chunk on a keyless session is a ceremony per chunk. Same config
+                // builder too — in particular the same `chainUrl`, which the `ensure()`
+                // branch of `openHostVault` needs for its vault-delegate grant.
                 const sdk = new VaultSDK(toVaultSdkConfig(manifest.endpoints, vaultSdkSigner, id.token, id.renewToken));
-                // With a token that SDK has no signer, and `ensure()` does not read
-                // `auth`: it needs the token handed to it, or it throws before the
-                // first chunk. Without one the key stays absent so the signer path runs.
-                const ensuredVault = await sdk.vault.ensure({
-                    onboard: false,
-                    ...(id.token ? { delegationToken: id.token } : {}),
-                });
-                return createVaultObjectUploader({ objects: ensuredVault.scope(manifest.scope).objects });
+                // The same vault the reader opened: the job runs where the event was
+                // published, so audio uploaded anywhere else is a URL into a database
+                // the agent is not in.
+                const uploadVault = await openHostVault(sdk.vault, id.context?.vaultId, id.token);
+                return createVaultObjectUploader({ objects: uploadVault.scope(manifest.scope).objects });
             })().catch((err) => { uploaderP = null; throw err; });
             return uploaderP;
         };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { buildWidgetManifest, type BuildManifestInput } from './manifest.js';
 export { injectWidgetBridge, type BridgeInput } from './bridge.js';
-export type { WidgetManifest, WidgetRuntimeApi, Identity, QueryResult } from './types.js';
+export type { WidgetManifest, WidgetRuntimeApi, Identity, QueryResult, PublishOptions } from './types.js';
 export { AgentNotConnectedError } from './types.js';
 export { validateConfig } from './validate-config.js';
 export { mountKind } from './mount.js';

package/dist/runtime.js

@@ -37,7 +37,7 @@ export function createWidgetRuntime(manifest, deps) {
     }
     return {
         async query(ref, params) { return (await ensureClient()).query(ref, params); },
-        async publish(type, payload, context) { return (await ensureClient()).publish(type, payload, context); },
+        async publish(type, payload, context, options) { return (await ensureClient()).publish(type, payload, context, options); },
         async identity() {
             await ensureClient();
             return { publicKey, status, ...(context ? { context } : {}) };

package/dist/types.d.ts

@@ -108,9 +108,21 @@ export interface QueryResult {
         rowCount: number;
     };
 }
+export interface PublishOptions {
+    /** The one agent this event is for, `<asPubkey>:<name>`. */
+    target?: string;
+}
 export interface WidgetRuntimeApi {
     query(ref: string, params?: unknown[]): Promise<QueryResult>;
-    publish(type: string, payload: unknown, context?: string): Promise<{
+    /**
+     * Publish an event into the widget's scope.
+     *
+     * `target` addresses one agent (`<asPubkey>:<name>`). A workflow is started
+     * this way: its manifest handles the runner's fixed set (`workflow.start`,
+     * …), never the trigger's own event type, so an untargeted `workflow.start`
+     * would start every workflow connected in the scope.
+     */
+    publish(type: string, payload: unknown, context?: string, options?: PublishOptions): Promise<{
         eventId: string;
     }>;
     identity(): Promise<Identity>;

package/dist/vault-client.d.ts

@@ -1,4 +1,4 @@
-import { type QueryResult, type WidgetManifest } from './types.js';
+import { type QueryResult, type WidgetManifest, type PublishOptions } from './types.js';
 export interface VaultSdkLike {
     vault: {
         ensure: (opts?: {
@@ -41,6 +41,26 @@ export declare class WidgetVaultUnreachableError extends Error {
     readonly reason: string;
     constructor(vaultId: string, cause?: unknown);
 }
+/**
+ * THE VAULT A WIDGET WORKS IN — the one the host named, else the caller's.
+ *
+ * There is deliberately no third branch. A named vault that will not open is an
+ * error, never a quiet fall-through to `ensure()`: the fall-through is
+ * indistinguishable from an empty result, and being indistinguishable from an
+ * empty result is the bug.
+ *
+ * Shared by the reader and the audio uploader, which each used to decide this
+ * for themselves — and only one of them knew about `context.vaultId`.
+ *
+ * Generic so both `VaultLike` and the real vault-sdk handle fit without `any`.
+ */
+export declare function openHostVault<V>(vaultNs: {
+    ensure: (opts?: {
+        onboard?: boolean;
+        delegationToken?: string;
+    }) => Promise<V>;
+    byId?: (vaultId: string) => Promise<V>;
+}, hostVaultId: string | undefined, hostToken?: string): Promise<V>;
 interface VaultLike {
     id: string;
     agents: {
@@ -95,7 +115,7 @@ interface AgentHandleLike {
 }
 export interface VaultClient {
     query(ref: string, params?: unknown[]): Promise<QueryResult>;
-    publish(type: string, payload: unknown, context?: string): Promise<{
+    publish(type: string, payload: unknown, context?: string, options?: PublishOptions): Promise<{
         eventId: string;
     }>;
     connectAgent(): Promise<void>;

package/dist/vault-client.js

@@ -29,6 +29,41 @@ export class WidgetVaultUnreachableError extends Error {
         this.reason = reason;
     }
 }
+/**
+ * THE VAULT A WIDGET WORKS IN — the one the host named, else the caller's.
+ *
+ * There is deliberately no third branch. A named vault that will not open is an
+ * error, never a quiet fall-through to `ensure()`: the fall-through is
+ * indistinguishable from an empty result, and being indistinguishable from an
+ * empty result is the bug.
+ *
+ * Shared by the reader and the audio uploader, which each used to decide this
+ * for themselves — and only one of them knew about `context.vaultId`.
+ *
+ * Generic so both `VaultLike` and the real vault-sdk handle fit without `any`.
+ */
+export async function openHostVault(vaultNs, hostVaultId, hostToken) {
+    if (!hostVaultId) {
+        // `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).
+        return vaultNs.ensure({
+            onboard: false,
+            ...(hostToken ? { delegationToken: hostToken } : {}),
+        });
+    }
+    if (typeof vaultNs.byId !== 'function') {
+        throw new WidgetVaultUnreachableError(hostVaultId);
+    }
+    try {
+        return await vaultNs.byId(hostVaultId);
+    }
+    catch (err) {
+        // Not found, no access, network — all one answer to the reader: this is
+        // not your vault and nothing here can show you what is in it.
+        throw new WidgetVaultUnreachableError(hostVaultId, err);
+    }
+}
 /**
  * Normalise the raw result from cubbies.query into a uniform QueryResult.
  * The platform returns `{columns: string[], rows: unknown[][]}` (positional).
@@ -90,37 +125,10 @@ hostVaultId) {
     let sdk;
     let vaultP;
     const getSdk = () => (sdk ?? (sdk = makeSdk()));
-    /**
-     * THE VAULT THIS WIDGET READS — the one the host named, else the caller's.
-     *
-     * There is deliberately no third branch. A named vault that will not open is
-     * an error, never a quiet fall-through to `ensure()`: the fall-through is
-     * indistinguishable from an empty result, and being indistinguishable from an
-     * empty result is the bug.
-     */
-    const openVault = async () => {
-        if (!hostVaultId) {
-            // `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).
-            return getSdk().vault.ensure({
-                onboard: false,
-                ...(hostToken ? { delegationToken: hostToken } : {}),
-            });
-        }
-        const vaultNs = getSdk().vault;
-        if (typeof vaultNs.byId !== 'function') {
-            throw new WidgetVaultUnreachableError(hostVaultId);
-        }
-        try {
-            return await vaultNs.byId(hostVaultId);
-        }
-        catch (err) {
-            // Not found, no access, network — all one answer to the reader: this is
-            // not your vault and nothing here can show you what is in it.
-            throw new WidgetVaultUnreachableError(hostVaultId, err);
-        }
-    };
+    // `async` so a synchronous throw from `makeSdk()` lands as a rejected promise
+    // rather than in the caller's frame — `getVault()` is only ever awaited today,
+    // but the `vaultP` memo below assumes a promise either way.
+    const openVault = async () => openHostVault(getSdk().vault, hostVaultId, hostToken);
     const getVault = () => {
         vaultP ?? (vaultP = openVault().catch((err) => {
             vaultP = undefined;
@@ -210,9 +218,14 @@ hostVaultId) {
             }
             return normaliseQueryResult(await queryService(decl ?? { id: ref, label: ref, sql: ref }, params ?? []));
         },
-        async publish(type, payload, context) {
+        async publish(type, payload, context, options) {
             const vault = await getVault();
-            return vault.scope(manifest.scope).publish({ type, context: context ?? '', payload });
+            return vault.scope(manifest.scope).publish({
+                type,
+                context: context ?? '',
+                payload,
+                ...(options?.target ? { target: options.target } : {}),
+            });
         },
         async connectAgent() {
             const vault = await getVault();