nanocodex 0.6.4 → 0.6.6

package/managed/Agent.d.mts

@@ -41,61 +41,6 @@ export type ReadSessionResponse = Readonly<{
   turns: readonly SessionTurn[];
   citations: readonly HistoryCitation[];
 }>;
-export type MemoryKey = Readonly<{ id: number; version: number }>;
-export type MemoryRecord = Readonly<{
-  key: MemoryKey;
-  content: string;
-  created_at_ms: number;
-  updated_at_ms: number;
-  last_scanned_at_ms: number | null;
-  scan_count: number;
-  last_used_at_ms: number | null;
-  use_count: number;
-  probation_until_ms: number | null;
-}>;
-export type MemoryCandidate = Readonly<{
-  key: MemoryKey;
-  preview: string;
-  score: number;
-}>;
-export type MemoryScanOperation = Readonly<{
-  operation: "scan";
-  query: string;
-  limit?: number | undefined;
-}>;
-export type MemoryReadOperation = Readonly<{ operation: "read"; keys: readonly MemoryKey[] }>;
-export type MemoryPutOperation = Readonly<{
-  operation: "put";
-  content: string;
-  replace?: MemoryKey | undefined;
-}>;
-export type MemoryDeleteOperation = Readonly<{ operation: "delete"; key: MemoryKey }>;
-export type MemoryOperation =
-  | MemoryScanOperation
-  | MemoryReadOperation
-  | MemoryPutOperation
-  | MemoryDeleteOperation;
-export type MemoryScanResult = Readonly<{
-  operation: "scan";
-  abstained: boolean;
-  candidates: readonly MemoryCandidate[];
-}>;
-export type MemoryReadResult = Readonly<{
-  operation: "read";
-  memories: readonly MemoryRecord[];
-}>;
-export type MemoryPutResult = Readonly<{
-  operation: "put";
-  memory: MemoryRecord;
-  replaced: boolean;
-}>;
-export type MemoryDeleteResult = Readonly<{ operation: "delete"; key: MemoryKey }>;
-export type MemoryResult =
-  | MemoryScanResult
-  | MemoryReadResult
-  | MemoryPutResult
-  | MemoryDeleteResult;
-
 export type Organization = Readonly<{
   id: string;
   name: string | null;
@@ -195,8 +140,6 @@ export type CreateAndPromptOptions = CreateOptions & Readonly<{
 export type Capabilities = Readonly<{
   durable_turns: true;
   resumable_events: true;
-  live_steer: true;
-  live_cancel: true;
   workspace: "cloudflare-computer";
   /** Tools can target explicit sandbox and connected-user environments. */
   execution_environments: true;
@@ -227,11 +170,26 @@ export type State = Readonly<{
   }>;
 }>;
 
+export type AgentPresentation = Readonly<{
+  revision: number;
+  status: "running" | "stopping" | "completed" | "cancelled" | "failed" | "idle";
+  activeTurnIds: readonly string[];
+  title?: string;
+  activity?: string;
+  activityTurnId?: string;
+  /** Bounded preview of the latest accepted user prompt. */
+  lastUserPrompt?: string;
+  lastUserMessageAt?: number;
+  updatedAt: number;
+}>;
+
 export type Summary = Readonly<{
   title: string;
   createdAt: number;
   updatedAt: number;
   turnCount: number;
+  lastUserMessageAt?: number;
+  presentation?: AgentPresentation;
 }>;
 
 export type TurnState =
@@ -260,9 +218,11 @@ export type EventData = Readonly<{
   cursor: string;
   created_at: number;
   turn_id: string | null;
+  model_route?: { model: string; thinking: string; reasoning_mode: string; fast_mode: boolean; backend: string };
+  model_routing_automatic?: boolean;
 }> & (
   | { type: "agent_created"; agent_id: string; capabilities: Capabilities }
-  | { type: "turn_accepted"; id: string; input: PromptInput; replayed: boolean }
+  | { type: "turn_accepted"; id: string; input: PromptInput; replayed: boolean; author?: "guest"; share_link_id?: string }
   | { type: "turn_cancelling"; id: string; error?: string; retry_at?: number }
   | CompletedEventData
   | { type: "turn_cancelled"; id: string }
@@ -369,7 +329,7 @@ export type CronTriggerConfig = Readonly<{
   cron: string;
   /** IANA time zone. Defaults to UTC. */
   timezone?: string | undefined;
-  /** Text prompt submitted for each occurrence, at most 64 KiB. */
+  /** Text prompt submitted for each occurrence. */
   input: string;
   /** Defaults to true; false pauses future occurrences. */
   enabled?: boolean | undefined;
@@ -415,6 +375,9 @@ export type Agent = Readonly<{
   /** Account-owned list metadata, present on handles returned by `list()`. */
   summary?: Summary | undefined;
   turn: Readonly<{ prompt(options: PromptOptions): Turn }>;
+  /** Copy the latest committed model boundary into a separate durable agent.
+   * Reuse the same key to reconcile an uncertain response. */
+  fork(options: Readonly<{ idempotencyKey: string; signal?: AbortSignal | undefined }>): Promise<Agent>;
   settings: Readonly<{
     read(): Promise<CreateSettings>;
     update(patch: SettingsPatch): Promise<CreateSettings>;
@@ -424,6 +387,9 @@ export type Agent = Readonly<{
     get(id: string): Promise<CronTrigger>;
     /** Create or replace an account-owned schedule using a stable id. */
     put(id: string, config: CronTriggerConfig): Promise<CronTrigger>;
+    /** Update an existing schedule; omitted settings are preserved. */
+    update(id: string, patch: Partial<CronTriggerConfig>): Promise<CronTrigger>;
+    /** Stop future occurrences. Already dispatched runs are not cancelled. */
     delete(id: string): Promise<void>;
   }>;
   /** Reverse-tool endpoint with cookie/bearer transport retained in a private closure. */
@@ -451,16 +417,6 @@ 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?: MemoryOptions): Promise<readonly MemoryRecord[]>;
-/** Compare-and-swap delete one hosted durable memory; deleting an absent id is idempotent. */
-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,3 +1,4 @@
+import { steerInputKey } from "../runtime/steer-receipt.mjs";
 import { requestOriginContext } from "../tools/environment.mjs";
 import { ManagedError } from "./ManagedError.mjs";
 import { registerManagedAgent } from "./internal.mjs";
@@ -28,13 +29,13 @@ const TURN_STATE_READ_TIMEOUT_MS = 2_000;
 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"]);
+const MODELS = new Set(["gpt-6.1-sol", "gpt-6-luna", "gpt-6-astra", "@cf/zai-org/glm-5.3", "kimi-k3", "mimo-v2.6-pro"]);
 const THINKING = new Set(["none", "low", "medium", "high", "xhigh", "max"]);
 const REASONING_MODES = new Set(["standard", "pro"]);
 const eventEncoder = new TextEncoder();
 
 /** Create a new managed agent owned by the authenticated account. */
-export async function create(options = {}) {
+export async function create(options = {}, onCreated) {
   const { clientOptions, requestBody, creationKey } = managedCreateOptions(options);
   const client = managedClient(clientOptions);
   const idempotencyKey = creationKey ?? `managed-create:${globalThis.crypto.randomUUID()}`;
@@ -44,7 +45,12 @@ export async function create(options = {}) {
     idempotencyKey,
     requestBody,
   );
-  return agentHandle(client, requiredString(receipt, "agent_id"));
+  const agent = agentHandle(client, requiredString(receipt, "agent_id"));
+  // Internal transport hook: preserve the public handle while sharing the POST
+  // identity receipt with the common Agent lifecycle. Never cache initial_state: an
+  // idempotent replay may return synthetic creation state for an existing agent.
+  onCreated?.(receipt);
+  return agent;
 }
 
 /** Create a managed agent and durably admit its first turn in one request. */
@@ -144,8 +150,11 @@ function managedCreateOptions(options) {
       || typeof settings.fastMode !== "boolean") {
     throw new TypeError("managed agent creation settings are invalid");
   }
-  if (settings.model === "gpt-6-astra" && settings.thinking === "none") {
-    throw new TypeError("GPT-6 Astra requires low, medium, high, xhigh, or max thinking");
+  if (["@cf/zai-org/glm-5.3", "kimi-k3", "mimo-v2.6-pro"].includes(settings.model) && ((settings.thinking !== undefined && !(settings.model === "kimi-k3" ? ["low", "high"] : ["low", "medium", "high"]).includes(settings.thinking)) || settings.reasoningMode === "pro")) {
+    throw new TypeError(`${settings.model === "@cf/zai-org/glm-5.3" ? "GLM-5.3" : settings.model} requires a supported thinking effort and standard reasoning mode`);
+  }
+  if (["gpt-6-astra", "gpt-6.1-sol"].includes(settings.model) && settings.thinking === "none") {
+    throw new TypeError("GPT-6 Astra and GPT-6.1 Sol require low, medium, high, xhigh, or max thinking");
   }
   if (settings.model === "gpt-6-astra" && settings.reasoningMode === "pro") {
     throw new TypeError("GPT-6 Astra does not support pro reasoning mode");
@@ -249,43 +258,6 @@ 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 { 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");
-  }
-  return Object.freeze(body.memories.map(managedMemoryRecord));
-}
-
-/** Compare-and-swap delete one account-owned hosted memory. */
-export async function deleteMemory(key, options = {}) {
-  validateMemoryKey(key);
-  const { client, scope } = memoryClient(options);
-  await client.empty(
-    `/v1/memory/${key.id}?version=${key.version}${scope === "personal" ? "&scope=personal" : ""}`,
-    { method: "DELETE" },
-  );
-}
-
-/** Run one atomic durable-memory operation in the authenticated account scope. */
-export async function memory(operation, options = {}) {
-  validateMemoryOperation(operation);
-  const { client, scope } = memoryClient(options);
-  const body = await client.json("/v1/memory", {
-    method: "POST",
-    body: JSON.stringify(scope === "personal" ? { ...operation, scope } : operation),
-  });
-  return managedMemoryResponse(body, operation.operation);
-}
-
 /** Read metadata for the authenticated account's organization. */
 export async function getOrganization(options = {}) {
   return managedOrganization(await managedClient(options).json("/v1/organization"));
@@ -313,6 +285,22 @@ function agentHandle(client, id, summary, retainedEventStream) {
     id,
     ...(summary === undefined ? {} : { summary }),
     events,
+    fork: async (options) => {
+      if (!options || typeof options !== "object" || Array.isArray(options)
+        || Object.keys(options).some(key => !["idempotencyKey", "signal"].includes(key))
+        || typeof options.idempotencyKey !== "string"
+        || !IDEMPOTENCY_KEY.test(options.idempotencyKey)) {
+        throw new TypeError("managed fork requires a valid idempotency key");
+      }
+      if (options.signal !== undefined && !(options.signal instanceof AbortSignal))
+        throw new TypeError("managed fork signal must be an AbortSignal");
+      const receipt = await retryCreateMutation(client, `${agentPath(id)}/forks`,
+        options.idempotencyKey, undefined, options.signal);
+      const childId = requiredString(receipt, "agent_id");
+      if (!SESSION_ID.test(childId) || childId === id || receipt.parent_agent_id !== id)
+        throw new ManagedError("invalid_response", "managed fork response did not identify a separate child");
+      return agentHandle(client, childId);
+    },
     // 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 }),
@@ -362,6 +350,9 @@ function agentHandle(client, id, summary, retainedEventStream) {
       put: async (triggerId, config) => managedCronTrigger(await client.json(cronTriggerPath(id, triggerId), {
         method: "PUT", body: cronTriggerBody(config),
       })),
+      update: async (triggerId, patch) => managedCronTrigger(await client.json(cronTriggerPath(id, triggerId), {
+        method: "PATCH", body: cronTriggerPatch(patch),
+      })),
       delete: async (triggerId) => { await client.empty(cronTriggerPath(id, triggerId), { method: "DELETE" }); },
     }),
     toolsTarget: () => client.toolsTarget(id),
@@ -398,6 +389,14 @@ function cronTriggerBody(config) {
   return JSON.stringify(config);
 }
 
+function cronTriggerPatch(patch) {
+  if (!patch || typeof patch !== "object" || Array.isArray(patch)) throw new TypeError("invalid cron trigger patch");
+  const defined = Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined));
+  if (!Object.keys(defined).length) throw new TypeError("cron trigger patch must contain a setting");
+  cronTriggerBody({ cron: "0 9 * * *", input: "validation", ...defined });
+  return JSON.stringify(defined);
+}
+
 function managedCronTrigger(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)
     || typeof value.id !== "string" || !/^[A-Za-z0-9_-]{1,64}$/.test(value.id)
@@ -430,8 +429,11 @@ function managedSettingsPatch(patch) {
     || (Object.hasOwn(patch, "fastMode") && typeof patch.fastMode !== "boolean")) {
     throw new TypeError("managed agent settings patch is invalid");
   }
-  if (patch.model === "gpt-6-astra" && patch.thinking === "none") {
-    throw new TypeError("GPT-6 Astra requires low, medium, high, xhigh, or max thinking");
+  if (["@cf/zai-org/glm-5.3", "kimi-k3", "mimo-v2.6-pro"].includes(patch.model) && ((patch.thinking !== undefined && !(patch.model === "kimi-k3" ? ["low", "high"] : ["low", "medium", "high"]).includes(patch.thinking)) || patch.reasoningMode === "pro")) {
+    throw new TypeError(`${patch.model === "@cf/zai-org/glm-5.3" ? "GLM-5.3" : patch.model} requires a supported thinking effort and standard reasoning mode`);
+  }
+  if (["gpt-6-astra", "gpt-6.1-sol"].includes(patch.model) && patch.thinking === "none") {
+    throw new TypeError("GPT-6 Astra and GPT-6.1 Sol require low, medium, high, xhigh, or max thinking");
   }
   if (patch.model === "gpt-6-astra" && patch.reasoningMode === "pro") {
     throw new TypeError("GPT-6 Astra does not support pro reasoning mode");
@@ -448,8 +450,10 @@ function managedSettings(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)
     || !MODELS.has(value.model) || !THINKING.has(value.thinking)
     || !REASONING_MODES.has(value.reasoning_mode) || typeof value.fast_mode !== "boolean"
-    || (value.model === "gpt-6-astra" && value.thinking === "none")
-    || (value.model === "gpt-6-astra" && value.reasoning_mode === "pro")) {
+    || (["@cf/zai-org/glm-5.3", "kimi-k3", "mimo-v2.6-pro"].includes(value.model) && (!(value.model === "kimi-k3" ? ["low", "high"] : ["low", "medium", "high"]).includes(value.thinking) || value.reasoning_mode === "pro"))
+    || (["gpt-6-astra", "gpt-6.1-sol"].includes(value.model) && value.thinking === "none")
+    || (value.model === "gpt-6-astra" && value.reasoning_mode === "pro")
+  ) {
     throw new ManagedError("invalid_response", "managed agent settings are malformed");
   }
   return Object.freeze({
@@ -509,9 +513,22 @@ function managedSummary(value) {
     createdAt: value.created_at,
     updatedAt: value.updated_at,
     turnCount: value.turn_count,
+    lastUserMessageAt: nonnegativeNumber(value.last_user_message_at) ? value.last_user_message_at : value.turn_count > 0 ? value.updated_at : 0,
+    ...(validPresentation(value.presentation) ? { presentation: Object.freeze({ ...value.presentation, activeTurnIds: Object.freeze([...value.presentation.activeTurnIds]) }) } : {}),
   });
 }
 
+function validPresentation(value) {
+  return value && typeof value === "object" && !Array.isArray(value)
+    && Number.isSafeInteger(value.revision) && value.revision > 0
+    && ["running", "stopping", "completed", "cancelled", "failed", "idle"].includes(value.status)
+    && Array.isArray(value.activeTurnIds) && value.activeTurnIds.every(id => typeof id === "string")
+    && nonnegativeNumber(value.updatedAt)
+    && (value.activity === undefined || typeof value.activity === "string")
+    && (value.activityTurnId === undefined || typeof value.activityTurnId === "string")
+    && (value.lastUserPrompt === undefined || typeof value.lastUserPrompt === "string");
+}
+
 function nonnegativeNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
@@ -590,11 +607,24 @@ function managedTurn(client, agentId, eventStream, options, acceptedSubmission)
       // Cancellation deliberately bypasses this queue.
       const steering = steeringTail.then(async () => {
         const accepted = await submission;
-        return client.json(`${turnPath(agentId, requiredString(accepted, "turn_id"))}/steer`, {
-          method: "POST",
-          body,
-          signal,
-        });
+        const turnId = requiredString(accepted, "turn_id");
+        try {
+          return await client.json(`${turnPath(agentId, turnId)}/steer`, { method: "POST", body, signal });
+        } catch (error) {
+          if (typeof messageId === "string" && TURN_ID.test(messageId) && !(error?.status >= 400 && error?.status < 500)) {
+            // Capability discovery is read-only. Missing/legacy receipts never authorize resending.
+            const receipt = await client.json(`${turnPath(agentId, turnId)}/steer-receipt?message_id=${encodeURIComponent(messageId)}`, { signal }).catch(() => undefined);
+            if (
+              receipt?.protocol === 1 && receipt.turn_id === turnId &&
+              receipt.message_id === messageId && receipt.state === "accepted" &&
+              typeof receipt.input_key === "string" &&
+              receipt.input_key === await steerInputKey(JSON.parse(body).input).catch(() => undefined)
+            ) {
+              return { turn_id: turnId, state: "steering" };
+            }
+          }
+          throw error;
+        }
       });
       steeringTail = steering.then(() => {}, () => {});
       return steering;
@@ -935,94 +965,6 @@ function managedCitations(value) {
   }));
 }
 
-function managedMemoryResponse(value, expectedOperation) {
-  if (!value || typeof value !== "object" || Array.isArray(value)
-    || value.operation !== expectedOperation) {
-    throw new ManagedError("invalid_response", "managed memory response is malformed");
-  }
-  if (value.operation === "scan") {
-    if (typeof value.abstained !== "boolean" || !Array.isArray(value.candidates)
-      || value.abstained !== (value.candidates.length === 0)) {
-      throw new ManagedError("invalid_response", "managed memory scan response is malformed");
-    }
-    return Object.freeze({
-      operation: "scan",
-      abstained: value.abstained,
-      candidates: Object.freeze(value.candidates.map(managedMemoryCandidate)),
-    });
-  }
-  if (value.operation === "read") {
-    if (!Array.isArray(value.memories)) {
-      throw new ManagedError("invalid_response", "managed memory read response is malformed");
-    }
-    return Object.freeze({
-      operation: "read",
-      memories: Object.freeze(value.memories.map(managedMemoryRecord)),
-    });
-  }
-  if (value.operation === "put") {
-    if (typeof value.replaced !== "boolean") {
-      throw new ManagedError("invalid_response", "managed memory put response is malformed");
-    }
-    return Object.freeze({
-      operation: "put",
-      memory: managedMemoryRecord(value.memory),
-      replaced: value.replaced,
-    });
-  }
-  if (value.operation === "delete") {
-    return Object.freeze({ operation: "delete", key: managedMemoryKey(value.key) });
-  }
-  throw new ManagedError("invalid_response", "managed memory response is malformed");
-}
-
-function managedMemoryCandidate(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)
-    || typeof value.preview !== "string"
-    || UTF8.encode(value.preview).byteLength > 64
-    || typeof value.score !== "number" || !Number.isFinite(value.score) || value.score <= 0) {
-    throw new ManagedError("invalid_response", "managed memory candidate is malformed");
-  }
-  return Object.freeze({
-    key: managedMemoryKey(value.key),
-    preview: value.preview,
-    score: value.score,
-  });
-}
-
-function managedMemoryRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)
-    || typeof value.content !== "string" || !value.content.trim()
-    || !nonnegativeSafeInteger(value.created_at_ms)
-    || !nonnegativeSafeInteger(value.updated_at_ms)
-    || !nullableNonnegativeSafeInteger(value.last_scanned_at_ms)
-    || !nonnegativeSafeInteger(value.scan_count)
-    || !nullableNonnegativeSafeInteger(value.last_used_at_ms)
-    || !nonnegativeSafeInteger(value.use_count)
-    || !nullableNonnegativeSafeInteger(value.probation_until_ms)) {
-    throw new ManagedError("invalid_response", "managed memory record is malformed");
-  }
-  return Object.freeze({
-    key: managedMemoryKey(value.key),
-    content: value.content,
-    created_at_ms: value.created_at_ms,
-    updated_at_ms: value.updated_at_ms,
-    last_scanned_at_ms: value.last_scanned_at_ms,
-    scan_count: value.scan_count,
-    last_used_at_ms: value.last_used_at_ms,
-    use_count: value.use_count,
-    probation_until_ms: value.probation_until_ms,
-  });
-}
-
-function managedMemoryKey(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)
-    || !positiveSafeInteger(value.id) || !positiveSafeInteger(value.version)) {
-    throw new ManagedError("invalid_response", "managed memory key is malformed");
-  }
-  return Object.freeze({ id: value.id, version: value.version });
-}
-
 function managedOrganization(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)
     || typeof value.id !== "string" || !UUID.test(value.id)
