@zoowork-ai/sdk 0.11.1 → 0.13.0

package/CHANGELOG.md

@@ -3,6 +3,39 @@
 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
+  Engine `v0.2.33-release`). New exported types `ThinkingLevel`
+  (`'off' | 'low' | 'medium' | 'high' | 'max'`), `AgentModelUpdate` and `AgentUpdate`.
+  `AgentResource.model.thinking` accepts a level or `null`. `null` in an update clears it, and
+  `{ model: { thinking: null } } satisfies AgentUpdate` type-checks without `primary`.
+- `ModelInfo.thinking` types the new `GET /v1/models` field `{ default, levels }`, which lists the
+  levels a model honours as named. A level a model does not list resolves to the nearest one.
+- `SchedulePayload.thinking` overrides the Agent's level for an `agentTurn` job. On update,
+  omitting it keeps the stored value and `null` clears it.
+- Additive only. Existing calls and types compile unchanged.
+
 ## 0.11.1 — 2026-10-04
 
 - `uploadFile` no longer runs `chown` on the uploaded file or on directories it creates. The

package/README.md

@@ -51,6 +51,29 @@ const session = await zc.createSession(agent.agent_id, {
 before using a catalog row in a new Agent or config. A non-selectable choice returns
 `409 model_not_selectable`; `expired_fallback_to` names the reviewed replacement when present.
 
+To set a default thinking level, read the levels a model supports from `listModels()` and
+choose one of them in `model.thinking` (`'off' | 'low' | 'medium' | 'high' | 'max'`). Omit it to
+use the platform default; send `thinking: null` in an `updateAgent` call to clear it. A schedule's
+`agentTurn` payload accepts the same `thinking` values; on `updateSchedule`, omitting it keeps the
+stored value and `null` clears it.
+
+```ts
+// `models` and `primary` come from the listModels() example above.
+const info = models.find((m) => m.model === primary)
+const wanted: ThinkingLevel = 'high'
+
+// Set the level only when the model supports it; otherwise leave `thinking` out and the
+// Agent follows the platform default.
+const model: AgentResource['model'] = { primary }
+if (info?.thinking?.levels.includes(wanted)) model.thinking = wanted
+
+const tuned = await zc.createAgent({ resource: { name: 'deep-research-agent', model } })
+
+// Clear it later. `model.thinking` merges, so `primary` is not needed. `satisfies AgentUpdate`
+// makes the compiler reject an unknown level (updateAgent itself accepts any object).
+await zc.updateAgent(tuned.agent_id, { model: { thinking: null } } satisfies AgentUpdate)
+```
+
 Agent resources also accept `userTimezone`, a named IANA timezone used for prompt and message
 time context, and `include_global_skills: false` to disable automatic global Skills while keeping
 explicitly listed Skills. An explicit `skills: []` also opts out. Schedule timezones are configured
@@ -138,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
@@ -448,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

@@ -118,6 +118,12 @@ export interface Ownership {
     project_id?: string | null;
     visibility?: 'private' | 'project';
 }
+/**
+ * Thinking level, in ascending order of reasoning. A model resolves a level it does not list in
+ * `ModelInfo.thinking.levels` to the nearest listed one (ties go up), so `off` on a model that
+ * cannot stop thinking becomes its lowest level.
+ */
+export type ThinkingLevel = 'off' | 'low' | 'medium' | 'high' | 'max';
 export interface ModelInfo {
     model: string;
     display_name?: string;
@@ -132,6 +138,15 @@ export interface ModelInfo {
     selectable?: boolean;
     retire_not_before?: string | null;
     default_for?: string[];
+    /**
+     * Thinking levels that take effect as named on this model, ascending; any other
+     * {@link ThinkingLevel} resolves to the nearest listed one. `default` is what the platform
+     * applies when an Agent sets none. Optional so older servers that omit it still type-check.
+     */
+    thinking?: {
+        default: ThinkingLevel;
+        levels: ThinkingLevel[];
+    };
     [k: string]: unknown;
 }
 /** Approval behavior for one MCP server or one of its tools. */
@@ -281,6 +296,21 @@ export interface OutcomeConfig {
     /** Defaults to `after_satisfied` at run time: an unsatisfied result stays unpublished. */
     publish?: 'after_satisfied' | 'always' | 'never';
 }
+/**
+ * Partial `model` section for {@link ZooworkClient.updateAgent}. `model.thinking` merges on its
+ * own, so `{ thinking: null }` alone clears the declared level; `primary` is not required.
+ */
+export type AgentModelUpdate = Partial<NonNullable<AgentResource['model']>>;
+/**
+ * Opt-in typing for the `sections` argument of `updateAgent`. `updateAgent` itself still takes
+ * `Record<string, unknown>` so existing callers compile unchanged; write
+ * `const update = { model: { thinking: null } } satisfies AgentUpdate` (or annotate with this
+ * type) to have the compiler check `model` and reject an unknown thinking level.
+ */
+export type AgentUpdate = {
+    model?: AgentModelUpdate;
+    [section: string]: unknown;
+};
 export interface AgentResource {
     name: string;
     /** Named IANA timezone used in prompt context and message timestamps, e.g. `Asia/Shanghai`. */
@@ -290,11 +320,16 @@ export interface AgentResource {
      * defaults can rotate; call `listModels()` and set `primary` explicitly for deterministic
      * provisioning. `max_tokens` caps output tokens per model request; omit only that field to
      * use the platform token limit.
+     *
+     * `thinking` is the Agent's default thinking level. Omit it to use the platform default for
+     * the model; send `null` in an update (PUT) to clear a previously declared value. Check
+     * `ModelInfo.thinking.levels` from `listModels()` for the levels a model accepts.
      */
     model?: {
         primary: string;
         input?: string[];
         max_tokens?: number;
+        thinking?: ThinkingLevel | null;
     };
     persona?: {
         docs: {
@@ -848,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
@@ -884,6 +956,16 @@ export interface SchedulePayload {
      * 2026-08-14 (201, read back verbatim). See {@link OutcomeConfig}.
      */
     outcome?: OutcomeConfig | null;
+    /**
+     * Thinking level for THIS job's turns, outranking the Agent's `model.thinking`. Only an
+     * `agentTurn` payload honours it. On an update it has three states: omit it (or send an empty or
+     * whitespace-only string) to keep the stored value, send `null` to clear it so the job follows
+     * the Agent again, or send a level to set it. The server trims and lowercases a new value and
+     * normalizes legacy spellings (`xhigh`, `minimal`, `adaptive` become `max`, `low`, `medium`);
+     * a stored value written back unchanged stays as is, so a job stored before this change may
+     * still read back a legacy spelling.
+     */
+    thinking?: ThinkingLevel | null;
     [k: string]: unknown;
 }
 export interface ScheduleInput {
@@ -1361,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.
@@ -1682,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 AgentResource, 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.11.1",
+  "version": "0.13.0",
   "description": "TypeScript SDK for the ZooWork Managed Agents API (Developer Preview)",
   "keywords": [
     "zoowork",