@zoowork-ai/sdk 0.12.0 → 0.14.0

package/CHANGELOG.md

@@ -3,6 +3,46 @@
 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.14.0 — 2026-10-29
+
+- Live smoke and thinking tests now default to the platform default model (the catalog row whose
+  `default_for` includes `model`) instead of the first catalog row, which sorts alphabetically.
+  They fall back to the first eligible row when no default is marked. `--model` still overrides.
+- Ship `dist/AGENTS.md`, a short guide for coding assistants working in a project that installs this
+  package. The public docs describe the newest release; the guide tells an assistant to check a
+  method against the installed `*.d.ts` and `CHANGELOG.md`, and to tell the user when the docs rely
+  on something the installed version lacks instead of upgrading or working around it silently. In
+  an eval of projects pinned to 0.10.2, such a guide took Codex from 0/9 to 8/9 on reporting the
+  gap and kept Claude Code at 9/9 (zoowork-sdk-skills#40).
+- Add `getBalance()` for `GET /service/v1/balance`. It returns the Organization balance shared by
+  all Projects as a USD decimal string (`available_amount`), the same amount the Platform Billing
+  page shows. Any Platform key in the Organization can read it; Work service tokens receive
+  `service_api.not_found`.
+- Require Node.js 22 or later (`engines.node` is now `>=22`). Node.js 20 reached end of life on
+  2026-04-30 and was not patched by the 2026-10-21 Node.js security release. The SDK does not use
+  any Node.js 22-only API, so Node.js 20 may still run it, but that line is no longer tested or
+  supported. CI now tests Node.js 22, 24 and 26.
+
+## 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

@@ -2,7 +2,10 @@
 
 TypeScript SDK for the [ZooWork Managed Agents](https://zoowork.ai/docs/) API. Developer Preview.
 
-Zero runtime dependencies — it uses the platform `fetch`, which you can override for edge runtimes and tests. ESM only, Node 20+.
+Zero runtime dependencies — it uses the platform `fetch`, which you can override for edge runtimes and tests. ESM only. Requires Node.js 22 or later; use the latest security release of your Node.js line.
+
+Coding assistants: the installed package includes `dist/AGENTS.md`, which explains how to check
+the docs against the installed version.
 
 ```bash
 npm install @zoowork-ai/sdk
@@ -161,7 +164,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
@@ -446,6 +449,7 @@ These helpers require an SDK release that includes them. Check the installed dec
 
 ```ts
 const usage = await zc.getUsage({ range: '7d', view: 'both' })
+const balance = await zc.getBalance() // { object: 'balance', available_amount: '11.34', currency: 'usd' }
 const endpoint = await zc.createAgentWebhook(agentId, {
   url: 'https://receiver.example/webhook', event_types: ['run.finished'],
 }, 'register-hook-v1')
@@ -460,7 +464,9 @@ The workspace Files methods (`getWorkspaceFile`, `writeWorkspaceFile`,
 Send a file to an Agent with `uploadFile`, and retrieve results by asking the Agent to publish
 Artifacts and downloading those through the Artifact API. The database viewer is not a
 supported production workflow. The Agent can use `agent_db` and return query results in its
-reply. Method presence is not production availability. Usage stays within the current key scope. Page helpers retain `next_cursor` and `has_more`; replay cursors
+reply. Method presence is not production availability. Usage stays within the current key scope.
+`getBalance` returns the Organization balance shared by all Projects, in USD, to any Platform
+key in the Organization. Page helpers retain `next_cursor` and `has_more`; replay cursors
 verbatim. `getApproval` and `getCustomToolCall` read terminal as well as pending actions.
 
 Agent webhook methods include get/update/delete, `rotateAgentWebhookSecret`, `testAgentWebhook`,
@@ -471,10 +477,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/AGENTS.md

@@ -0,0 +1,18 @@
+# @zoowork-ai/sdk: notes for coding assistants
+
+This file ships inside the installed `@zoowork-ai/sdk` package. The installed version is in
+`../package.json`.
+
+The docs at https://zoowork.ai/docs describe the newest SDK release, which can be newer than the
+copy installed in this project. Before you use a method, field, or option from the docs:
+
+- Check that it exists in the `*.d.ts` files next to this one. They are the source of truth for
+  what the installed version supports.
+- `../CHANGELOG.md` lists what each release up to the installed one added. Later releases are
+  listed at https://raw.githubusercontent.com/SerendipityOneInc/zoowork-sdk-typescript/main/CHANGELOG.md.
+- If the docs rely on something the installed version lacks, tell the user which release adds it
+  and ask before upgrading. Do not upgrade the SDK without asking. If you work around the gap
+  instead, for example with a deprecated method or an untyped value, say so.
+
+Server behavior (errors, event streams, schedules, limits) does not depend on the SDK version.
+Follow the live docs for it: https://zoowork.ai/docs/llms.txt

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/developer-api.d.ts

@@ -68,6 +68,13 @@ export interface UsageResult extends ApiObject {
     groups?: ApiObject[];
     records?: ApiObject[];
 }
+/** The Organization's shared balance, as shown on the Platform Billing page. */
+export interface BalanceResult extends ApiObject {
+    object: 'balance';
+    /** Decimal USD string with two places, e.g. `"11.34"`, after current-period usage. */
+    available_amount: string;
+    currency: 'usd';
+}
 export interface RunOutputArtifact extends ApiObject {
     artifact_id: string | null;
     name: string;
@@ -182,6 +189,8 @@ export interface DeveloperApi {
         offset?: number;
     }): Promise<AgentDatabaseRows>;
     getUsage(opts?: UsageOptions): Promise<UsageResult>;
+    /** Read the Organization balance shared by every Project. Requires a Platform key. */
+    getBalance(): Promise<BalanceResult>;
     getRunOutput(agentId: string, sessionId: string, runId: string, opts?: CursorOptions): Promise<RunOutput>;
     getApproval(agentId: string, approvalId: string): Promise<ApprovalRecord>;
     getCustomToolCall(agentId: string, callId: string): Promise<CustomToolCallRecord>;

package/dist/developer-api.js

@@ -21,6 +21,7 @@ export function createDeveloperApi(json, bytes, selectors) {
         getAgentDatabase: (id) => json(`${agent(id)}/database`),
         getAgentDatabaseRows: (id, table, opts = {}) => json(`${agent(id)}/database/tables/${segment(table)}/rows${query({ limit: opts.limit, offset: opts.offset })}`),
         getUsage: (opts = {}) => json(`/usage${query({ range: opts.range, timezone: opts.timezone, group_by: opts.groupBy, view: opts.view, session_id: opts.sessionId, api_key_id: opts.apiKeyId, root_session_id: opts.rootSessionId, attribution: opts.attribution, page: opts.page, per_page: opts.perPage, as_of: opts.asOf, snapshot: opts.snapshot, cursor: opts.cursor })}`),
+        getBalance: () => json('/balance'),
         getRunOutput: (id, sid, rid, opts = {}) => json(`${agent(id)}/sessions/${segment(sid)}/runs/${segment(rid)}/output${query({ cursor: opts.cursor, limit: opts.limit })}`),
         getApproval: (id, aid) => json(`${agent(id)}/approvals/${segment(aid)}`),
         getCustomToolCall: (id, cid) => json(`${agent(id)}/custom_tool_calls/${segment(cid)}`),

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,5 +1,5 @@
-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';
-export type { ApiObject, CursorOptions, ActionListOptions, ApprovalPage, CustomToolCallPage, WorkspaceFileEntry, WorkspaceFile, AgentDatabase, AgentDatabaseRows, UsageOptions, UsageResult, RunOutputArtifact, RunOutputItem, RunOutput, AgentWebhookInput, AgentWebhookEndpoint, AgentWebhookPage, AgentWebhookCreated, AgentWebhookSecretRotation, WebhookDeliveryOptions, WebhookDeliveryPage, WebhookTestReceipt, WebhookRedeliveryReceipt, WebhookBatchRedeliveryReceipt, WebhookBatchRedeliveryInput, DeveloperApi, } from './developer-api.js';
+export type { ApiObject, CursorOptions, ActionListOptions, ApprovalPage, CustomToolCallPage, WorkspaceFileEntry, WorkspaceFile, AgentDatabase, AgentDatabaseRows, UsageOptions, UsageResult, BalanceResult, RunOutputArtifact, RunOutputItem, RunOutput, AgentWebhookInput, AgentWebhookEndpoint, AgentWebhookPage, AgentWebhookCreated, AgentWebhookSecretRotation, WebhookDeliveryOptions, WebhookDeliveryPage, WebhookTestReceipt, WebhookRedeliveryReceipt, WebhookBatchRedeliveryReceipt, WebhookBatchRedeliveryInput, DeveloperApi, } from './developer-api.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoowork-ai/sdk",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "TypeScript SDK for the ZooWork Managed Agents API (Developer Preview)",
   "keywords": [
     "zoowork",
@@ -33,14 +33,14 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "sideEffects": false,
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json && node -e \"require('node:fs').copyFileSync('agent-guide/AGENTS.md', 'dist/AGENTS.md')\"",
     "typecheck": "tsc --noEmit",
     "test": "tsc --noEmit && vitest run",
     "test:watch": "vitest",