@@ -1553,7 +1495,7 @@ 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 (path === "/v1/agent-runs" || 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);
@@ -1701,58 +1643,6 @@ function validateReadSessionRequest(request) {
   }
 }
 
-function validateMemoryOperation(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new TypeError("managed memory operation must be an object");
-  }
-  if (typeof value.operation !== "string") {
-    throw new TypeError("managed memory operation is required");
-  }
-  if (value.operation === "scan") {
-    assertOnlyFields(value, ["operation", "query", "limit"], "managed memory scan");
-    if (typeof value.query !== "string" || !value.query.trim()) {
-      throw new TypeError("managed memory scan query must be a nonempty string");
-    }
-    if (value.limit !== undefined
-      && (!Number.isSafeInteger(value.limit) || value.limit < 1)) {
-      throw new TypeError("managed memory scan limit must be a positive safe integer");
-    }
-    return;
-  }
-  if (value.operation === "read") {
-    assertOnlyFields(value, ["operation", "keys"], "managed memory read");
-    if (!Array.isArray(value.keys) || value.keys.length === 0) {
-      throw new TypeError("managed memory read requires at least one key");
-    }
-    value.keys.forEach(validateMemoryKey);
-    return;
-  }
-  if (value.operation === "put") {
-    assertOnlyFields(value, ["operation", "content", "replace"], "managed memory put");
-    if (typeof value.content !== "string" || !value.content.trim()) {
-      throw new TypeError("managed memory content must be a nonempty string");
-    }
-    if (value.replace !== undefined) validateMemoryKey(value.replace);
-    return;
-  }
-  if (value.operation === "delete") {
-    assertOnlyFields(value, ["operation", "key"], "managed memory delete");
-    validateMemoryKey(value.key);
-    return;
-  }
-  throw new TypeError("managed memory operation must be scan, read, put, or delete");
-}
-
-function validateMemoryKey(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new TypeError("managed memory key must be an object");
-  }
-  assertOnlyFields(value, ["id", "version"], "managed memory key");
-  if (!positiveSafeInteger(value.id) || !positiveSafeInteger(value.version)) {
-    throw new TypeError("managed memory key id and version must be positive safe integers");
-  }
-}
-
 function validateOrganizationUpdate(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new TypeError("managed organization update must be an object");
@@ -1777,10 +1667,6 @@ function nonnegativeSafeInteger(value) {
   return Number.isSafeInteger(value) && value >= 0;
 }
 
-function nullableNonnegativeSafeInteger(value) {
-  return value === null || nonnegativeSafeInteger(value);
-}
-
 function requiredString(value, field) {
   const result = value?.[field];
   if (typeof result !== "string" || result.length === 0) {

package/managed/README.md

@@ -93,39 +93,6 @@ const session = await Agent.readSession(
 Both methods derive the account scope from the cookie or API key; no scope or user
 identifier is accepted from the caller.
 
-Hosted durable memory is account-owned and independent from session history. The
-memory panel can list records and compare-and-swap delete one current key:
-
-```js
-const memories = await Agent.listMemories({
-  baseUrl: process.env.NANOCODEX_MANAGED_URL,
-  apiKey: process.env.NANOCODEX_API_KEY,
-});
-await Agent.deleteMemory(memories[0].key, {
-  baseUrl: process.env.NANOCODEX_MANAGED_URL,
-  apiKey: process.env.NANOCODEX_API_KEY,
-});
-```
-
-Managed agents access this same hosted store through their `memory` tool. It is
-never mirrored into a browser, TUI, or other local persistence layer.
-
-Account memory uses the same derived organization scope and supports scan, read,
-put, and delete operations. Scan before writing so the service can reject
-duplicates, and retain returned `{ id, version }` keys for compare-and-swap
-updates:
-
-```js
-const scanned = await Agent.memory(
-  { operation: "scan", query: "production deploy schedule" },
-  { baseUrl: process.env.NANOCODEX_MANAGED_URL, apiKey: process.env.NANOCODEX_API_KEY },
-);
-const stored = await Agent.memory(
-  { operation: "put", content: "Production deploys happen on Tuesdays." },
-  { baseUrl: process.env.NANOCODEX_MANAGED_URL, apiKey: process.env.NANOCODEX_API_KEY },
-);
-```
-
 Browser account owners can read and rename their organization:
 
 ```js
@@ -172,8 +139,9 @@ const morning = {
 await agent.triggers.put("morning-review", morning);
 await agent.triggers.list();
 await agent.triggers.get("morning-review");
-await agent.triggers.put("morning-review", { ...morning, enabled: false }); // pause
-await agent.triggers.put("morning-review", morning); // resume
+await agent.triggers.update("morning-review", { enabled: false }); // pause
+await agent.triggers.update("morning-review", { enabled: true }); // resume
+await agent.triggers.update("morning-review", { cron: "30 9 * * *" }); // preserve other fields
 await agent.triggers.delete("morning-review");
 ```
 
@@ -182,6 +150,7 @@ await agent.triggers.delete("morning-review");
 | GET | `/v1/agents/:agent/triggers` | `{ data: [...] }` |
 | GET | `/v1/agents/:agent/triggers/:id` | Trigger or 404 |
 | PUT | `/v1/agents/:agent/triggers/:id` | Create (201) or replace (200) |
+| PATCH | `/v1/agents/:agent/triggers/:id` | Partial update (200), or 404 |
 | DELETE | `/v1/agents/:agent/triggers/:id` | Idempotent deletion (204) |
 
 The managed-agent web composer also has a **Schedules** button. It opens the
@@ -194,10 +163,12 @@ PUT takes `{ cron, input, timezone?, enabled?, session_mode? }`. Expressions hav
 (minute, hour, day of month, month, day of week), supporting numeric values,
 lists, ranges, steps, and month/day names. The time zone defaults to UTC and
 accepts IANA names. Local times follow daylight saving transitions. Seconds,
-macros, and random `H` fields are rejected. Inputs are text up to 64 KiB;
-there can be at most 32 triggers per agent. IDs use 1–64 letters, digits,
+macros, and random `H` fields are rejected. Inputs must be non-empty text.
+IDs use 1–64 letters, digits,
 underscores, or hyphens. PUT is a full replacement; an identical retry preserves
-the next occurrence. A changed configuration starts from the next matching time.
+the next occurrence. PATCH (SDK `triggers.update`) changes only supplied fields
+and requires an existing schedule. A concurrent edit may return 409; refresh
+before deciding which changes to retry. A changed configuration starts from the next matching time.
 
 `session_mode: "new"` (the default for new configurations) creates a fresh managed
 session for every occurrence. It copies the source agent's model settings at

package/managed/Voice.mjs

@@ -13,6 +13,7 @@ export async function createManagedBrowserVoice(agent, voice, options = {}) {
   await initializeBrowserEngine(options);
   const raw = new ManagedBrowserVoice(voice);
   const voiceSessionId = uuidV7();
+  raw.bindSession(voiceSessionId);
   const startOperationId = crypto.randomUUID();
   const stopOperationId = crypto.randomUUID();
   const tailOperationId = crypto.randomUUID();
@@ -38,6 +39,7 @@ export async function createManagedBrowserVoice(agent, voice, options = {}) {
     if (typeof routed.turn_id !== "string") return [];
     activeTurnId = routed.turn_id;
     if (routed.route === "started") startedTurnId = routed.turn_id;
+    else if (startedTurnId !== activeTurnId) startedTurnId = undefined;
     const buffered = pendingEvents;
     pendingEvents = [];
     return buffered.map(observe).filter((effects) => effects !== undefined);
@@ -53,7 +55,7 @@ export async function createManagedBrowserVoice(agent, voice, options = {}) {
     dataChannelControl: true,
     async start() {
       const started = await startManagedRealtime(agent, voiceSessionId, startOperationId);
-      raw.start(JSON.stringify(started.context));
+      return raw.start(JSON.stringify(started.context));
     },
     callBody(sdp) {
       const envelope = JSON.parse(raw.callBody(sdp, voiceSessionId));
@@ -136,7 +138,8 @@ export async function createManagedBrowserVoice(agent, voice, options = {}) {
       }
       let stopFailure;
       try {
-        await stopManagedRealtime(agent, voiceSessionId, stopOperationId);
+        await stopManagedRealtime(agent, voiceSessionId, stopOperationId,
+          update.delegation?.trim() ? undefined : update.transcript);
       } catch (error) {
         stopFailure = error;
       }

package/managed/index.d.mts

@@ -14,9 +14,6 @@ export type {
   HistoryCitation as ManagedHistoryCitation,
   FindSessionsResponse as ManagedFindSessionsResponse,
   ReadSessionResponse as ManagedReadSessionResponse,
-  MemoryKey as ManagedMemoryKey,
-  MemoryRecord as ManagedMemoryRecord,
-  MemoryResult as ManagedMemoryResult,
   Organization as ManagedOrganization,
   Turn as ManagedTurn,
   TurnResult as ManagedTurnResult,