@zoowork-ai/sdk 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to `@zoowork-ai/sdk` (formerly `@zooclaw-agents/sdk`). Dates are the
 day the behaviour was verified, not the day it was written.
 
+## 0.13.0 — 2026-10-23
+
+- Make the deprecated engine-only event lane visible in the types (#58). `listEvents`,
+  `listEventsPage`, `listAllEvents` and `streamEvents` now have a cursor overload and a
+  `@deprecated` overload for `after`, so editors strike through `{ after: ev.seq }`. That call
+  reads a lane whose numbering differs from the unified `seq` and which omits your inputs, so it
+  silently skips and renumbers events. Use `cursor`.
+- `listAllEvents` accepts `cursor` and starts the unified walk after it. A walk that starts from
+  a cursor never falls back to the `after` lane. Passing both `cursor` and `after` throws a
+  `TypeError` before any request.
+- Type-level change: an options object that sets both `cursor` and `after` no longer compiles,
+  matching the server, which rejects that combination with `400 invalid_request`. A variable
+  typed `{ after?: number; cursor?: string }` also no longer matches either overload; narrow it
+  to one lane. New exported types: `EventCursorPosition`, `LegacyEventPosition` (deprecated),
+  `ListEventsOptions`, `ListAllEventsOptions` and `StreamEventsOptions`.
+- Document that `SessionEvent.seq` orders events but is not a resume position, and that
+  `SessionEvent.cursor` is set only on streamed events.
+- `examples/capability-probe.ts` and `examples/surface-probe.ts` resume turns with `cursor`
+  instead of passing a unified `seq` as `after`.
+
 ## 0.12.0 — 2026-10-14
 
 - Add the Agent default thinking level (Managed API `model.thinking`, live in production from

package/README.md

@@ -161,7 +161,7 @@ for await (const ev of zc.streamEvents(agent.agent_id, session.session_id)) {
 Three things worth knowing before you write that loop:
 
 - **The stream is session-scoped and does not close when a turn ends.** The server closes it after an idle period. Break on `isRunFinished(ev)` yourself, or you block until that timeout.
-- **Save the opaque cursor.** After consuming an event, retain `ev.cursor` and resume with `{ cursor }`. Do not derive it from `seq` or mix it with `after`: `after` selects the deprecated event lane, which omits user-input events. The SDK sends the cursor in the query; do not rely on a raw `Last-Event-ID` header passing through the public gateway.
+- **Save the opaque cursor.** After consuming an event, retain `ev.cursor` and resume with `{ cursor }`. Do not derive it from `seq` or mix it with `after`: `after` selects the deprecated event lane, which numbers events differently and omits user-input events, so `after: ev.seq` silently skips events. Calls that pass `after` resolve to a `@deprecated` overload, which editors strike through. Listed events carry no cursor: continue a listing from the page's `nextCursor`, which `listAllEvents({ cursor })` also accepts. The SDK sends the cursor in the query; do not rely on a raw `Last-Event-ID` header passing through the public gateway.
 - **The default unified REST and SSE wire formats use snake_case.** Older event formats differ; the SDK normalizes both into `SessionEvent`, where you read `eventType`. Keep the cursor unchanged.
 
 For API sessions, `user.message` can carry `actor: { ref: 'customer-42' }`, including in
@@ -471,10 +471,15 @@ records to learn the result. SDK writes do not retry automatically.
 `createSession` accepts `runtime_mode: 'active'` to pin the current active configuration at
 creation. Omit it to resolve active configuration on later turns. `idle_compaction` preserves
 false, null and omission. MCP tool overrides accept `requireConfirmation?: boolean`.
-Production `updateAgent` currently rejects `expected_config_version` with
-`400 invalid_declared_key`. Omit it for ordinary last-write-wins updates; serialize competing
-writes in your application. A GET followed by PUT is not atomic. Ownership-only changes do not
-increment the configuration version. The separate `upgradeSystemPrompt` precondition remains supported.
+
+Pass an optional positive `expected_config_version` in the `updateAgent` sections object to
+check the current configuration version atomically with the update. Read it from
+`agent.status?.config_version ?? agent.config_version`. A mismatch returns
+`409 active_config_changed` without changing the configuration. Re-read and recompute the
+intended change before retrying; the precondition itself is not stored in `declared`.
+Omitting it keeps last-write-wins behavior. Ownership-only changes do not increment the
+configuration version. The separate `upgradeSystemPrompt` method requires its version
+precondition and uses `409 config_version_changed`.
 
 ## Current production behavior
 

package/dist/client.d.ts

@@ -883,6 +883,43 @@ export interface SessionEventPage {
     hasMore?: boolean;
     nextCursor?: string | null;
 }
+/**
+ * Where an event read starts: omit `cursor` for the beginning of the unified history, or pass a
+ * saved one to continue after it. `after` is not accepted here; it selects a separate,
+ * deprecated overload, so an editor flags any call that uses it.
+ */
+export interface EventCursorPosition {
+    /** Opaque resume token: a page's `nextCursor`, or a streamed event's `cursor`. Do not build one from `seq`. */
+    cursor?: string;
+    after?: undefined;
+}
+/**
+ * @deprecated Engine-only lane position. Use {@link EventCursorPosition}.
+ *
+ * That lane numbers events differently from the unified history and omits your own inputs
+ * (`user.message`, …), so `after: event.seq` with a `seq` from the unified history silently
+ * skips events and returns them renumbered. Keep it only for numeric positions stored from that
+ * lane before cursors existed. The server rejects `after` and `cursor` together.
+ */
+export interface LegacyEventPosition {
+    /** @deprecated Engine-only lane sequence, not a unified `SessionEvent.seq`. Use `cursor`. */
+    after?: number;
+    cursor?: undefined;
+}
+/** Filters for {@link ZooworkClient.listEvents} and {@link ZooworkClient.listEventsPage}. */
+export interface ListEventsOptions {
+    types?: string[];
+    limit?: number;
+}
+/** Filters for {@link ZooworkClient.listAllEvents}. */
+export interface ListAllEventsOptions {
+    types?: string[];
+    pageSize?: number;
+}
+/** Options for {@link ZooworkClient.streamEvents}. */
+export interface StreamEventsOptions {
+    signal?: AbortSignal;
+}
 /**
  * When a schedule fires: cron expression, everyMs interval in milliseconds (optional
  * anchorMs), or an ISO instant in at. The everyMs contract is source-reviewed; it was
@@ -1406,8 +1443,10 @@ export interface ZooworkClient extends DeveloperApi {
     listAgents(opts?: AgentListParams): AgentPagePromise;
     getAgent(agentId: string): Promise<AgentRecord>;
     /** PUT declared sections. Ownership-only changes do not bump config_version.
-     * Production currently rejects expected_config_version with 400 invalid_declared_key.
-     * Omit it for last-write-wins updates and serialize competing writes in the application. */
+     * Pass optional expected_config_version as a positive integer in sections for an atomic
+     * version precondition. A mismatch returns 409 active_config_changed without applying
+     * the update; re-read and recompute the change before retrying. Omit it for last-write-wins
+     * updates. The precondition is not stored in declared configuration. */
     updateAgent(agentId: string, sections: Record<string, unknown>): Promise<AgentRecord>;
     /**
      * Soft delete: the agent stops resolving on the API, but this is not a resource purge.
@@ -1727,53 +1766,55 @@ export interface ZooworkClient extends DeveloperApi {
      * (`user.message`, …) alongside engine events. `limit` defaults to 100 and is capped at 500;
      * the page's pagination fields are dropped, so use {@link ZooworkClient.listAllEvents}, or
      * {@link ZooworkClient.listEventsPage} to page by hand.
-     * Passing `after` selects the deprecated engine-only lane — old cursors only.
      */
-    listEvents(agentId: string, sessionId: string, opts?: {
-        after?: number;
-        cursor?: string;
-        types?: string[];
-        limit?: number;
-    }): Promise<SessionEvent[]>;
+    listEvents(agentId: string, sessionId: string, opts?: ListEventsOptions & EventCursorPosition): Promise<SessionEvent[]>;
+    /**
+     * @deprecated `after` reads the engine-only lane, whose numbering differs from the unified
+     * `seq` and which omits your inputs. Use `cursor`; see {@link LegacyEventPosition}.
+     */
+    listEvents(agentId: string, sessionId: string, opts: ListEventsOptions & LegacyEventPosition): Promise<SessionEvent[]>;
     /**
      * The page-returning primitive under `listEvents`: same options, plus the page's `hasMore`
      * and `nextCursor` (absent on servers without cursor pagination). Feed `nextCursor` back as
-     * `cursor` to page by hand.
+     * `cursor` to page by hand. Listed events carry no per-event `cursor`; resume from
+     * `nextCursor`, not from an event's `seq`.
      */
-    listEventsPage(agentId: string, sessionId: string, opts?: {
-        after?: number;
-        cursor?: string;
-        types?: string[];
-        limit?: number;
-    }): Promise<SessionEventPage>;
+    listEventsPage(agentId: string, sessionId: string, opts?: ListEventsOptions & EventCursorPosition): Promise<SessionEventPage>;
+    /**
+     * @deprecated `after` reads the engine-only lane, whose numbering differs from the unified
+     * `seq` and which omits your inputs. Use `cursor`; see {@link LegacyEventPosition}.
+     */
+    listEventsPage(agentId: string, sessionId: string, opts: ListEventsOptions & LegacyEventPosition): Promise<SessionEventPage>;
     /**
      * Every durable event: follows the server's `next_cursor` until `has_more` is false, and
      * falls back to walking `after` against servers without cursor pagination (that walk stops
      * when a page fails to advance, so a server that ignored `after` cannot spin it forever).
      *
-     * `pageSize` is the per-request `limit` (default and maximum 500). Events come back in
-     * ascending `seq`, deduplicated across page boundaries. Passing `after` forces the
-     * deprecated engine-only lane.
+     * Pass `cursor` (a saved `nextCursor` or streamed event `cursor`) to start after that
+     * position; a walk that starts from a cursor never falls back to `after`. `pageSize` is the
+     * per-request `limit` (default and maximum 500). Events come back in ascending `seq`,
+     * deduplicated across page boundaries.
      */
-    listAllEvents(agentId: string, sessionId: string, opts?: {
-        after?: number;
-        types?: string[];
-        pageSize?: number;
-    }): Promise<SessionEvent[]>;
+    listAllEvents(agentId: string, sessionId: string, opts?: ListAllEventsOptions & EventCursorPosition): Promise<SessionEvent[]>;
+    /**
+     * @deprecated `after` forces the engine-only lane, whose numbering differs from the unified
+     * `seq` and which omits your inputs. Use `cursor`; see {@link LegacyEventPosition}.
+     */
+    listAllEvents(agentId: string, sessionId: string, opts: ListAllEventsOptions & LegacyEventPosition): Promise<SessionEvent[]>;
     /**
      * Durable event stream with server-side resume.
      *
      * The stream is SESSION-scoped and unbounded: it does NOT close when a turn ends, and the
      * server closes it on idle. Detect turn end with `isRunFinished`, and resume by passing the
-     * last event's `cursor` (its `after` fallback selects the deprecated engine-only lane).
-     * `chat.delta` preview frames are skipped — they are snapshot-replace frames on a separate
-     * Redis-only lane, not durable events.
+     * last event's `cursor`. `chat.delta` preview frames are skipped — they are snapshot-replace
+     * frames on a separate Redis-only lane, not durable events.
      */
-    streamEvents(agentId: string, sessionId: string, opts?: {
-        after?: number;
-        cursor?: string;
-        signal?: AbortSignal;
-    }): AsyncGenerator<SessionEvent>;
+    streamEvents(agentId: string, sessionId: string, opts?: StreamEventsOptions & EventCursorPosition): AsyncGenerator<SessionEvent>;
+    /**
+     * @deprecated `after` resumes the engine-only lane, whose numbering differs from the unified
+     * `seq` and which omits your inputs. Use `cursor`; see {@link LegacyEventPosition}.
+     */
+    streamEvents(agentId: string, sessionId: string, opts: StreamEventsOptions & LegacyEventPosition): AsyncGenerator<SessionEvent>;
     /** Pending calls only. Any other status is rejected by the API. */
     listCustomToolCalls(agentId: string, opts?: {
         status?: 'pending';

package/dist/client.js

@@ -337,6 +337,21 @@ export function createZooworkClient(cfg = {}) {
             throw error;
         }
     };
+    // Both public overloads share this implementation; the deprecated `after` one only differs in
+    // which lane the server reads.
+    const listEventsPage = async (agentId, sessionId, opts = {}) => {
+        const data = await json(`${sessions(agentId)}/${encodeURIComponent(sessionId)}/events${query({
+            after: opts.after,
+            cursor: opts.cursor,
+            types: opts.types?.join(','),
+            limit: opts.limit,
+        })}`);
+        return {
+            events: (data.events ?? []).map((e) => normalizeEvent(e)),
+            ...(data.has_more !== undefined ? { hasMore: data.has_more } : {}),
+            ...(data.next_cursor !== undefined ? { nextCursor: data.next_cursor } : {}),
+        };
+    };
     const client = {
         ...createDeveloperApi(json, bytes, artifactSelectors),
         listModels: async () => {
@@ -620,28 +635,19 @@ export function createZooworkClient(cfg = {}) {
             const data = await json(`${sessions(agentId)}/${encodeURIComponent(sessionId)}/events`, { method: 'POST', body: JSON.stringify({ events }) });
             return { events: data.events ?? [] };
         },
-        listEvents: async (agentId, sessionId, opts = {}) => (await client.listEventsPage(agentId, sessionId, opts)).events,
-        listEventsPage: async (agentId, sessionId, opts = {}) => {
-            const data = await json(`${sessions(agentId)}/${encodeURIComponent(sessionId)}/events${query({
-                after: opts.after,
-                cursor: opts.cursor,
-                types: opts.types?.join(','),
-                limit: opts.limit,
-            })}`);
-            return {
-                events: (data.events ?? []).map((e) => normalizeEvent(e)),
-                ...(data.has_more !== undefined ? { hasMore: data.has_more } : {}),
-                ...(data.next_cursor !== undefined ? { nextCursor: data.next_cursor } : {}),
-            };
-        },
+        listEvents: async (agentId, sessionId, opts = {}) => (await listEventsPage(agentId, sessionId, opts)).events,
+        listEventsPage,
         listAllEvents: async (agentId, sessionId, opts = {}) => {
+            if (opts.cursor !== undefined && opts.after !== undefined) {
+                throw new TypeError('listAllEvents: pass either cursor or after, not both');
+            }
             const pageSize = Math.min(Math.max(opts.pageSize ?? 500, 1), 500);
             const out = [];
             // Unified lane (default): follow the server's cursor until has_more is false.
             if (opts.after === undefined) {
-                let pageCursor;
+                let pageCursor = opts.cursor;
                 for (;;) {
-                    const page = await client.listEventsPage(agentId, sessionId, {
+                    const page = await listEventsPage(agentId, sessionId, {
                         ...(pageCursor !== undefined ? { cursor: pageCursor } : {}),
                         ...(opts.types ? { types: opts.types } : {}),
                         limit: pageSize,
@@ -667,7 +673,7 @@ export function createZooworkClient(cfg = {}) {
             }
             let cursor = opts.after ?? out.reduce((max, e) => (e.seq > max ? e.seq : max), 0);
             for (;;) {
-                const page = await client.listEvents(agentId, sessionId, {
+                const { events: page } = await listEventsPage(agentId, sessionId, {
                     after: cursor,
                     ...(opts.types ? { types: opts.types } : {}),
                     limit: pageSize,

package/dist/events.d.ts

@@ -24,7 +24,11 @@ export declare const PUBLIC_INPUT_EVENT_TYPES: readonly ["user.message", "user.i
 export type PublicInputEventType = (typeof PUBLIC_INPUT_EVENT_TYPES)[number];
 /** A durable session event, normalized across the REST and SSE shapes. */
 export interface SessionEvent {
-    /** Durable per-session sequence: strictly increasing, not necessarily contiguous. */
+    /**
+     * Durable per-session sequence: strictly increasing, not necessarily contiguous. It orders
+     * events; it is not a resume position. The unified history and the deprecated engine-only
+     * lane number events differently, so never pass it as `after`. Resume with `cursor`.
+     */
     seq: number;
     eventType: SessionEventType | PublicInputEventType | string;
     payload: Record<string, unknown>;
@@ -35,7 +39,10 @@ export interface SessionEvent {
     id?: string;
     /** Input events only: `null` while queued, set once the agent has consumed it. */
     processedAt?: string | null;
-    /** Resume token for `streamEvents({ cursor })`, present on streamed events. */
+    /**
+     * Opaque resume token, set only on events from `streamEvents`. Listed events do not carry
+     * one; resume a listing from its page's `nextCursor`.
+     */
     cursor?: string;
 }
 /** Accepts either wire shape (and an SSE `id:` line as the seq fallback). */

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { createZooworkClient, DEFAULT_BASE_URL, ZooworkError, type ZooworkClient, type ZooworkConfig, type ZooworkAuth, type Ownership, type ModelInfo, type ThinkingLevel, type AgentResource, type AgentModelUpdate, type AgentUpdate, type AgentRecord, type AgentListParams, type AgentPage, type AgentPagePromise, type AgentStatus, type AgentSkill, type AgentChannel, type AgentChannelCapabilitySync, type AgentChannelCapabilities, type FeishuChannelProviderStatus, type FeishuDocumentsCapability, type ChannelPlatform, type AddChannelPlatform, type GuidedSetupPlatform, type AddChannelInput, type UpdateChannelInput, type ChannelSetupInput, type ChannelSetupSession, type ChannelPollResult, type FeishuSetupInput, type FeishuSetupSession, type FeishuPollResult, type McpContextConfig, type McpServerDeclaration, type McpToolPermission, type McpToolPermissionOverride, type CustomToolDeclaration, type CustomToolResultImageMimeType, type CustomToolResultContent, type CustomToolResultEvent, type SkillRecord, type SkillVersionRecord, type SessionRecord, type SessionListPageOptions, type SessionListPage, type SessionHistoryEntry, type SessionEvent, type SessionEventPage, type OutboundEvent, type PostEventReceipt, type ApprovalDecision, type ApprovalRecord, type CustomToolCallStatus, type CustomToolCallRecord, type ArtifactPage, type ArtifactRecord, type ArtifactStatus, type OutcomeConfig, type OutcomeEvaluator, type SystemPromptDeclaration, type SystemPromptInfo, type SystemPromptPreview, type SystemPromptPreviewInput, type SystemPromptUpgrade, type ScheduleSpec, type SchedulePayload, type ScheduleInput, type ScheduleUpdate, type ScheduleRecord, type ScheduleRun, type WakeResult, type ExecResult, type UploadFileResult, type EnvironmentConfig, type EnvironmentResource, type EnvironmentRecord, type EnvironmentVersionRecord, } from './client.js';
+export { createZooworkClient, DEFAULT_BASE_URL, ZooworkError, type ZooworkClient, type ZooworkConfig, type ZooworkAuth, type Ownership, type ModelInfo, type ThinkingLevel, type AgentResource, type AgentModelUpdate, type AgentUpdate, type AgentRecord, type AgentListParams, type AgentPage, type AgentPagePromise, type AgentStatus, type AgentSkill, type AgentChannel, type AgentChannelCapabilitySync, type AgentChannelCapabilities, type FeishuChannelProviderStatus, type FeishuDocumentsCapability, type ChannelPlatform, type AddChannelPlatform, type GuidedSetupPlatform, type AddChannelInput, type UpdateChannelInput, type ChannelSetupInput, type ChannelSetupSession, type ChannelPollResult, type FeishuSetupInput, type FeishuSetupSession, type FeishuPollResult, type McpContextConfig, type McpServerDeclaration, type McpToolPermission, type McpToolPermissionOverride, type CustomToolDeclaration, type CustomToolResultImageMimeType, type CustomToolResultContent, type CustomToolResultEvent, type SkillRecord, type SkillVersionRecord, type SessionRecord, type SessionListPageOptions, type SessionListPage, type SessionHistoryEntry, type SessionEvent, type SessionEventPage, type EventCursorPosition, type ListEventsOptions, type ListAllEventsOptions, type StreamEventsOptions, type LegacyEventPosition, type OutboundEvent, type PostEventReceipt, type ApprovalDecision, type ApprovalRecord, type CustomToolCallStatus, type CustomToolCallRecord, type ArtifactPage, type ArtifactRecord, type ArtifactStatus, type OutcomeConfig, type OutcomeEvaluator, type SystemPromptDeclaration, type SystemPromptInfo, type SystemPromptPreview, type SystemPromptPreviewInput, type SystemPromptUpgrade, type ScheduleSpec, type SchedulePayload, type ScheduleInput, type ScheduleUpdate, type ScheduleRecord, type ScheduleRun, type WakeResult, type ExecResult, type UploadFileResult, type EnvironmentConfig, type EnvironmentResource, type EnvironmentRecord, type EnvironmentVersionRecord, } from './client.js';
 export { SESSION_EVENT_TYPES, type SessionEventType, PUBLIC_INPUT_EVENT_TYPES, type PublicInputEventType, normalizeEvent, isRunFinished, runOutcome, messageText, assistantText, thinkingText, customToolUse, type CustomToolUse, toolCall, type ToolCall, } from './events.js';
 export { parseSSE, type SSEMessage } from './sse.js';
 export { WEBHOOK_EVENT_TYPES, WEBHOOK_SCHEDULE_CONFIG_EVENT_TYPES, type WebhookEventType, isKnownWebhookEventType, knownWebhookEvent, verifyWebhookSignature, unwrapWebhook, signWebhook, ZooworkWebhookError, type WebhookErrorCode, WEBHOOK_ID_HEADER, WEBHOOK_TIMESTAMP_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_SECRET_ENV, WEBHOOK_TOLERANCE_SECONDS, WEBHOOK_DEFAULT_MAX_BODY_BYTES, type WebhookEvent, type WebhookEventFor, type KnownWebhookEvent, type WebhookEventData, type WebhookEventDataByType, type WebhookEventAttribution, type WebhookScheduleRunRef, type WebhookWaitingOnRef, type WebhookRunEventData, type WebhookRunStartedData, type WebhookRunFinishedData, type WebhookRunYieldedData, type WebhookApprovalEventData, type WebhookApprovalRequestedData, type WebhookApprovalResolvedData, type WebhookCustomToolEventData, type WebhookCustomToolRequestedData, type WebhookCustomToolResolvedData, type WebhookOutcomeEvaluatedData, type WebhookSessionCreatedData, type WebhookSessionArchivedData, type WebhookSessionDeletedData, type WebhookScheduleFireData, type WebhookScheduleDispatchedData, type WebhookScheduleDispatchFailedData, type WebhookScheduleSkippedData, type WebhookScheduleFinishedData, type WebhookScheduleConfigData, type WebhookTestData, type WebhookHeaders, type WebhookHeaderSource, type WebhookSignatureHeaders, type VerifyWebhookInput, type VerifiedWebhook, type SignWebhookInput, } from './webhooks.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoowork-ai/sdk",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "TypeScript SDK for the ZooWork Managed Agents API (Developer Preview)",
   "keywords": [
     "zoowork",