nanocodex 0.6.1 → 0.6.4

package/README.md

@@ -80,6 +80,23 @@ Worker, Durable Object, or application proxy that owns rotating credentials.
 Authentication modes are constructors rather than a union of mutually
 exclusive fields on `Agent.create`.
 
+### Personal memories and caller context
+
+Managed agents can keep user preferences separate from team knowledge:
+
+```js
+import { Agent } from "nanocodex/managed";
+
+await Agent.memory({ operation: "scan", query: "my preferences" }, { scope: "personal" });
+await Agent.memory({ operation: "put", content: "I prefer concise replies." }, { scope: "personal" });
+```
+
+The default scope remains `team`. Personal memories belong to the authenticated
+user within their organization, across teams; use the same scope when reading,
+replacing, or deleting a memory. Managed clients also accept descriptive
+`requestOrigin: { client: "desktop", hand: "user:HAND_ID", cwd: "/HAND_ID" }`.
+Caller context is included once at startup and never grants execution authority.
+
 ### Compose and place tools
 
 `createTools` owns one deterministic tool recipe. Custom functions, a portable
@@ -158,8 +175,11 @@ workspace or MCP configuration to an Agent that already receives them through
 `Tools`.
 
 Browser consumers can attach Codex's ChatGPT Realtime voice lifecycle to the
-same retained Agent. The resource owns microphone, speaker, WebRTC, sideband,
+same retained Agent. The resource owns microphone, speaker, WebRTC control,
 and delegation cleanup; stopping voice does not cancel an active coding turn.
+Managed and Connect voice use the WebRTC data channel for live events and
+commands. Speech and captions can flow while durable startup completes;
+delegated work still waits for admission. Local Agents retain the sideband path.
 Snapshots update each speaker's transcript row as speech arrives, using a stable
 `id` and `isPartial` flag. Completion replaces that row. `transcript.delta` events
 carry the current partial text; `transcript` events retain completed-turn semantics.
@@ -214,15 +234,17 @@ subscription adapter (which treats all roles as context), and
 `appendContext(voice, text)` adds background commentary without
 requesting speech. Context and speech are split into provider-sized messages.
 These commands retain frames until sent and preserve them
-across a sideband reconnect. They are also methods on the resource and on
+across reconnects when using the sideband transport. They are also methods on
+the resource and on
 `useVoice` from `nanocodex-react`. These settings use ChatGPT subscription voice;
 custom voices and Platform audio configuration are not accepted.
 
 `Voice.create(...)` remains the equivalent namespaced resource constructor, and
 `Voice.voices` is the exact ChatGPT V3 voice catalog. The constructor accepts a
 normal browser Agent, an account-owned managed Agent, or a grant-scoped
-`ConnectAgent`. Authentication stays in the owning host routes; Connect uses a
-fresh one-use sideband ticket, and the browser binding never receives ChatGPT
+`ConnectAgent`. Authentication stays in the owning host routes. An explicit
+`sidebandUrl` override selects the sideband transport; Connect uses a fresh
+one-use ticket for that path. The browser binding never receives ChatGPT
 credentials or places its reusable grant bearer in a WebSocket URL.
 
 ### Durable Cloudflare Agent
@@ -500,7 +522,7 @@ use the individual factories in server-side Cloudflare Workers. Vite integration
 is provided separately by `nanocodex-vite`.
 
 The browser composition includes native `browseX` public X browsing, advertised
-by `accountInfo().apis` without an X connector. The embedding app serves
+by `environment().apis` without an X connector. The embedding app serves
 `/api/tools/x/browse` and `/api/tools/x/convert`; Nanocodex's account app forwards
 these requests to the private X Worker.
 
