@yanlinglabs/winter-agent-sdk 0.0.28 → 0.0.30

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export type { Query, SdkMessage, SessionMessagingFacet } from "./query.js";
 export type { QueryInternal, ControlRequestHandler, ControlRequestHandlerResult } from "./query.js";
 export type { Options } from "./options.js";
 export { SYSTEM_PROMPT_DYNAMIC_BOUNDARY, DEFAULT_CONTEXT_WINDOW_TOKENS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_PLANS_DIRECTORY, DEFAULT_OUTPUT_STYLE } from "./options.js";
-export { DEFAULT_PROVIDER_STALL_TIMEOUT_MS, DEFAULT_KEYCHAIN_SERVICE } from "./options.js";
+export { DEFAULT_PROVIDER_STALL_TIMEOUT_MS, DEFAULT_KEYCHAIN_SERVICE, MCP_OAUTH_REFRESH_SUBTYPE, CREDENTIAL_RESOLVE_SUBTYPE } from "./options.js";
 export { WEB_TOOLS_DEFAULTS, resolveWebToolsConfig } from "./options.js";
 export type { ResolvedWebToolsConfig } from "./options.js";
 export type { WebToolsConfig, WebSearchConfig, WebFetchConfig, WebPrivateAddressPolicy, AutoMemoryConfig } from "./protocol/config.js";
@@ -21,6 +21,8 @@ export { resolveRuntimeExecutable, defaultSpawn } from "./transport.js";
 export type { SpawnedRuntimeProcess, SpawnRuntimeOptions, SpawnClaudeCodeProcess } from "./transport.js";
 export type { RuntimeConfig, RuntimeHooksConfig, RuntimeHookMatcherGroup, SandboxSettingsConfig } from "./protocol/config.js";
 export type { McpServerConfigForProcessTransport, McpVersionNegotiation, AgentMcpServerSpec, RuntimeAgentDefinition } from "./protocol/config.js";
+export type { McpOAuthConfig, McpOAuthSecretRef, McpOAuthRefreshRequest, McpOAuthRefreshAnswer } from "./protocol/config.js";
+export type { CredentialResolveRequest, CredentialResolveAnswer } from "./protocol/config.js";
 export { encodeFrame, decodeFrame, splitFrames, ProtocolError } from "./protocol/codec.js";
 export { PROTOCOL_VERSION } from "./protocol/frames.js";
 export { SDK_VERSION } from "./version.js";

package/dist/index.js

@@ -66,6 +66,8 @@ var DEFAULT_PLANS_DIRECTORY = `${WINTER_BRAND2.projectDirName}/plans`;
 var DEFAULT_OUTPUT_STYLE = "default";
 var DEFAULT_PROVIDER_STALL_TIMEOUT_MS = 120000;
 var DEFAULT_KEYCHAIN_SERVICE = WINTER_BRAND2.keychainService;
+var MCP_OAUTH_REFRESH_SUBTYPE = "mcp_oauth_refresh";
+var CREDENTIAL_RESOLVE_SUBTYPE = "credential_resolve";
 var WEB_TOOLS_DEFAULTS = {
   searchEnabled: true,
   maxSearchesPerCall: 8,
@@ -474,6 +476,74 @@ function makeElicitationHandler(onElicitation, abortController) {
     return { ok: true, payload: result ?? { action: "decline" } };
   };
 }
