nanocodex 0.6.0 → 0.6.4

package/cloud/actions/connector.mjs

@@ -0,0 +1,22 @@
+import { API_CONNECTORS } from "../internal.mjs";
+
+const SERVICES = new Set(API_CONNECTORS);
+
+/** Calls an opted-in service using the current app grant, without an agent turn. */
+export async function request(client, options) {
+  if (!SERVICES.has(options?.connector)) throw new TypeError("Unknown connector API");
+  if (typeof options.path !== "string" || !options.path.startsWith("/") || options.path.startsWith("//")) {
+    throw new TypeError("Connector requests require a provider-relative path");
+  }
+  return client.fetch(`/v1/connectors/${options.connector}/request`, {
+    method: "POST",
+    headers: { "content-type": "application/json", origin: client.appOrigin },
+    body: JSON.stringify({
+      path: options.path,
+      method: options.method ?? "GET",
+      ...(options.connectionId === undefined ? {} : { connection_id: options.connectionId }),
+      ...(options.body === undefined ? {} : { body: options.body }),
+    }),
+    signal: options.signal,
+  });
+}

package/cloud/actions/index.d.mts

@@ -1,5 +1,7 @@
 export * as account from "./account.mjs";
 export * as agent from "./agent.mjs";
+export * as connector from "./connector.mjs";
+export * as connectors from "./connector.mjs";
 export * as connection from "./connection.mjs";
 export * as grant from "./grant.mjs";
 export * as machineUsd from "./machineUsd.mjs";

package/cloud/actions/index.mjs

@@ -1,5 +1,7 @@
 export * as account from "./account.mjs";
 export * as agent from "./agent.mjs";
+export * as connector from "./connector.mjs";
+export * as connectors from "./connector.mjs";
 export * as connection from "./connection.mjs";
 export * as grant from "./grant.mjs";
 export * as machineUsd from "./machineUsd.mjs";

package/cloud/internal.mjs

@@ -12,8 +12,13 @@ const CLOUD_ACCOUNT_PROVIDERS = Object.freeze([
   "gcontacts",
   "slack",
   "x",
+  "spotify",
+  "soundcloud",
+  "link",
   "chatgpt",
 ]);
+export const API_CONNECTORS = Object.freeze(CLOUD_ACCOUNT_PROVIDERS.filter(provider => provider !== "chatgpt"));
+
 const MCP_CONNECTION_ID = /^[A-Za-z0-9_-]{43}$/;
 const AGENT_CONVERSATION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 const CATALOG_DIGEST = /^0x[0-9a-f]{64}$/;

package/cloud/types.d.mts

@@ -12,6 +12,8 @@ export type CloudAccount =
   | "gcontacts"
   | "slack"
   | "x"
+  | "spotify"
+  | "soundcloud" | "link"
   | "chatgpt";
 
 /** Secret-free account identity returned by a connector status reader. */

package/cloudflare/Agent.mjs