@@ -1133,7 +1155,7 @@ package manager or build step:
 
 ```html
 <script type="module">
-  import { Agent, Transport } from "https://cdn.jsdelivr.net/npm/nanocodex@0.6.1/host/index.mjs";
+  import { Agent, Transport } from "https://cdn.jsdelivr.net/npm/nanocodex@0.6.4/host/index.mjs";
   const agent = await Agent.create({
     transport: Transport.hostManaged({
       websocketUrl: "/api/responses",
@@ -1183,3 +1205,133 @@ inspect `agent.configuration()`, `environment()`, `usage()`, `requests()`,
 `artifacts`, `webhook`, and `requiredActions`. See the
 [managed configuration and operations guide](../../docs/MANAGED_AGENT_CONFIGURATION.md)
 for examples, authorization, delivery semantics, and runtime limits.
+
+
+## Call connected services from your app
+
+After Nanocodex Connect login, the app and its agents share the same approved
+service capabilities and exact account selections. Request the services during
+login and call them directly without creating an agent or running a turn:
+
+```js
+const connection = await client.connection.connect({
+  capabilities: { cloudAccounts: { spotify: true, soundcloud: true } },
+});
+const response = await client.connectors.spotify.request({
+  path: "/v1/me/playlists?limit=20",
+  // Select an approved account when more than one is connected:
+  connectionId: connection.grant.connectorConnections.spotify[0],
+});
+if (!response.ok) throw new Error(`Spotify returned ${response.status}`);
+const playlists = await response.json();
+```
+
+`client` is a `Client.create(...)` instance from `nanocodex/connect`. For a dynamic service, use
+`client.connectors.request({ connector: "spotify", path: "/v1/me/playlists" })`.
+The standalone form is `Actions.connectors.request(client, options)`.
+Every API service has a scoped entry point, including `client.connectors.gmail`
+and `client.connectors.soundcloud`. The original singular `client.connector.request`
+and `Actions.connector.request` remain supported. Requests support a provider
+path, HTTP method, optional `connectionId`, JSON object `body`, and abort `signal`.
+The response preserves provider HTTP status, body, and pagination/rate-limit
+headers. Writes are never automatically retried.
+
+The underlying API is `POST /v1/connectors/:connector/request` at the configured
+Connect API origin, authenticated with the app's Connect grant bearer token and
+`X-Nanocodex-App-Id`. Browser calls must come from the grant's approved app origin.
+Its JSON body uses `path`, `method`, optional `connection_id`, and optional `body`.
+It requires no conversation or thread ID. Both this endpoint and agent egress
+check current grant revocation, expiry, approved service, and exact account IDs.
+Connecting an account alone does not grant it to every app; the user must approve
+that service in the app's Connect flow. Provider tokens remain in the broker.
+ChatGPT is a model connector and has no generic HTTP endpoint here.
+
+
+### Use a provider SDK with a custom base URL
+
+Native SDKs can use normal HTTP through
+`https://nanocodex.gakonst.workers.dev/connectors/<service>/<provider-path>`.
+All 13 API capabilities share this route. Append the provider's existing path:
+
+| Connector | Example route |
+| --- | --- |
+| Spotify | `/connectors/spotify/v1/me/playlists` |
+| SoundCloud | `/connectors/soundcloud/me/playlists` |
+| Gmail | `/connectors/gmail/gmail/v1/users/me/messages` |
+| Google Drive | `/connectors/gdrive/drive/v3/files` |
+| Google Calendar | `/connectors/gcalendar/calendar/v3/calendars/primary/events` |
+| Google Tasks | `/connectors/gtasks/tasks/v1/users/@me/lists` |
+| Google Docs | `/connectors/gdocs/v1/documents/{id}` |
+| Google Sheets | `/connectors/gsheets/v4/spreadsheets/{id}` |
+| Google Slides | `/connectors/gslides/v1/presentations/{id}` |
+| Google Contacts | `/connectors/gcontacts/v1/people/me/connections?personFields=names` |
+| GitHub | `/connectors/github/user` |
+| Slack | `/connectors/slack/api/auth.test` |
+| X | `/connectors/x/2/users/me` |
+
+Provider path restrictions and upstream OAuth permissions still apply. Google
+services are individually opted in even though they share a Google login.
+ChatGPT and remote MCP connections use their existing separate protocols.
+The same routes are available on the configured Connect API origin.
+
+Send the app's **Nanocodex Connect grant token** as the bearer token. Native
+requests need no extra app identity headers: the token identifies its approved
+app and user. SDK routes also accept `Authorization: OAuth <grant-token>`
+(SoundCloud) and `Authorization: token <grant-token>` (GitHub). Tokens must stay in
+headers, not query parameters. Browser Origins and any explicit app ID must match that grant.
+The grant must already include the requested service; this route cannot connect
+accounts or enlarge the grant. If multiple accounts were approved, set
+`X-Nanocodex-Connector-Connection` to the selected approved connection ID.
+
+For example, with [Spotipy](https://github.com/spotipy-dev/spotipy):
+
+```python
+import spotipy
+
+spotify = spotipy.Spotify(auth=nanocodex_grant_token, retries=0, status_retries=0)
+spotify.prefix = "https://nanocodex.gakonst.workers.dev/connectors/spotify/v1/"
+page = spotify.current_user_playlists(limit=20)
+next_page = spotify.next(page)
+```
+
+For Gmail with Google's [Python API client](https://github.com/googleapis/google-api-python-client):
+
+```python
+from google.oauth2.credentials import Credentials
+from googleapiclient.discovery import build
+
+gmail = build(
+    "gmail", "v1",
+    credentials=Credentials(token=nanocodex_grant_token),
+    client_options={
+        "api_endpoint": "https://nanocodex.gakonst.workers.dev/connectors/gmail/",
+    },
+    cache_discovery=False,
+)
+messages = gmail.users().messages().list(userId="me").execute(num_retries=0)
+```
+
+Use `userId="me"`; Gmail routes are restricted to the connected user. These
+credentials hold only the Connect grant; renew an expired grant through Nanocodex
+Connect instead of asking the provider SDK to refresh it with Google or Spotify.
+SoundCloud clients use `/connectors/soundcloud/` as their base URL and the same
+Connect grant, using [SoundCloud's OAuth header format](https://developers.soundcloud.com/docs).
+
+The proxy preserves request methods, query parameters, and body bytes. Provider
+status codes, JSON errors, rate-limit headers, and non-JSON bodies are preserved.
+API links in JSON, pagination Link headers, and same-provider redirects are
+rewritten through the proxy; artwork and public share URLs stay unchanged.
+Cross-provider redirects are rejected. JSON link rewriting is bounded to 16 MiB
+per response; use provider pagination for larger collections. Spotify GETs share
+one-second read results and the broker's registration-wide rate-limit cooldown.
+The broker retries a rate-limited Spotify GET at most twice within a ten-second
+cooldown-wait budget; longer limits return 429 with the remaining `Retry-After`.
+No writes are automatically retried. Disable SDK write retries to avoid repeating
+a successful write after an ambiguous network failure.
+
+See the runnable [Python example](../../examples/python/spotify_proxy.py).
+The integration test uses real Spotipy 2.26.0 and google-api-python-client 2.192.0
+against the Connect Worker with fixture provider responses, covering reads,
+writes, pagination, rate limits, and revoked grants. Worker tests cover routing
+and service denial for all 13 API connectors. SDKs that hardcode their API host need a custom transport instead of only
+a base URL setting.

package/browser/InlineAgent.mjs

@@ -77,6 +77,7 @@ export async function create(options = {}) {
     websocketWarmup,
     WebSocketImpl,
     createWebSocket,
+    createResponse,
   } = resolveResponsesTransport(transport ?? defaultHostManagedTransport());
   const subagentsEnabled = internalRuntime?.subagentsEnabled;
   if (subagentsEnabled !== undefined && typeof subagentsEnabled !== "boolean") {
@@ -109,6 +110,7 @@ export async function create(options = {}) {
   const host = createBrowserHost({
     WebSocketImpl,
     createWebSocket,
+    createResponse,
     hostAuth: hostAuth === true
       || (apiKey === undefined && mpp === undefined && subscription === undefined),
     hostManagedProtocol,

package/browser/Transport.d.mts

@@ -4,6 +4,7 @@ import type {
 } from "../types.mjs";
 import type { Options as ManagedClientOptions } from "../managed/Agent.mjs";
 import type {
+  BrowserHttpRequest,
   BrowserWebSocketConnection,
   BrowserWebSocketRequest,
 } from "./host.mjs";
@@ -34,9 +35,11 @@ type SharedEndpointOptions = Readonly<{
 type WorkerEndpointOptions = SharedEndpointOptions & Readonly<{
   WebSocketImpl?: never;
   createWebSocket?: never;
+  createResponse?: never;
 }>;
 
 type EndpointOptions = SharedEndpointOptions & Readonly<{
+  createResponse?(endpoint: string, sessionId: string, request: BrowserHttpRequest): Promise<Response>;
   WebSocketImpl?: typeof WebSocket | undefined;
   createWebSocket?(
     endpoint: string,

package/browser/Transport.mjs

@@ -54,6 +54,7 @@ function connection(options = {}) {
     WebSocketImpl: options.WebSocketImpl,
     apiBaseUrl: options.apiBaseUrl,
     createWebSocket: options.createWebSocket,
+    createResponse: options.createResponse,
     websocketUrl: options.websocketUrl,
     websocketPreconnect: options.websocketPreconnect,
     websocketWarmup: options.websocketWarmup,

package/browser/Voice.d.mts

@@ -34,6 +34,7 @@ export type Snapshot = Readonly<{
   microphoneLevel: number;
   speakerLevel: number;
   error: Error | undefined;
+  /** Active means media and live control are ready; task admission may still be pending. */
   status: "idle" | "connecting" | "active" | "error";
   statusText: string | undefined;
   /** Latest 200 rows, retained across stop/start. Subscribe to events for longer history. */
@@ -78,6 +79,7 @@ export type Voice = Readonly<{
   destroy(): Promise<void>;
   getSnapshot(): Snapshot;
   onEvent(listener: (event: Event) => void): () => void;
+  /** Resolves after media and task admission are ready. The active snapshot may arrive first. */
   start(options?: Settings): Promise<void>;
   stop(): Promise<void>;
   subscribe(listener: () => void): () => void;

package/browser/Voice.mjs

@@ -114,6 +114,13 @@ export function create(agent, options = {}) {
       : createBrowserVoice(agent, selectedVoice));
     const transport = managedTransport;
     let transcriptSequence = 0;
+    let publishedReady = false;
+    const publishReady = () => {
+      if (publishedReady || destroyed || session !== next || generation !== current) return;
+      publishedReady = true;
+      publish({ ...snapshot, error: undefined, status: "active", statusText: `Voice active (${selectedVoice})` });
+      emit(Object.freeze({ type: "started", voice: selectedVoice }));
+    };
     const next = new BrowserVoiceSession({
       core,
       sessionId,
@@ -122,9 +129,10 @@ export function create(agent, options = {}) {
       ...(transport?.call === undefined ? {} : { call: transport.call }),
       ...(transport?.sidebandUrl === undefined ? {} : { sidebandUrl: transport.sidebandUrl }),
       ...(options.callUrl === undefined ? {} : { callUrl: options.callUrl }),
-      ...(options.sidebandUrl === undefined ? {} : { sidebandUrl: options.sidebandUrl }),
+      ...(options.sidebandUrl === undefined ? {} : { sidebandUrl: options.sidebandUrl, dataChannelControl: false }),
       ...(options.captureMicrophone === undefined ? {} : { captureMicrophone: options.captureMicrophone }),
       ...(options.beforeAgentTurn === undefined ? {} : { beforeAgentTurn: options.beforeAgentTurn }),
+      onReady: publishReady,
       onStatus(text) {
         if (session === next && generation === current && snapshot.status !== "idle" && snapshot.status !== "error") {
           publish({ ...snapshot, statusText: text });
@@ -175,11 +183,9 @@ export function create(agent, options = {}) {
     session = next;
     next.setMuted(snapshot.muted);
     observeAgentEvents(next);
-    startPromise = next.start().then(() => {
-      if (destroyed || session !== next || generation !== current) return;
-      publish({ ...snapshot, error: undefined, status: "active", statusText: `Voice active (${selectedVoice})` });
-      emit(Object.freeze({ type: "started", voice: selectedVoice }));
-    }).catch(async (cause) => {
+    // Media readiness updates the UI independently; start still waits for task
+    // admission, and a later rejection closes media through the same error path.
+    startPromise = next.start().then(publishReady).catch(async (cause) => {
       if (session === next) session = undefined;
       if (activeResources.get(agent) === resource) activeResources.delete(agent);
       cleanupWatcher();

package/browser/VoiceSession.mjs

@@ -76,6 +76,7 @@ export class BrowserVoiceSession {
   #admission;
   #peer;
   #channel;
+  #directControl = false;
   #sideband;
   #sidebandUrl;
   #sidebandCallId;
@@ -129,14 +130,16 @@ export class BrowserVoiceSession {
     const coreReady = Promise.resolve(this.#options.core).then(async (core) => {
       if (this.#closed || this.#closing.signal.aborted) { core.free(); return; }
       this.#core = core;
+      this.#directControl = core.dataChannelControl === true && this.#options.dataChannelControl !== false;
       if (this.#options.settings) await core.configure(JSON.stringify(this.#options.settings));
-      await this.#options.beforeAgentTurn?.();
+      if (!this.#directControl) await this.#options.beforeAgentTurn?.();
       if (this.#closed || this.#closing.signal.aborted) return;
       return core;
     });
-    // Managed Rust can deliver authoritative context after SDP negotiation.
-    // Start both immediately, but fence incoming control events on admission.
+    // Media and live conversation do not depend on durable task admission.
+    // Only delegated work waits for admission on the direct control path.
     const coreStartup = coreReady.then(async (core) => {
+      if (this.#directControl) await this.#options.beforeAgentTurn?.();
       await core?.start();
       return core;
     });
@@ -203,7 +206,7 @@ export class BrowserVoiceSession {
     const completed = JSON.parse(await core.completeCall(callResponse.body, callResponse.location));
     if (this.#closed || peer.signalingState === "closed") return;
     this.#sidebandCallId = completed.call_id;
-    this.#sidebandUrl = this.#options.sidebandUrl
+    this.#sidebandUrl = this.#directControl || this.#options.sidebandUrl
       ? undefined
       : String(await core.sidebandUrl(completed.call_id));
     if (this.#closed) return;
@@ -215,7 +218,7 @@ export class BrowserVoiceSession {
         }, { signal: this.#closing.signal, timeoutMs: PEER_CONNECTION_TIMEOUT_MS,
           timeoutError: new VoiceError("peer_connection_timeout", "Voice media did not connect in time."),
           onTimeout: () => { peer.close(); } }),
-        this.#openSideband().then(() => withStartupDeadline(() => this.#backendReady, { signal: this.#closing.signal,
+        (this.#directControl ? this.#openDataChannel() : this.#openSideband()).then(() => withStartupDeadline(() => this.#backendReady, { signal: this.#closing.signal,
           timeoutMs: SIDEBAND_OPEN_TIMEOUT_MS,
           timeoutError: new VoiceError("session_ready_timeout", "The Realtime session did not become ready in time.") })),
       ]);
@@ -227,6 +230,7 @@ export class BrowserVoiceSession {
     if (this.#closed) return;
     this.#sampleLevels();
     this.#status(`Voice active (${this.#options.voice})`);
+    this.#options.onReady?.();
   }
 
   async #prepareMedia(capture) {
@@ -249,6 +253,17 @@ export class BrowserVoiceSession {
     this.#peer = peer;
     for (const track of microphone.getAudioTracks()) peer.addTrack(track, microphone);
     this.#channel = peer.createDataChannel("oai-events");
+    const channel = this.#channel;
+    channel.addEventListener("message", (event) => {
+      if (this.#directControl && !this.#closed && this.#channel === channel) {
+        this.#receiveControl(event.data, () => this.#channel === channel);
+      }
+    });
+    channel.addEventListener("close", () => {
+      if (this.#directControl && !this.#closed && !this.#closing.signal.aborted && this.#channel === channel) {
+        this.#options.onTerminated("Voice control connection closed — tap Voice to reconnect");
+      }
+    });
     peer.addEventListener("track", (event) => {
       if (this.#closed || this.#closing.signal.aborted || this.#peer !== peer) {
         event.track.stop();
@@ -410,7 +425,10 @@ export class BrowserVoiceSession {
     }
     let sent = 0;
     for (const frame of effects.frames ?? []) {
-      if (this.#sideband?.readyState === WebSocket.OPEN) {
+      if (this.#directControl && this.#channel?.readyState === "open") {
+        this.#channel.send(frame);
+        sent += 1;
+      } else if (!this.#directControl && this.#sideband?.readyState === WebSocket.OPEN) {
         this.#sideband.send(frame);
         sent += 1;
       }
@@ -457,20 +475,7 @@ export class BrowserVoiceSession {
     let opened = false;
     sideband.addEventListener("message", (event) => {
       if (!this.#closed && generation === this.#sidebandGeneration) {
-        this.#applyLive(async () => {
-          await this.#admission;
-          if (this.#closed || generation !== this.#sidebandGeneration) return;
-          if (await this.#core.requiresAgentAdmission(event.data)) {
-            // Only delegations wait for durable admission. Speech deltas and
-            // agent output must continue while that independent request waits.
-            void this.#enqueue(async () => {
-              await this.#options.beforeAgentTurn?.();
-              return this.#core.realtimeMessage(event.data);
-            }, true).catch(() => {});
-            return;
-          }
-          return this.#core.realtimeMessage(event.data);
-        });
+        this.#receiveControl(event.data, () => generation === this.#sidebandGeneration);
       }
     });
     sideband.addEventListener("close", () => {
@@ -492,6 +497,46 @@ export class BrowserVoiceSession {
     }
   }
 
+  #receiveControl(payload, isCurrent) {
+    this.#applyLive(async () => {
+      if (!this.#directControl) await this.#admission;
+      if (this.#closed || !isCurrent()) return;
+      if (await this.#core.requiresAgentAdmission(payload)) {
+        // Retain accepted requests on close, but keep captions and interruptions
+        // independent of the durable route and its ordered task queue.
+        void this.#enqueue(async () => {
+          await this.#admission;
+          await this.#options.beforeAgentTurn?.();
+          return this.#core.realtimeMessage(payload);
+        }, true).catch(() => {});
+        return;
+      }
+      return this.#core.realtimeMessage(payload);
+    });
+  }
+
+  async #openDataChannel() {
+    const channel = this.#channel;
+    await withStartupDeadline(() => new Promise((resolve, reject) => {
+      const cleanup = () => {
+        channel.removeEventListener("open", opened);
+        channel.removeEventListener("close", closed);
+        this.#closing.signal.removeEventListener("abort", closed);
+      };
+      const opened = () => { cleanup(); resolve(); };
+      const closed = () => { cleanup(); reject(new Error("voice data channel closed before opening")); };
+      channel.addEventListener("open", opened);
+      channel.addEventListener("close", closed);
+      this.#closing.signal.addEventListener("abort", closed, { once: true });
+      if (channel.readyState === "open") opened();
+      else if (channel.readyState === "closed" || this.#closing.signal.aborted) closed();
+    }), {
+      signal: this.#closing.signal, timeoutMs: SIDEBAND_OPEN_TIMEOUT_MS,
+      timeoutError: new VoiceError("data_channel_open_timeout", "The Realtime voice data channel did not open in time."),
+    });
+    if (!this.#closed && this.#channel === channel) await this.#applyLive(() => this.#core.sidebandOpened());
+  }
+
   #status(message) {
     if (!this.#closed) this.#options.onStatus(message);
   }
@@ -512,8 +557,13 @@ export class BrowserVoiceSession {
     this.#flushTimer = undefined;
     if (this.#reconnectTimer !== undefined) window.clearTimeout(this.#reconnectTimer);
     this.#reconnectTimer = undefined;
-    this.#channel?.close();
+    // Match native close: release provider media before durable tail cleanup.
+    if (this.#directControl && this.#channel?.readyState === "open") {
+      try { this.#channel.send('{"type":"session.close"}'); } catch {}
+    }
+    const channel = this.#channel;
     this.#channel = undefined;
+    channel?.close();
     this.#peer?.close();
     this.#peer = undefined;
     stopStream(this.#microphone);

package/browser/WorkerAgent.mjs

@@ -1317,7 +1317,8 @@ function serializeConfig(options) {
       ...connection
     } = setup;
     if (hostAuth === true) {
-      if (typeof connection.createWebSocket === "function"
+      if (typeof connection.createResponse === "function"
+        || typeof connection.createWebSocket === "function"
         || typeof connection.WebSocketImpl === "function") {
         throw new TypeError("Worker Agent host-managed transport callbacks must live inside a custom Worker");
       }

package/browser/host.d.mts

@@ -41,6 +41,12 @@ export type BrowserWebSocketRequest = BrowserWebSocketMetadata & (
     }
 );
 
+/** One streaming HTTPS Responses request. The host must preserve cancellation. */
+export type BrowserHttpRequest = Exclude<BrowserWebSocketRequest, { authorization: "preconnect" }> & {
+  body: string;
+  signal: AbortSignal;
+};
+
 export type BrowserWebSocketConnection = {
   socket: WebSocket;
   status?: number | undefined;
@@ -59,6 +65,7 @@ export function createBrowserHost(options?: {
     sessionId: string,
     request: BrowserWebSocketRequest,
   ) => WebSocket | BrowserWebSocketConnection | Promise<WebSocket | BrowserWebSocketConnection>;
+  createResponse?: (endpoint: string, sessionId: string, request: BrowserHttpRequest) => Promise<Response>;
   filesystem?: Workspace;
   filesystemTools?: boolean;
   onEvent?: (eventJson: string) => void;

package/browser/host.mjs

@@ -1,3 +1,4 @@
+import { createResponsesHttp, responsesHttpHeaders } from "../runtime/responses-http.mjs";
 import { createCodeRuntime, toolResult } from "../runtime/code-runtime.mjs";
 import {
   toolRouterBrand,
@@ -45,6 +46,19 @@ export function createBrowserHost(options = {}) {
   if (!options.mpp && !createWebSocket) {
     throw new Error("WebSocket is unavailable in this runtime");
   }
+  const http = createResponsesHttp((endpoint, apiKey, sessionId, metadata, body, signal) => {
+    if (disposal) throw new Error("Nanocodex host is already disposed");
+    if (options.mpp) throw JSON.stringify({ kind: "transport", detail: "MPP HTTPS transport is unavailable", reconnectable: false });
+    if (options.createResponse) {
+      const authorization = options.hostAuth
+        ? { authorization: "host_managed" }
+        : { authorization: "bearer", bearerToken: apiKey };
+      return options.createResponse(endpoint, sessionId, { ...metadata, ...authorization, body, signal });
+    }
+    if (options.hostAuth) throw JSON.stringify({ kind: "transport", detail: "host-managed HTTPS requires createResponse", reconnectable: false });
+    return fetch(endpoint, { method: "POST", headers: responsesHttpHeaders(apiKey, sessionId, metadata),
+      body, signal, redirect: "error" });
+  });
   const connections = new Map();
   const openingAttempts = new Set();
   const connectingConnections = new Set();
@@ -375,6 +389,7 @@ export function createBrowserHost(options = {}) {
 
   function dispose() {
     if (disposal) return disposal;
+    http.dispose();
     disposalError = new Error("Nanocodex host was disposed during WebSocket connection");
     disposal = Promise.resolve().then(async () => {
       const cleanups = [];
@@ -480,6 +495,10 @@ export function createBrowserHost(options = {}) {
       if (references > 0) references -= 1;
       return references === 0 ? dispose() : Promise.resolve();
     },
+    httpOpen: http.httpOpen,
+    httpReady: http.httpReady,
+    httpNext: http.httpNext,
+    httpClose: http.httpClose,
     connect,
     preconnect,
     send,

package/cloud/Decorator.d.mts

@@ -1,5 +1,6 @@
 import type { logout } from "./actions/account.mjs";
 import type { create as createAgent } from "./actions/agent.mjs";
+import type { request as connectorRequest } from "./actions/connector.mjs";
 import type { connect, disconnect, reconnect } from "./actions/connection.mjs";
 import type { revoke } from "./actions/grant.mjs";
 import type { fund, getConfig } from "./actions/machineUsd.mjs";
@@ -11,6 +12,14 @@ import type { Connection, HostConnection } from "./types.mjs";
 export type ConnectActions<connection extends Connection | HostConnection = Connection> = {
   account: { logout(): logout.ReturnType };
   agent: { create(options: createAgent.Options): Promise<createAgent.ReturnType> };
+  connector: { request(options: connectorRequest.Options): connectorRequest.ReturnType };
+  connectors: {
+    request(options: connectorRequest.Options): connectorRequest.ReturnType;
+  } & {
+    readonly [service in connectorRequest.Options["connector"]]: {
+      request(options: Omit<connectorRequest.Options, "connector">): connectorRequest.ReturnType;
+    };
+  };
   connection: {
     connect(options: connect.Options): Promise<connection>;
     disconnect(options?: disconnect.Options | undefined): disconnect.ReturnType;

package/cloud/Decorator.mjs

@@ -1,5 +1,7 @@
+import { API_CONNECTORS } from "./internal.mjs";
 import * as account from "./actions/account.mjs";
 import * as agent from "./actions/agent.mjs";
+import * as connector from "./actions/connector.mjs";
 import * as connection from "./actions/connection.mjs";
 import * as grant from "./actions/grant.mjs";
 import * as machineUsd from "./actions/machineUsd.mjs";
@@ -14,6 +16,13 @@ export function connectActions() {
     agent: {
       create: (options) => agent.create(client, options),
     },
+    connector: { request: (options) => connector.request(client, options) },
+    connectors: {
+      request: (options) => connector.request(client, options),
+      ...Object.fromEntries(API_CONNECTORS.map(service => [service, {
+        request: (options) => connector.request(client, { ...options, connector: service }),
+      }])),
+    },
     connection: {
       connect: (options) => connection.connect(client, options),
       disconnect: (options) => connection.disconnect(client, options),

package/cloud/Transport.mjs

@@ -376,6 +376,9 @@ function requestedConnectors(value) {
     "gcontacts",
     "slack",
     "x",
+    "spotify",
+    "soundcloud",
+  "link",
     "chatgpt",
   ];
   if (value.some((provider) => !supported.includes(provider))) {
@@ -413,6 +416,9 @@ function connectorName(provider) {
     gcontacts: "Google Contacts",
     slack: "Slack",
     x: "X",
+    spotify: "Spotify",
+    soundcloud: "SoundCloud",
+  link: "Stripe Link",
     chatgpt: "ChatGPT",
   })[provider];
 }

package/cloud/actions/connection.mjs

@@ -22,6 +22,9 @@ const CLOUD_ACCOUNT_PROVIDERS = Object.freeze([
   "gcontacts",
   "slack",
   "x",
+  "spotify",
+  "soundcloud",
+  "link",
   "chatgpt",
 ]);
 const CONNECTOR_RESOURCE_PREFIX = "urn:nanocodex:connector:";

package/cloud/actions/connector.d.mts

@@ -0,0 +1,18 @@
+import type { Client } from "../Client.mjs";
+import type { CloudAccount } from "../types.mjs";
+
+export declare namespace request {
+  type Options = Readonly<{
+    connector: Exclude<CloudAccount, "chatgpt">;
+    path: string;
+    method?: "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | undefined;
+    /** Required when the grant includes more than one account for this service. */
+    connectionId?: string | undefined;
+    body?: Record<string, unknown> | undefined;
+    signal?: AbortSignal | undefined;
+  }>;
+  type ReturnType = Promise<Response>;
+}
+
+/** Returns the provider response (including HTTP failures). Never retries writes. */
+export function request(client: Client, options: request.Options): request.ReturnType;