+function isRefreshRequest(payload) {
+  if (typeof payload !== "object" || payload === null)
+    return false;
+  const p = payload;
+  return typeof p.server === "string" && typeof p.account === "string" && typeof p.generation === "number" && Number.isInteger(p.generation) && (p.stepUpScope === undefined || typeof p.stepUpScope === "string");
+}
+function isRefreshAnswer(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const v = value;
+  return v.ok === true || v.ok === false && (v.reason === "needs_auth" || v.reason === "transient");
+}
+function makeMcpOAuthRefreshHandler(onMcpOAuthRefresh, abortController) {
+  return async (payload, handlerCtx) => {
+    if (!isRefreshRequest(payload))
+      return { ok: false, error: { code: "invalid_payload", message: "mcp_oauth_refresh expects { server, account, generation, stepUpScope? }" } };
+    const controller = new AbortController;
+    if (abortController?.signal.aborted === true || handlerCtx?.signal.aborted === true)
+      controller.abort();
+    abortController?.signal.addEventListener("abort", () => controller.abort(), { once: true });
+    handlerCtx?.signal.addEventListener("abort", () => controller.abort(), { once: true });
+    const request = { server: payload.server, account: payload.account, generation: payload.generation, ...payload.stepUpScope !== undefined ? { stepUpScope: payload.stepUpScope } : {} };
+    try {
+      const answer = await onMcpOAuthRefresh(request, { signal: controller.signal });
+      return { ok: true, payload: isRefreshAnswer(answer) ? answer : { ok: false, reason: "transient" } };
+    } catch (err) {
+      console.error(`winter: onMcpOAuthRefresh threw for account '${payload.account}' (${err instanceof Error ? err.name : "error"}) -- answering transient`);
+      return { ok: true, payload: { ok: false, reason: "transient" } };
+    }
+  };
+}
+function isCredentialResolveRequest(payload) {
+  if (typeof payload !== "object" || payload === null)
+    return false;
+  const p = payload;
+  const ref = p.ref;
+  return typeof ref === "object" && ref !== null && ref.kind === "keychain" && typeof ref.account === "string" && (ref.service === undefined || typeof ref.service === "string") && (p.minGeneration === undefined || typeof p.minGeneration === "number" && Number.isInteger(p.minGeneration));
+}
+function isCredentialResolveAnswer(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const v = value;
+  if (v.ok === true)
+    return typeof v.material === "string" && typeof v.generation === "number" && (v.expiresAt === undefined || typeof v.expiresAt === "number");
+  return v.ok === false && (v.reason === "not_found" || v.reason === "not_allowed" || v.reason === "stale" || v.reason === "unavailable");
+}
+function makeCredentialResolveHandler(onCredentialResolve, abortController) {
+  return async (payload, handlerCtx) => {
+    if (!isCredentialResolveRequest(payload))
+      return { ok: false, error: { code: "invalid_payload", message: 'credential_resolve expects { ref: { kind: "keychain", account, service? }, minGeneration? }' } };
+    const controller = new AbortController;
+    if (abortController?.signal.aborted === true || handlerCtx?.signal.aborted === true)
+      controller.abort();
+    abortController?.signal.addEventListener("abort", () => controller.abort(), { once: true });
+    handlerCtx?.signal.addEventListener("abort", () => controller.abort(), { once: true });
+    const request = {
+      ref: { kind: "keychain", account: payload.ref.account, ...payload.ref.service !== undefined ? { service: payload.ref.service } : {} },
+      ...payload.minGeneration !== undefined ? { minGeneration: payload.minGeneration } : {}
+    };
+    try {
+      const answer = await onCredentialResolve(request, { signal: controller.signal });
+      return { ok: true, payload: isCredentialResolveAnswer(answer) ? answer : { ok: false, reason: "unavailable" } };
+    } catch (err) {
+      console.error(`winter: onCredentialResolve threw for account '${payload.ref.account}' (${err instanceof Error ? err.name : "error"}) -- answering unavailable`);
+      return { ok: true, payload: { ok: false, reason: "unavailable" } };
+    }
+  };
+}
 function buildRuntimeHooksConfig(hooks) {
   if (!hooks)
     return;
@@ -640,6 +710,7 @@ function query(args) {
     ...options.providerStallTimeoutMs !== undefined ? { providerStallTimeoutMs: options.providerStallTimeoutMs } : {},
     ...options.maxOutputTokens !== undefined ? { maxOutputTokens: options.maxOutputTokens } : {},
     ...brand.keychainService !== WINTER_BRAND2.keychainService || options.keychainService !== undefined ? { keychainService: brand.keychainService } : {},
+    ...options.onCredentialResolve !== undefined ? { hostCredentials: true } : {},
     ...options.autoClassifier !== undefined ? { autoClassifier: options.autoClassifier } : {},
     ...options.advisor !== undefined ? { advisor: options.advisor } : {},
     ...options.web !== undefined ? { web: options.web } : {},
@@ -773,6 +844,12 @@ function query(args) {
   if (options.onElicitation) {
     controlRequestHandlers.set("mcp_elicitation", makeElicitationHandler(options.onElicitation, options.abortController));
   }
+  if (options.onCredentialResolve) {
+    controlRequestHandlers.set(CREDENTIAL_RESOLVE_SUBTYPE, makeCredentialResolveHandler(options.onCredentialResolve, options.abortController));
+  }
+  if (options.onMcpOAuthRefresh) {
+    controlRequestHandlers.set(MCP_OAUTH_REFRESH_SUBTYPE, makeMcpOAuthRefreshHandler(options.onMcpOAuthRefresh, options.abortController));
+  }
   if (proc.stderr) {
     const stderrIterable = proc.stderr;
     (async () => {
@@ -919,6 +996,9 @@ function query(args) {
     const retained = typeof payload === "object" && payload !== null ? payload.retained_count : undefined;
     return { retainedCount: typeof retained === "number" ? retained : 0 };
   };
+  gen.reconnectMcpServer = async (serverName) => {
+    await sendControlRequest("mcp_reconnect", { serverName });
+  };
   gen.supportedModels = async () => {
     const payload = await sendControlRequest("list_models", undefined);
     return Array.isArray(payload) ? payload : [];
@@ -1038,7 +1118,7 @@ function query(args) {
   return gen;
 }
 // src/version.ts
-var SDK_VERSION = "0.0.28";
+var SDK_VERSION = "0.0.30";
 // src/paths/project-key.ts
 var TRANSCRIPT_PROJECT_KEY_MAX_LENGTH = 64;
 var VENDOR_PROJECT_KEY_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
@@ -2203,6 +2283,7 @@ export {
   BRAND_TOKEN_RE2 as BRAND_TOKEN_RE,
   CATALOG_TAG_RENAMES,
   CLIConnectionError,
+  CREDENTIAL_RESOLVE_SUBTYPE,
   DEFAULT_COMPACTION_THRESHOLD,
   DEFAULT_CONTEXT_WINDOW_TOKENS,
   DEFAULT_KEYCHAIN_SERVICE,
@@ -2214,6 +2295,7 @@ export {
   FIRST_PARTY_ORIGINATORS2 as FIRST_PARTY_ORIGINATORS,
   HOOK_EVENTS,
   InvalidBrandError,
+  MCP_OAUTH_REFRESH_SUBTYPE,
   MESSAGING_CONTROL_SUBTYPES,
   MESSAGING_CONTROL_SUBTYPE_LIST,
   MESSAGING_HOST_REQUEST_SUBTYPES,

package/dist/options.d.ts

@@ -1,6 +1,6 @@
 import type { SpawnClaudeCodeProcess } from "./transport.js";
 import type { PermissionMode, CanUseTool, HookEvent, HookCallbackMatcher } from "./permissions/types.js";
-import type { SandboxSettingsConfig, McpServerToolPolicy, McpStdioServerConfig, McpHttpServerConfig, McpSSEServerConfig, McpSdkServerConfig, RuntimeAgentDefinition, SdkPluginConfig, SystemPromptOption, OutputFormat, SkillsOption, ProviderSelection, ThinkingConfig, EffortLevel, AutoClassifierConfig, AdvisorConfig, WebToolsConfig, WebPrivateAddressPolicy, AutoMemoryConfig, CredentialRef } from "./protocol/config.js";
+import type { SandboxSettingsConfig, McpServerToolPolicy, McpStdioServerConfig, McpHttpServerConfig, McpSSEServerConfig, McpSdkServerConfig, RuntimeAgentDefinition, SdkPluginConfig, SystemPromptOption, OutputFormat, SkillsOption, ProviderSelection, ThinkingConfig, EffortLevel, AutoClassifierConfig, AdvisorConfig, WebToolsConfig, WebPrivateAddressPolicy, AutoMemoryConfig, CredentialRef, McpOAuthRefreshRequest, McpOAuthRefreshAnswer, CredentialResolveRequest, CredentialResolveAnswer } from "./protocol/config.js";
 import type { SettingSource } from "./settings/types.js";
 import type { SessionStore } from "./store/session-store.js";
 import { type BrandProfile } from "./brand.js";
@@ -15,6 +15,14 @@ export declare const DEFAULT_PLANS_DIRECTORY: string;
 export declare const DEFAULT_OUTPUT_STYLE = "default";
 export declare const DEFAULT_PROVIDER_STALL_TIMEOUT_MS = 120000;
 export declare const DEFAULT_KEYCHAIN_SERVICE: string;
+/**
+ * WS-25 (MCP OAuth): the runtime -> host control subtype a session sends when a stored MCP sign-in needs
+ * refreshing (`McpOAuthRefreshRequest` -> `McpOAuthRefreshAnswer`, protocol/config.ts). Spelled once:
+ * `query.ts` registers the handler under it and the runtime sends it.
+ */
+export declare const MCP_OAUTH_REFRESH_SUBTYPE = "mcp_oauth_refresh";
+/** WS-25 §7: the runtime -> host control subtype a host-brokered session resolves a Keychain credential with (`CredentialResolveRequest` -> `CredentialResolveAnswer`). */
+export declare const CREDENTIAL_RESOLVE_SUBTYPE = "credential_resolve";
 /**
  * Every web-tool default, spelled ONCE. A reader function resolves an absent field against this --
  * no consumer writes a literal of its own.
@@ -172,6 +180,37 @@ export interface Options {
         action: "accept" | "decline" | "cancel";
         content?: Record<string, unknown>;
     } | null>;
+    /**
+     * WS-25 (MCP OAuth), WINTER-ONLY: the host refreshes this session's MCP sign-ins. When set, `query()`
+     * answers the runtime's `mcp_oauth_refresh` control request with it; the session then re-reads the
+     * token item from the Keychain and never posts a refresh grant itself. The host is the ONE refresher
+     * (single-flight per `account`, a `generation` re-read before posting), which is what keeps a
+     * ROTATING refresh token from being replayed by two processes.
+     *
+     * Absent: the runtime's request lands on the generic "no handler registered" answer and the session
+     * refreshes in-process -- correct for a standalone SDK user with one process. A host that runs
+     * several sessions (or refreshes elsewhere) MUST set this, and must set it here, before the session
+     * starts: a handler registered later leaves the first connects refreshing in-process.
+     *
+     * Never serialized (a JS function), like `onElicitation`. Carries no material in either direction.
+     */
+    onMcpOAuthRefresh?: (request: McpOAuthRefreshRequest, options: {
+        signal: AbortSignal;
+    }) => Promise<McpOAuthRefreshAnswer>;
+    /**
+     * WS-25 §7 (prompt-free credentials), WINTER-ONLY: the host resolves this session's Keychain
+     * credentials. When set, `query()` puts `hostCredentials: true` on the wire and answers the runtime's
+     * `credential_resolve` requests with it; the session then never touches the Keychain (no macOS consent
+     * prompt for a child binary reading items the host created) and never persists a credential -- renewal
+     * is the host's, and a 401 asks again with `minGeneration`.
+     *
+     * The host answers ONLY for refs this session's `Options` named, and never with a refresh token (see
+     * `CredentialResolveAnswer`). Never serialized (a JS function); the material crosses only in the
+     * control_response frame.
+     */
+    onCredentialResolve?: (request: CredentialResolveRequest, options: {
+        signal: AbortSignal;
+    }) => Promise<CredentialResolveAnswer>;
     systemPrompt?: SystemPromptOption;
     plugins?: SdkPluginConfig[];
     skills?: SkillsOption;

package/dist/protocol/config.d.ts

@@ -120,6 +120,117 @@ export interface McpServerToolPolicy {
 export type McpVersionNegotiation = "legacy" | "auto" | {
     pin: string;
 };
+/**
+ * WS-25, WINTER-OWNED: "this pre-registered client has a secret, stored in the Keychain". It is a MARKER,
+ * not a locator: the Keychain account is DERIVED from the server's canonical URL
+ * (`mcp-oauth-client-secret:<id>`, `/mcp-auth`'s `mcpOAuthClientSecretAccount`), in the host's own service,
+ * and a config can name neither. A config-named account would let any config source -- a trusted
+ * repository's MCP list, copied verbatim into a session -- point the sign-in at ANY Keychain item (a
+ * provider API key) and send it to an authorization server of its choosing as `client_secret`.
+ * `validateServerConfig` refuses any other key (`account`, `service`, a value).
+ */
+export interface McpOAuthSecretRef {
+    kind: "keychain";
+}
+/**
+ * WS-25, WINTER-OWNED: how Winter signs in to ONE remote (http/sse) MCP server over OAuth. Every field is
+ * optional, and so is the block: a server whose authorization server supports Client ID Metadata
+ * Documents or Dynamic Client Registration needs none of it. Tokens NEVER live here -- they live in the
+ * host's Keychain, keyed by the server's canonical URL (`@yanlinglabs/winter-agent-runtime/mcp-auth`'s
+ * `mcpOAuthAccountId`).
+ *
+ * - `clientId` -- a PRE-REGISTERED client (preferred over CIMD and DCR when present).
+ * - `clientSecretRef` -- `{ kind: "keychain" }`: that client has a secret, stored at the DERIVED Keychain
+ *   account (see `McpOAuthSecretRef`).
+ * - `callbackPort` -- the loopback port the sign-in listener binds (`http://127.0.0.1:<port>/callback`);
+ *   a pre-registered client usually needs it fixed. Absent: an ephemeral port (DCR persists it).
+ * - `authServerMetadataUrl` -- the authorization server's RFC 8414 metadata document, for a server that
+ *   publishes no RFC 9728 protected-resource metadata.
+ * - `scopes` -- the scopes to request (absent: the server's own `scopes_supported`).
+ */
+export interface McpOAuthConfig {
+    clientId?: string;
+    clientSecretRef?: McpOAuthSecretRef;
+    callbackPort?: number;
+    authServerMetadataUrl?: string;
+    scopes?: string[];
+}
+/**
+ * WS-25: the runtime -> host `mcp_oauth_refresh` control request (subtype `MCP_OAUTH_REFRESH_SUBTYPE`).
+ * A session never refreshes a token itself when its host answers this: the host (Winter's daemon) is the
+ * ONLY refresher, so a rotating refresh token is posted by one process, once (RFC 9700 §4.14's family
+ * revocation would otherwise punish N sessions refreshing the same token).
+ *
+ * Carries NO material -- names only:
+ * - `server` -- the server's config name in this session (diagnostics; the host may use it to find the
+ *   config);
+ * - `account` -- the FULL Keychain account name of the token item, `mcp-oauth:<id>` (the host keys its
+ *   single-flight on it and derives the client item by the prefix swap `mcp-oauth-client:<id>`);
+ * - `generation` -- the token record's `generation` the session last read. A host that already holds a
+ *   newer generation answers `{ ok: true }` without posting (another session asked first).
+ * - `stepUpScope` -- WS-25, additive: present when the server answered `403 insufficient_scope`. A refresh
+ *   cannot widen a grant (RFC 6749 §6), so the host records the scope on the client registration for the
+ *   next sign-in and answers `needs_auth`.
+ */
+export interface McpOAuthRefreshRequest {
+    server: string;
+    account: string;
+    generation: number;
+    stepUpScope?: string;
+}
+/**
+ * The host's answer. `{ ok: true }` means "re-read the Keychain item"; `needs_auth` means the sign-in is
+ * gone (no refresh token, `invalid_grant`, a revoked client) and the server is marked `needs-auth`;
+ * `transient` means try again later (the network, the authorization server's 5xx).
+ */
+export type McpOAuthRefreshAnswer = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "needs_auth" | "transient";
+};
+/**
+ * WS-25 §7: the runtime -> host `credential_resolve` control request (subtype `CREDENTIAL_RESOLVE_SUBTYPE`),
+ * sent only when `RuntimeConfig.hostCredentials` is set. A session asks its host for ONE Keychain item
+ * instead of reading the Keychain itself (a child reading an item another binary created is what raises
+ * the macOS consent prompt).
+ *
+ * - `ref` -- the Keychain LOCATOR the session was configured with (a provider `authRef`, a tool key's
+ *   ref) or, for an MCP sign-in, `{ kind: "keychain", account: "mcp-oauth:<id>" }`. The host answers ONLY
+ *   for refs that session's `Options` named (plus what its own MCP config implies) -- the allowlist is
+ *   the host's.
+ * - `minGeneration` -- after a 401 (or an expiry): "I hold generation N-1; answer only with N or newer".
+ *   The host refreshes (single-flight, its own job) until it can, or answers `stale`.
+ */
+export interface CredentialResolveRequest {
+    ref: {
+        kind: "keychain";
+        account: string;
+        service?: string;
+    };
+    minGeneration?: number;
+}
+/**
+ * The host's answer. `material` is the item's value EXACTLY as the Keychain would hold it -- a JSON
+ * `CredentialMaterial` for a provider credential, the bare key for a tool secret, the token record JSON
+ * for an MCP sign-in -- with every REFRESH token removed (a session never holds one; MCP records carry
+ * `MCP_OAUTH_HOST_HELD_REFRESH_TOKEN` in its place so the session knows a refresh is possible).
+ * `generation` counts the host's writes of that item. It travels ONLY in this `control_response` frame
+ * over the session's own stdio pipe -- never argv, env, `Options`, a transcript, a log or an error.
+ *
+ * `reason`: `not_found` (no such item -- the session behaves as with an empty Keychain),
+ * `not_allowed` (the ref is outside this session's allowlist), `stale` (no generation >= `minGeneration`
+ * could be produced -- a refresh failed), `unavailable` (retry later).
+ */
+export type CredentialResolveAnswer = {
+    ok: true;
+    material: string;
+    expiresAt?: number;
+    generation: number;
+} | {
+    ok: false;
+    reason: "not_found" | "not_allowed" | "stale" | "unavailable";
+};
 export interface McpStdioServerConfig {
     type?: "stdio";
     command: string;
@@ -137,6 +248,7 @@ export interface McpHttpServerConfig {
     timeout?: number;
     alwaysLoad?: boolean;
     versionNegotiation?: McpVersionNegotiation;
+    oauth?: McpOAuthConfig;
 }
 export interface McpSSEServerConfig {
     type: "sse";
@@ -146,6 +258,7 @@ export interface McpSSEServerConfig {
     timeout?: number;
     alwaysLoad?: boolean;
     versionNegotiation?: McpVersionNegotiation;
+    oauth?: McpOAuthConfig;
 }
 export interface WireMcpToolDefinition {
     name: string;
@@ -357,6 +470,14 @@ export interface RuntimeConfig {
     /** WS-23: `Options.maxOutputTokens`, carried to every main-loop `TurnRequest`. See its own doc. */
     maxOutputTokens?: number;
     keychainService?: string;
+    /**
+     * WS-25 §7 (prompt-free credentials), WINTER-ONLY: `true` when the host answers `credential_resolve`
+     * (`Options.onCredentialResolve`). The runtime then NEVER reads or writes the Keychain for this
+     * session: every `{ kind: "keychain" }` credential, tool key and MCP sign-in is asked of the host over
+     * the control channel, and renewal is the host's (a 401 asks again with `minGeneration`). Absent: the
+     * runtime's own Keychain store, as before (a standalone SDK user). A flag, never material.
+     */
+    hostCredentials?: boolean;
     autoClassifier?: AutoClassifierConfig;
     advisor?: AdvisorConfig;
     /** The wire twin of `Options.web` -- see `WebToolsConfig`. Pure passthrough; absent means every default in `WEB_TOOLS_DEFAULTS`. */

package/dist/query.d.ts

@@ -148,6 +148,17 @@ export interface Query extends AsyncGenerator<SdkMessage> {
     }): Promise<{
         retainedCount: number;
     }>;
+    /**
+     * WS-25 -- reconnect ONE MCP server now (the runtime's `mcp_reconnect` control subtype), and resolve
+     * once it is connected; rejects when the reconnect fails or leaves the server `failed`/`needs-auth`.
+     * The pinned shape (`sdk.d.ts:2668`, `reconnectMcpServer(serverName): Promise<void>`, "throws on
+     * failure"). A host calls it after a sign-in so a `needs-auth` server lists its tools in the live
+     * session -- a reconnect, never a restart of the session.
+     *
+     * OPTIONAL on the interface for the same reason as `compact` (a host's structural `Query` doubles keep
+     * type-checking); every `Query` this package returns has it.
+     */
+    reconnectMcpServer?(serverName: string): Promise<void>;
     /**
      * Phase 6 Task 10 (derived-shapes-p6 item (d), `sdk.d.ts:2566`): the models this session may select.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanlinglabs/winter-agent-sdk",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "license": "MIT",
   "type": "module",
   "engines": {
@@ -45,15 +45,15 @@
     }
   },
   "dependencies": {
-    "@yanlinglabs/winter-provider-catalog": "0.0.28"
+    "@yanlinglabs/winter-provider-catalog": "0.0.30"
   },
   "optionalDependencies": {
-    "@yanlinglabs/winter-agent-sdk-darwin-arm64": "0.0.28"
+    "@yanlinglabs/winter-agent-sdk-darwin-arm64": "0.0.30"
   },
   "devDependencies": {
     "@types/node": "^26.4.0",
-    "@yanlinglabs/winter-agent-runtime": "0.0.28",
-    "@yanlinglabs/winter-conformance": "0.0.28"
+    "@yanlinglabs/winter-agent-runtime": "0.0.30",
+    "@yanlinglabs/winter-conformance": "0.0.30"
   },
   "scripts": {}
 }