@@ -1,4 +1,4 @@
-import { responseControlsSocket } from "../runtime/response-controls.mjs";
+import { responseControlsBody, responseControlsSocket } from "../runtime/response-controls.mjs";
 import * as HostAgent from "../host/Agent.mjs";
 import {
   CLOUDFLARE_SESSION_RESERVATION,
@@ -316,6 +316,12 @@ async function createOwned(module, resolved, options, hostAgent, lifecycle) {
   const transport = Transport.hostManaged({
     ...endpoint,
     websocketPreconnect: true,
+    createResponse(url, id, request) {
+      return endpoint.createResponse(url, id, {
+        ...request,
+        body: responseControlsBody(request.body, internalRuntime?.responseControls),
+      });
+    },
     async createWebSocket(url, id, request) {
       try {
         const opened = await endpoint.createWebSocket(url, id, request);

package/cloudflare/egress.d.mts

@@ -1,4 +1,5 @@
 import type {
+  BrowserHttpRequest,
   BrowserWebSocketConnection,
   BrowserWebSocketRequest,
 } from "../browser/host.mjs";
@@ -23,6 +24,7 @@ export type CloudflareEgressOptions = Readonly<{
 export type CloudflareEgressTransportOptions = Readonly<{
   apiBaseUrl: string;
   websocketUrl: string;
+  createResponse(endpoint: string, sessionId: string, request: BrowserHttpRequest): Promise<Response>;
   createWebSocket(
     endpoint: string,
     sessionId: string,
@@ -31,7 +33,7 @@ export type CloudflareEgressTransportOptions = Readonly<{
 }>;
 
 /**
- * Creates the brokered WebSocket seam for a managed Cloudflare Worker.
+ * Creates the brokered WebSocket and streaming HTTPS seams for a managed Cloudflare Worker.
  *
  * The managed Worker supplies only fixed placeholders to `binding`; the
  * separately deployed broker owns and injects the real provider credential.

package/cloudflare/egress.mjs

@@ -1,3 +1,4 @@
+import { responsesHttpHeaders } from "../runtime/responses-http.mjs";
 import { cloudflareEgressSubject } from "./egress-subject.mjs";
 
 const OPENAI_WEBSOCKET_BETA = "responses_websockets=2026-02-06";
@@ -14,6 +15,19 @@ export function cloudflareEgress(options) {
   return Object.freeze({
     apiBaseUrl: BROKER_API_BASE_URL,
     websocketUrl: BROKER_WEBSOCKET_URL,
+    async createResponse(endpoint, sessionId, request) {
+      if (request?.authorization !== "host_managed") {
+        throw new Error("Cloudflare EGRESS requires Transport.hostManaged authorization");
+      }
+      const url = exactWebSocketEndpoint(endpoint, BROKER_WEBSOCKET_URL);
+      const headers = responsesHttpHeaders("NANOCODEX_PROVIDER_CREDENTIAL", sessionId, {
+        threadId: request.threadId, turnState: request.turnState,
+      });
+      const subject = cloudflareEgressSubject(binding);
+      if (subject !== undefined) headers.set("x-nanocodex-subject", subject);
+      return binding.fetch(url, { method: "POST", headers, body: request.body,
+        signal: request.signal, redirect: "manual" });
+    },
     createWebSocket: (endpoint, sessionId, request) =>
       openBrokeredWebSocket(binding, endpoint, sessionId, request),
   });

package/cloudflare/managed-access.d.mts

@@ -0,0 +1,23 @@
+/** Credential-bound authority reused for at most 120 seconds; live renewal is separate. */
+export type ManagedAccessPrincipal = Readonly<{
+  kind: "account_session" | "api_key" | "connect_grant" | "service";
+  userId: string;
+  organizationId: string;
+  teamId: string;
+  authorizationEpoch: number;
+  capabilities: readonly string[];
+  connectGrant?: unknown;
+}>;
+export type ManagedAccessEnv = { NANOCODEX_ACCESS_SECRET?: string; DEPLOYMENT_SHA?: string };
+export type ManagedAccessClaims<P extends ManagedAccessPrincipal = ManagedAccessPrincipal> = {
+  version: 1; audience: string; binding: string; issuedAt: number; expiresAt: number; principal: P;
+};
+export const MANAGED_ACCESS_HEADER: "x-nanocodex-access";
+export const MANAGED_ACCESS_TTL_MS: 120000;
+export function managedAccessRequest(request: Request): boolean;
+export function readManagedAccess<P extends ManagedAccessPrincipal = ManagedAccessPrincipal>(request: Request, env: ManagedAccessEnv, now?: number): Promise<P | undefined>;
+export function createManagedAccessClaims<P extends ManagedAccessPrincipal>(request: Request, principal: P, now?: number): Promise<ManagedAccessClaims<P>>;
+export function signManagedAccessClaims(claims: ManagedAccessClaims, env: ManagedAccessEnv): Promise<string>;
+export function isHandViewerUpgrade(request: Request): boolean;
+export function handRequestFailure(request: Request, principal: ManagedAccessPrincipal): "forbidden" | "forbidden_origin" | undefined;
+export function handBrokerRequest(request: Request, principal: ManagedAccessPrincipal): Request;

package/cloudflare/managed-access.mjs

@@ -0,0 +1,120 @@
+export const MANAGED_ACCESS_HEADER = "x-nanocodex-access";
+export const MANAGED_ACCESS_TTL_MS = 120_000;
+const encoder = new TextEncoder();
+let cachedKey;
+
+/** Finite agent operations and screen viewer admission. Publishers, renewal and
+ * agent streams retain live authentication; a viewer renews live every 10 s. */
+export function managedAccessRequest(request) {
+  const path = new URL(request.url).pathname;
+  if (path === "/v1/account/hands/view") {
+    return request.method === "GET" && request.headers.get("upgrade")?.toLowerCase() === "websocket";
+  }
+  if (path === "/v1/account/hands/screens" || path === "/v1/account/hands/ice") {
+    return request.method === (path.endsWith("/screens") ? "GET" : "POST")
+      && !request.headers.has("upgrade");
+  }
+  return /^\/v1\/agents(?:\/|$)/.test(path)
+    && !request.headers.has("upgrade")
+    && !request.headers.get("accept")?.includes("text/event-stream")
+    && !/\/(?:ws|events|tool-host|device-host|sideband)$/.test(path);
+}
+
+function key(secret) {
+  if (secret.length < 32) throw new Error("managed_access_not_configured");
+  if (cachedKey?.secret !== secret) cachedKey = { secret, promise: crypto.subtle.importKey(
+    "raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign", "verify"],
+  ) };
+  return cachedKey.promise;
+}
+function encode(bytes) {
+  return btoa(String.fromCharCode(...bytes)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function decode(value) {
+  if (!/^[A-Za-z0-9_-]+$/.test(value)) throw new Error("invalid_managed_access");
+  return Uint8Array.from(atob(value.replaceAll("-", "+").replaceAll("_", "/")), c => c.charCodeAt(0));
+}
+
+/** Bind reuse to the original login/key/grant, including all Connect restrictions. */
+async function credentialBinding(request, kind) {
+  const url = new URL(request.url);
+  const connect = kind === "connect_grant" && url.origin === "https://nanocodex.internal" && request.headers.has("x-nanocodex-connect-user");
+  // Match the live authenticator's first-cookie and whitespace semantics.
+  let cookie;
+  for (const part of request.headers.get("cookie")?.split(";") ?? []) {
+    const separator = part.indexOf("=");
+    if (separator >= 0 && part.slice(0, separator).trim() === "nanocodex_account") {
+      cookie = part.slice(separator + 1).trim();
+      break;
+    }
+  }
+  const authorization = request.headers.get("authorization");
+  if (!(connect || (kind === "account_session" && cookie) || (kind === "api_key" && authorization))) throw new Error("managed_access_requires_session");
+  // Include every authority input so adding a cookie/Connect restriction cannot
+  // make a cached API-key principal override the live authenticator's precedence.
+  const identity = JSON.stringify({ kind, authorization, cookie: cookie ?? null,
+    connect: [...request.headers].filter(([name]) => name.startsWith("x-nanocodex-connect-")).sort() });
+  return encode(new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(identity))));
+}
+
+export async function readManagedAccess(request, env, now = Date.now()) {
+  try {
+    if (!managedAccessRequest(request)) return;
+    const token = request.headers.get(MANAGED_ACCESS_HEADER);
+    if (!token || token.length > 16_384) return;
+    const [prefix, payload, signature, extra] = token.split(".");
+    if (prefix !== "ncx_access_v1" || !payload || !signature || extra !== undefined) return;
+    if (!await crypto.subtle.verify("HMAC", await key(env.NANOCODEX_ACCESS_SECRET ?? ""), decode(signature), encoder.encode(`${prefix}.${payload}`))) return;
+    const value = JSON.parse(new TextDecoder().decode(decode(payload)));
+    if (value.version !== 1 || value.audience !== new URL(request.url).origin
+      || !Number.isSafeInteger(value.issuedAt) || !Number.isSafeInteger(value.expiresAt)
+      || value.issuedAt > now || value.expiresAt <= now || value.expiresAt <= value.issuedAt
+      || value.expiresAt - value.issuedAt > MANAGED_ACCESS_TTL_MS
+      || !value.principal || !["account_session", "api_key", "connect_grant"].includes(value.principal.kind)
+      || value.binding !== await credentialBinding(request, value.principal.kind)) return;
+    return value.principal;
+  } catch { return; }
+}
+
+/** Shared issuance keeps the exact audience, credential binding and lifetime wire contract. */
+export async function createManagedAccessClaims(request, principal, now = Date.now()) {
+  return { version: 1, audience: new URL(request.url).origin, binding: await credentialBinding(request, principal.kind),
+    issuedAt: now, expiresAt: now + MANAGED_ACCESS_TTL_MS, principal };
+}
+export async function signManagedAccessClaims(claims, env) {
+  const payload = `ncx_access_v1.${encode(encoder.encode(JSON.stringify(claims)))}`;
+  const signature = await crypto.subtle.sign("HMAC", await key(env.NANOCODEX_ACCESS_SECRET ?? ""), encoder.encode(payload));
+  return `${payload}.${encode(new Uint8Array(signature))}`;
+}
+
+export function isHandViewerUpgrade(request) {
+  return request.method === "GET" && new URL(request.url).pathname === "/v1/account/hands/view"
+    && request.headers.get("upgrade")?.toLowerCase() === "websocket";
+}
+
+/** Shared account Hand policy, applied after live or signed-snapshot authentication. */
+export function handRequestFailure(request, principal) {
+  const url = new URL(request.url);
+  if (principal.connectGrant || !principal.capabilities.includes("agents:read")
+    || !principal.capabilities.includes("tools:use")
+    || (url.pathname.endsWith("/host") && !principal.capabilities.includes("agents:write"))) return "forbidden";
+  if (principal.kind !== "api_key" && (request.method !== "GET" || request.headers.has("upgrade"))
+    && request.headers.get("origin") !== url.origin) return "forbidden_origin";
+}
+
+/** Only for an authenticated principal that passed handRequestFailure. */
+export function handBrokerRequest(request, principal) {
+  const url = new URL(request.url);
+  const headers = new Headers(request.headers);
+  headers.delete("x-nanocodex-remote-vm");
+  headers.set("x-nanocodex-owner-id", principal.userId);
+  headers.set("x-nanocodex-session-organization-id", principal.organizationId);
+  headers.set("x-nanocodex-session-team-id", principal.teamId);
+  headers.set("x-nanocodex-authorization-epoch", String(principal.authorizationEpoch));
+  headers.set("x-nanocodex-capabilities", JSON.stringify(principal.capabilities));
+  for (const name of ["x-nanocodex-connect-user", "x-nanocodex-connect-grant-id", "x-nanocodex-connect-capabilities",
+    "x-nanocodex-connect-connectors", "x-nanocodex-connect-connector-connections", "x-nanocodex-connect-mcp-ids",
+    "x-nanocodex-connect-app-tool-catalog-digest"]) headers.delete(name);
+  return new Request(`https://account-tools.internal${url.pathname.slice("/v1/account".length)}${url.search}`,
+    new Request(request, { headers }));
+}

package/internal.mjs

@@ -12,6 +12,7 @@ const activeAgentSessions = new Map();
 const pendingCloudflareAgentSessions = new Map();
 const cloudflareAgentSessions = new WeakSet();
 const hostConnections = new Map();
+const hostHttpRequests = new Map();
 const definitionHosts = new Map();
 let nextHostConnection = 1;
 let nextDefinitionHost = 1;
@@ -445,6 +446,32 @@ export function releaseDefinitionHost(id) {
 }
 
 const hostBridge = Object.freeze({
+  httpOpen(endpoint, apiKey, accountId, fedramp, sessionId, threadId, turnState, body) {
+    const host = requiredSessionHost(threadId);
+    if (typeof host.httpOpen !== "function") {
+      throw JSON.stringify({ kind: "transport", detail: "host HTTPS transport is unavailable", reconnectable: false });
+    }
+    const local = host.httpOpen(endpoint, apiKey, sessionId, { accountId, fedramp, threadId, turnState }, body);
+    const handle = nextHostConnection++;
+    hostHttpRequests.set(handle, { host, handle: local });
+    return handle;
+  },
+  async httpReady(handle) {
+    const request = hostHttpRequests.get(handle);
+    try { return await request.host.httpReady(request.handle); }
+    catch (error) { throw JSON.stringify(connectFailure(error)); }
+  },
+  async httpNext(handle) {
+    const request = hostHttpRequests.get(handle);
+    try { return await request.host.httpNext(request.handle); }
+    catch (error) { throw JSON.stringify(connectFailure(error)); }
+  },
+  httpClose(handle) {
+    const request = hostHttpRequests.get(handle);
+    if (!request) return;
+    hostHttpRequests.delete(handle);
+    request.host.httpClose(request.handle);
+  },
   async connect(endpoint, apiKey, accountId, fedramp, sessionId, threadId, turnState) {
     const host = requiredSessionHost(threadId);
     let result;

package/managed/Access.d.mts

@@ -0,0 +1,5 @@
+/** Reuses short-lived server-issued authorization for finite managed Agent HTTP requests.
+ * Retains the original credential and scopes; retries once only on explicit pre-admission rejection.
+ * Cache state is bounded, in memory, and separated by origin and credential/grant.
+ */
+export function withManagedAccess(fetch: typeof globalThis.fetch): typeof globalThis.fetch;

package/managed/Access.mjs

@@ -0,0 +1,66 @@
+const stores = new WeakMap();
+const HEADER = "x-nanocodex-access";
+
+/** Reuse finite-request authority across Agent handles for the same client identity. */
+export function managedAccessFetch(fetchImpl, origin, identity = "browser") {
+  let store = stores.get(fetchImpl);
+  if (!store) stores.set(fetchImpl, store = new Map());
+  const key = `${origin}\n${identity}`;
+  let state = store.get(key);
+  if (!state) {
+    if (store.size >= 128) store.delete(store.keys().next().value);
+    store.set(key, state = {});
+  }
+  const clock = () => performance.now();
+  function remember(response, began) {
+    const token = response.headers.get(HEADER);
+    const ttl = Number(response.headers.get("x-nanocodex-access-ttl-ms"));
+    if (response.ok && token?.startsWith("ncx_access_v1.") && token.length <= 16_384
+      && Number.isFinite(ttl) && ttl > 0 && ttl <= 120_000) {
+      const until = began + ttl;
+      if (!state.until || until > state.until) { state.token = token; state.until = until; }
+    }
+  }
+  return async (url, init = {}) => {
+    const source = url instanceof Request ? url : undefined;
+    const target = new URL(source?.url ?? url);
+    const headers = new Headers(source?.headers ?? init.headers);
+    headers.delete(HEADER);
+    const eligible = target.origin === origin && /^\/v1\/agents(?:\/|$)/.test(target.pathname)
+      && !headers.has("upgrade") && !headers.get("accept")?.includes("text/event-stream")
+      && !/\/(?:ws|events|tool-host|device-host|sideband)$/.test(target.pathname);
+    const token = eligible && state.until > clock() + 5000 ? state.token : undefined;
+    if (token) headers.set(HEADER, token);
+    const began = clock();
+    const retryRequest = source && token ? source.clone() : undefined;
+    let response;
+    try {
+      response = source ? await fetchImpl(new Request(source, { headers })) : await fetchImpl(url, { ...init, headers });
+    } catch (error) {
+      if (retryRequest?.body) void retryRequest.body.cancel().catch(() => {});
+      throw error;
+    }
+    if (token && response.status === 401 && response.headers.get("x-nanocodex-access-rejected") === "1") {
+      await response.body?.cancel();
+      if (state.token === token) { state.token = undefined; state.until = undefined; }
+      const retryHeaders = new Headers(headers);
+      retryHeaders.delete(HEADER);
+      // Rejected by ingress before admission. Preserve the exact body and idempotency key.
+      response = retryRequest ? await fetchImpl(new Request(retryRequest, { headers: retryHeaders }))
+        : await fetchImpl(url, { ...init, headers: retryHeaders });
+    }
+    if (retryRequest?.body && !retryRequest.bodyUsed) void retryRequest.body.cancel().catch(() => {});
+    remember(response, began);
+    return response;
+  };
+}
+
+/** Wrap a managed HTTP transport with bounded, credential-bound access reuse. */
+export function withManagedAccess(fetchImpl) {
+  return (input, init) => {
+    const request = new Request(input, init);
+    const identity = JSON.stringify([...request.headers].filter(([name]) =>
+      name === "authorization" || name === "cookie" || name.startsWith("x-nanocodex-connect-")).sort());
+    return managedAccessFetch(fetchImpl, new URL(request.url).origin, identity)(request);
+  };
+}

package/managed/Agent.d.mts

@@ -1,3 +1,4 @@
+import type { RequestOriginContext } from "../tools/environment.mjs";
 import type { Model, PromptInput, ReasoningMode, Thinking, TurnUsage } from "../types.mjs";
 import type { AgentId } from "../runtime/subagents.mjs";
 
@@ -106,6 +107,8 @@ export type Organization = Readonly<{
 export type OrganizationUpdate = Readonly<{ name: string | null }>;
 
 export type Options = Readonly<{
+  /** Descriptive client-reported context; never grants authority or changes execution placement. */
+  requestOrigin?: RequestOriginContext;
   /** Managed service origin. Defaults to the current browser origin. */
   baseUrl?: string | URL | undefined;
   /** Server credential. Browsers omit this and authenticate with the account cookie. */
@@ -141,6 +144,8 @@ export type Environment = Readonly<{
   network?: NetworkPolicy;
 }>;
 export type Configuration = Readonly<{
+  /** Pin this session to one connected ChatGPT account; disables automatic account failover. */
+  chatgpt_account_id?: string;
   settings?: Readonly<{ model: CreateSettings["model"]; thinking: CreateSettings["thinking"]; reasoning_mode: "standard" | "pro"; fast_mode: boolean }>;
   instructions?: string;
   tools?: readonly string[];
@@ -390,6 +395,9 @@ export type CronTrigger = Readonly<{
 }>;
 
 export type Agent = Readonly<{
+  /** Start bounded background runtime/socket preparation for an active conversation.
+   * Resolves on acceptance, not provider readiness. Never required before prompt(). */
+  prepare(options?: Readonly<{ signal?: AbortSignal }>): Promise<void>;
   requiredActions: Readonly<{
     list(): Promise<{ data: readonly Readonly<{ call_id: string; session_id: string; source_call_id: string; name: string; input: unknown; deadline_at: number }>[] }>;
     submit(callId: string, outcome: import("nanocodex-tools/hosted").HostedToolCallOutcome): Promise<void>;
@@ -443,15 +451,16 @@ export function remove(id: string, options?: Options): Promise<void>;
 export { remove as delete };
 export function findSessions(request: FindSessionsRequest, options?: Options): Promise<FindSessionsResponse>;
 export function readSession(request: ReadSessionRequest, options?: Options): Promise<ReadSessionResponse>;
+export type MemoryOptions = Options & Readonly<{ scope?: "team" | "personal" }>;
 /** List the authenticated account's hosted durable memory. */
-export function listMemories(options?: Options): Promise<readonly MemoryRecord[]>;
+export function listMemories(options?: MemoryOptions): Promise<readonly MemoryRecord[]>;
 /** Compare-and-swap delete one hosted durable memory; deleting an absent id is idempotent. */
-export function deleteMemory(key: MemoryKey, options?: Options): Promise<void>;
-export function memory(operation: MemoryScanOperation, options?: Options): Promise<MemoryScanResult>;
-export function memory(operation: MemoryReadOperation, options?: Options): Promise<MemoryReadResult>;
-export function memory(operation: MemoryPutOperation, options?: Options): Promise<MemoryPutResult>;
-export function memory(operation: MemoryDeleteOperation, options?: Options): Promise<MemoryDeleteResult>;
-export function memory(operation: MemoryOperation, options?: Options): Promise<MemoryResult>;
+export function deleteMemory(key: MemoryKey, options?: MemoryOptions): Promise<void>;
+export function memory(operation: MemoryScanOperation, options?: MemoryOptions): Promise<MemoryScanResult>;
+export function memory(operation: MemoryReadOperation, options?: MemoryOptions): Promise<MemoryReadResult>;
+export function memory(operation: MemoryPutOperation, options?: MemoryOptions): Promise<MemoryPutResult>;
+export function memory(operation: MemoryDeleteOperation, options?: MemoryOptions): Promise<MemoryDeleteResult>;
+export function memory(operation: MemoryOperation, options?: MemoryOptions): Promise<MemoryResult>;
 export function getOrganization(options?: Options): Promise<Organization>;
 export function updateOrganization(request: OrganizationUpdate, options?: Options): Promise<Organization>;
 

package/managed/Agent.mjs

@@ -1,5 +1,7 @@
+import { requestOriginContext } from "../tools/environment.mjs";
 import { ManagedError } from "./ManagedError.mjs";
 import { registerManagedAgent } from "./internal.mjs";
+import { managedAccessFetch } from "./Access.mjs";
 
 const API_KEY = /^ncx_live_[A-Za-z0-9_-]{12}_[A-Za-z0-9_-]{43}$/;
 const CURSOR = /^(?:0|[1-9][0-9]*)$/;
@@ -23,7 +25,7 @@ const TURN_SUBMISSION_TIMEOUT_MS = 10_000;
 const TURN_STATE_POLL_INITIAL_MS = 1_000;
 const TURN_STATE_POLL_MAX_MS = 5_000;
 const TURN_STATE_READ_TIMEOUT_MS = 2_000;
-const ALLOWED_OPTIONS = new Set(["apiKey", "baseUrl", "fetch", "toolsTransport"]);
+const ALLOWED_OPTIONS = new Set(["apiKey", "baseUrl", "fetch", "toolsTransport", "requestOrigin"]);
 const CREATE_SETTINGS = new Set(["model", "thinking", "reasoningMode", "fastMode"]);
 const SETTINGS_PATCH = CREATE_SETTINGS;
 const MODELS = new Set(["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-6-astra"]);
@@ -247,9 +249,16 @@ export async function readSession(request, options = {}) {
   return managedReadSessionResponse(body);
 }
 
+function memoryClient(options) {
+  const { scope = "team", ...clientOptions } = options;
+  if (scope !== "team" && scope !== "personal") throw new TypeError("memory scope must be team or personal");
+  return { client: managedClient(clientOptions), scope };
+}
+
 /** List the authenticated account's hosted durable memory. */
 export async function listMemories(options = {}) {
-  const body = await managedClient(options).json("/v1/memory");
+  const { client, scope } = memoryClient(options);
+  const body = await client.json(`/v1/memory${scope === "personal" ? "?scope=personal" : ""}`);
   if (!body || typeof body !== "object" || Array.isArray(body) || !Array.isArray(body.memories)) {
     throw new ManagedError("invalid_response", "managed memory list is malformed");
   }
@@ -259,8 +268,9 @@ export async function listMemories(options = {}) {
 /** Compare-and-swap delete one account-owned hosted memory. */
 export async function deleteMemory(key, options = {}) {
   validateMemoryKey(key);
-  await managedClient(options).empty(
-    `/v1/memory/${key.id}?version=${key.version}`,
+  const { client, scope } = memoryClient(options);
+  await client.empty(
+    `/v1/memory/${key.id}?version=${key.version}${scope === "personal" ? "&scope=personal" : ""}`,
     { method: "DELETE" },
   );
 }
@@ -268,9 +278,10 @@ export async function deleteMemory(key, options = {}) {
 /** Run one atomic durable-memory operation in the authenticated account scope. */
 export async function memory(operation, options = {}) {
   validateMemoryOperation(operation);
-  const body = await managedClient(options).json("/v1/memory", {
+  const { client, scope } = memoryClient(options);
+  const body = await client.json("/v1/memory", {
     method: "POST",
-    body: JSON.stringify(operation),
+    body: JSON.stringify(scope === "personal" ? { ...operation, scope } : operation),
   });
   return managedMemoryResponse(body, operation.operation);
 }
@@ -302,6 +313,10 @@ function agentHandle(client, id, summary, retainedEventStream) {
     id,
     ...(summary === undefined ? {} : { summary }),
     events,
+    // Activation is explicit: passive event/history readers never warm a model.
+    prepare: (options = {}) => client.json(`${agentPath(id)}/prepare`, {
+      method: "POST", ...(options.signal === undefined ? {} : { signal: options.signal }),
+    }).then(() => undefined),
     requiredActions: Object.freeze({
       list: () => client.json(`${agentPath(id)}/required-actions`),
       submit: (callId, outcome) => {
@@ -1524,6 +1539,11 @@ function managedClient(options) {
   }
   const fetchImpl = options.fetch ?? globalThis.fetch;
   if (typeof fetchImpl !== "function") throw new Error("fetch is unavailable in this runtime");
+  const authorizedFetch = managedAccessFetch(fetchImpl, new URL(baseUrl).origin, apiKey);
+  const requestOrigin = requestOriginContext(options.requestOrigin ?? {
+    client: typeof window === "undefined" ? "javascript" : "web",
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+  });
   const toolsTransport = options.toolsTransport;
   if (toolsTransport !== undefined
       && typeof toolsTransport !== "function"
@@ -1533,13 +1553,14 @@ function managedClient(options) {
 
   const response = async (path, init = {}) => {
     const headers = new Headers();
+    if (path === "/v1/agents" || path.startsWith("/v1/agents/")) headers.set("x-nanocodex-client-context", JSON.stringify(requestOrigin));
     if (init.body !== undefined) headers.set("content-type", "application/json");
     if (init.accept) headers.set("accept", init.accept);
     if (init.idempotencyKey) headers.set("idempotency-key", init.idempotencyKey);
     if (init.voiceSessionId) headers.set("x-nanocodex-voice-session-id", init.voiceSessionId);
     if (apiKey) headers.set("authorization", `Bearer ${apiKey}`);
     try {
-      return await fetchImpl(new URL(path, baseUrl), {
+      return await authorizedFetch(new URL(path, baseUrl), {
         method: init.method ?? "GET",
         headers,
         credentials: apiKey ? "omit" : "include",

package/managed/Voice.mjs

@@ -50,6 +50,7 @@ export async function createManagedBrowserVoice(agent, voice, options = {}) {
     appendText: (role, text) => raw.appendText(role, text),
     appendContext: (text) => raw.appendContext(text),
     parallelStartup: true,
+    dataChannelControl: true,
     async start() {
       const started = await startManagedRealtime(agent, voiceSessionId, startOperationId);
       raw.start(JSON.stringify(started.context));

package/managed/index.d.mts

@@ -1,5 +1,6 @@
 export * as Agent from "./Agent.mjs";
 export { ManagedError } from "./ManagedError.mjs";
+export { withManagedAccess } from "./Access.mjs";
 export type {
   Agent as ManagedAgent,
   CronTrigger as ManagedCronTrigger,

package/managed/index.mjs

@@ -1,2 +1,3 @@
 export * as Agent from "./Agent.mjs";
 export { ManagedError } from "./ManagedError.mjs";
+export { withManagedAccess } from "./Access.mjs";

package/node/host.mjs

@@ -1,3 +1,4 @@
+import { createResponsesHttp, responsesHttpHeaders } from "../runtime/responses-http.mjs";
 import { Console } from "node:console";
 import { createRequire } from "node:module";
 import { resolve } from "node:path";
@@ -41,6 +42,12 @@ export function createNodeHost(options = {}) {
   }
   const toolsLifecycle = options.tools?.[toolRuntimeLifecycle];
   toolsLifecycle?.available();
+  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 });
+    return fetch(endpoint, { method: "POST", headers: responsesHttpHeaders(apiKey, sessionId, metadata),
+      body, signal, redirect: "error" });
+  });
   const connections = new Map();
   const code = createCodeRuntime(options.tools, {
     require: createRequire(resolve(options.workspace ?? process.cwd(), ".nanocodex-code-mode.cjs")),
@@ -288,6 +295,7 @@ export function createNodeHost(options = {}) {
 
   function dispose() {
     if (disposal) return disposal;
+    http.dispose();
     disposal = Promise.resolve().then(() => settleCleanup([
       ...[...connections.keys()].map((handle) => () => close(handle)),
       () => code.reset(),
@@ -309,6 +317,10 @@ export function createNodeHost(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,
     send,
     next,