@yanlinglabs/winter-agent-sdk 0.0.1 → 0.0.3

package/dist/tools/index.js

@@ -0,0 +1,438 @@
+import {
+  validateToField2,
+  callerAddress2,
+  sendMessage2,
+  formatListing,
+  listAgents2
+} from "../index-51ysrfm8.js";
+import {
+  resolveWinterHome2,
+  WinterCompatibilitySessionStore2
+} from "../index-9e98bg1r.js";
+
+// src/tools/schemas.ts
+var SEND_MESSAGE_TO_MAX = 300;
+var SEND_MESSAGE_SUMMARY_MAX = 200;
+var LIST_AGENTS_FIELD_MAX = 256;
+var NATIVE_SEND_MESSAGE_SCHEMA = {
+  type: "object",
+  properties: {
+    to: { type: "string", maxLength: SEND_MESSAGE_TO_MAX, description: 'no newline, no "*" broadcast' },
+    message: { type: "string", description: 'required; defaults "" for pure idle subscription' },
+    summary: { type: "string", maxLength: SEND_MESSAGE_SUMMARY_MAX },
+    notify_when_idle: { type: "boolean", description: "one-shot; main conversation -> same-machine session only" }
+  },
+  required: ["to", "message"]
+};
+var NATIVE_LIST_AGENTS_SCHEMA = {
+  type: "object",
+  properties: {
+    channel: { type: "string", maxLength: LIST_AGENTS_FIELD_MAX, description: "reserved" },
+    q: { type: "string", maxLength: LIST_AGENTS_FIELD_MAX, description: "reserved" }
+  }
+};
+var NATIVE_LIST_AGENTS_OUTPUT_SCHEMA = {
+  type: "object",
+  properties: { listing: { type: "string" } },
+  required: ["listing"],
+  additionalProperties: false
+};
+var NATIVE_READ_NOTIFICATIONS_SCHEMA = {
+  type: "object",
+  properties: {},
+  additionalProperties: false
+};
+var NATIVE_READ_NOTIFICATIONS_OUTPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    notifications: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          notification_id: { type: "string" },
+          origin: { type: "string" },
+          queued_at: { type: "string" },
+          content: { type: "string" }
+        }
+      }
+    },
+    remaining: { type: "number" }
+  }
+};
+var NATIVE_ADVISOR_SCHEMA = {
+  type: "object",
+  properties: {}
+};
+var NATIVE_ADVISOR_OUTPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    advice: { type: "string" },
+    model: { type: "string" },
+    truncated: { type: "boolean" }
+  },
+  required: ["advice", "model"]
+};
+// src/tools/definitions.ts
+var SEND_MESSAGE_DEFINITION = {
+  toolName: "send_message",
+  builtinName: "SendMessage",
+  description: "Resolves `to` against child registry, teammates, live peer registry; steers a running child, resumes an addressable completed/stopped child, wakes an idle live peer, queues for a running peer; never cold-resumes an arbitrary exited transcript.",
+  searchHint: "send message agent session peer child steer resume notify idle",
+  inputSchema: NATIVE_SEND_MESSAGE_SCHEMA,
+  permissionClass: "messaging"
+};
+var LIST_AGENTS_DEFINITION = {
+  toolName: "list_agents",
+  builtinName: "ListAgents",
+  description: "Names/refs, activity/status, addressing identity for children, teammates, eligible live peers; never an enumeration of exited transcripts.",
+  searchHint: "list agents sessions peers children roster reachable",
+  inputSchema: NATIVE_LIST_AGENTS_SCHEMA,
+  outputSchema: NATIVE_LIST_AGENTS_OUTPUT_SCHEMA,
+  permissionClass: "messaging"
+};
+var READ_NOTIFICATIONS_DEFINITION = {
+  toolName: "read_notifications",
+  builtinName: "ReadNotifications",
+  description: "Drains Winter's own global-messaging notification queue ([WS-10]).",
+  inputSchema: NATIVE_READ_NOTIFICATIONS_SCHEMA,
+  outputSchema: NATIVE_READ_NOTIFICATIONS_OUTPUT_SCHEMA,
+  permissionClass: "messaging"
+};
+var ADVISOR_DEFINITION = {
+  toolName: "advisor",
+  builtinName: "advisor",
+  description: "Consults a stronger reviewer model over this session's own conversation/tool history (provider-opaque state such as encrypted_content is never included). Reviewer unavailable/timeout -> ordinary tool error; never blocks the turn.",
+  inputSchema: NATIVE_ADVISOR_SCHEMA,
+  outputSchema: NATIVE_ADVISOR_OUTPUT_SCHEMA,
+  permissionClass: "mcp"
+};
+var WINTER_DEFAULT_TOOL_DEFINITIONS = [
+  SEND_MESSAGE_DEFINITION,
+  LIST_AGENTS_DEFINITION,
+  READ_NOTIFICATIONS_DEFINITION,
+  ADVISOR_DEFINITION
+];
+// src/tools/accept.ts
+var SEND_MESSAGE_FIELDS = new Set(Object.keys(NATIVE_SEND_MESSAGE_SCHEMA.properties ?? {}));
+var LIST_AGENTS_FIELDS = new Set(Object.keys(NATIVE_LIST_AGENTS_SCHEMA.properties ?? {}));
+function unknownFields(record, allowed) {
+  return Object.keys(record).filter((key) => !allowed.has(key));
+}
+function asRecord(input) {
+  return typeof input === "object" && input !== null && !Array.isArray(input) ? input : undefined;
+}
+function acceptNativeSendMessageArgs(input) {
+  const record = asRecord(input);
+  if (record === undefined)
+    return { ok: false, reason: "expected an object of SendMessage arguments" };
+  const extra = unknownFields(record, SEND_MESSAGE_FIELDS);
+  if (extra.length > 0)
+    return { ok: false, reason: `unknown argument(s): ${extra.join(", ")}` };
+  const to = record["to"];
+  const validated = validateToField2(to);
+  if (!validated.ok)
+    return { ok: false, reason: validated.message };
+  const message = record["message"];
+  if (typeof message !== "string")
+    return { ok: false, reason: "`message` is required and must be a string (an empty string is a pure idle subscription)" };
+  const notify = record["notify_when_idle"];
+  if (notify !== undefined && typeof notify !== "boolean")
+    return { ok: false, reason: "`notify_when_idle` must be a boolean" };
+  if (message.length === 0 && notify !== true) {
+    return { ok: false, reason: "`message` may only be empty when `notify_when_idle` is true (a pure idle subscription, WS-10 §10.1)" };
+  }
+  const summary = record["summary"];
+  if (summary !== undefined && typeof summary !== "string")
+    return { ok: false, reason: "`summary` must be a string" };
+  const capped = summary === undefined ? undefined : summary.slice(0, SEND_MESSAGE_SUMMARY_MAX);
+  return {
+    ok: true,
+    args: {
+      to,
+      message,
+      ...capped === undefined ? {} : { summary: capped },
+      ...notify === undefined ? {} : { notify_when_idle: notify }
+    }
+  };
+}
+function acceptNativeListAgentsArgs(input) {
+  if (input === undefined || input === null)
+    return { ok: true, args: {} };
+  const record = asRecord(input);
+  if (record === undefined)
+    return { ok: false, reason: "expected an object of ListAgents arguments" };
+  const extra = unknownFields(record, LIST_AGENTS_FIELDS);
+  if (extra.length > 0)
+    return { ok: false, reason: `unknown argument(s): ${extra.join(", ")}` };
+  for (const field of ["channel", "q"]) {
+    const value = record[field];
+    if (value !== undefined && (typeof value !== "string" || value.length > LIST_AGENTS_FIELD_MAX)) {
+      return { ok: false, reason: `\`${field}\` must be a string of at most ${LIST_AGENTS_FIELD_MAX} characters` };
+    }
+  }
+  return {
+    ok: true,
+    args: {
+      ...typeof record["channel"] === "string" ? { channel: record["channel"] } : {},
+      ...typeof record["q"] === "string" ? { q: record["q"] } : {}
+    }
+  };
+}
+function acceptNativeReadNotificationsArgs(input) {
+  if (input === undefined || input === null)
+    return { ok: true, args: {} };
+  const record = asRecord(input);
+  if (record === undefined)
+    return { ok: false, reason: "expected an empty object of ReadNotifications arguments" };
+  const extra = Object.keys(record);
+  if (extra.length > 0)
+    return { ok: false, reason: `unknown argument(s): ${extra.join(", ")} (ReadNotifications takes no arguments)` };
+  return { ok: true, args: {} };
+}
+function deriveSendMessageSummary(rawSummary, message) {
+  if (rawSummary !== undefined)
+    return rawSummary.slice(0, SEND_MESSAGE_SUMMARY_MAX);
+  const firstLine = (message.split(`
+`)[0] ?? "").trim();
+  if (firstLine.length === 0)
+    return;
+  return firstLine.slice(0, SEND_MESSAGE_SUMMARY_MAX);
+}
+// src/tools/port.ts
+var fallbackCounter = 0;
+function fallbackToolUseId() {
+  return `no-tool-use-id-${++fallbackCounter}-${Date.now()}`;
+}
+function callerFromAddress(from, originToolCallId) {
+  return {
+    sessionId: from.parentWinterSessionId ?? from.winterSessionId,
+    ...from.objectKind === "agent" && from.childId !== undefined ? { agentId: from.childId } : {},
+    toolUseId: originToolCallId ?? fallbackToolUseId()
+  };
+}
+function messagingToolPortFromRuntimeDeps(deps) {
+  return {
+    async sendDetailed(request) {
+      const caller = callerFromAddress(request.from, request.originToolCallId);
+      return sendMessage2(deps, caller, {
+        to: request.to,
+        message: request.body,
+        ...request.summary === undefined ? {} : { summary: request.summary },
+        ...request.notifyWhenIdle === undefined ? {} : { notify_when_idle: request.notifyWhenIdle }
+      });
+    },
+    async listReachable(scope) {
+      const { rows } = await listAgents2(deps, { sessionId: scope.from.parentWinterSessionId ?? scope.from.winterSessionId }, {});
+      return rows;
+    },
+    readNotifications(sessionId) {
+      return deps.notifications.drain(sessionId);
+    }
+  };
+}
+// src/tools/messaging-handlers.ts
+var VENDOR_TOOL_USE_ID_META_KEY = "claudecode/toolUseId";
+function toolUseIdFromExtra(extra) {
+  if (typeof extra !== "object" || extra === null)
+    return;
+  const meta = extra._meta;
+  if (typeof meta !== "object" || meta === null)
+    return;
+  const id = meta[VENDOR_TOOL_USE_ID_META_KEY];
+  return typeof id === "string" && id.length > 0 ? id : undefined;
+}
+var MODEL_FACING_FAILURES = new Set(["refused", "ambiguous", "not_found", "unavailable"]);
+function text(body, isError = false) {
+  return { text: body, ...isError ? { isError: true } : {} };
+}
+function describe(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function guarded(what, run) {
+  try {
+    return await run();
+  } catch (err) {
+    return text(`Error: ${what}: ${describe(err)}`, true);
+  }
+}
+function createMessagingToolHandlers(port, caller) {
+  const identity = () => typeof caller === "function" ? caller() : caller;
+  return {
+    async sendMessage(rawArgs, extra) {
+      const accepted = acceptNativeSendMessageArgs(rawArgs);
+      if (!accepted.ok)
+        return text(accepted.reason, true);
+      const bound = identity();
+      const perCall = toolUseIdFromExtra(extra);
+      const who = perCall === undefined ? bound : { ...bound, toolUseId: perCall };
+      const summary = deriveSendMessageSummary(accepted.args.summary, accepted.args.message);
+      return guarded("SendMessage could not reach the messaging system", async () => {
+        const result = await port.sendDetailed({
+          from: callerAddress2(who),
+          to: accepted.args.to,
+          body: accepted.args.message,
+          ...summary === undefined ? {} : { summary },
+          ...accepted.args.notify_when_idle === undefined ? {} : { notifyWhenIdle: accepted.args.notify_when_idle },
+          ...who.toolUseId === undefined ? {} : { originToolCallId: who.toolUseId }
+        });
+        const payload = result.notify === undefined ? result.outcome : { ...result.outcome, notify: result.notify };
+        return text(JSON.stringify(payload), MODEL_FACING_FAILURES.has(result.outcome.status));
+      });
+    },
+    async listAgents(rawArgs) {
+      const accepted = acceptNativeListAgentsArgs(rawArgs);
+      if (!accepted.ok)
+        return text(accepted.reason, true);
+      return guarded("ListAgents could not reach the messaging system", async () => {
+        const rows = await port.listReachable({ from: callerAddress2(identity()) });
+        return text(JSON.stringify({ listing: formatListing(rows) }));
+      });
+    },
+    async readNotifications(rawArgs) {
+      const accepted = acceptNativeReadNotificationsArgs(rawArgs);
+      if (!accepted.ok)
+        return text(accepted.reason, true);
+      return guarded("ReadNotifications could not drain the notification queue", () => {
+        const { notifications, remaining } = port.readNotifications(identity().sessionId);
+        return text(JSON.stringify({ notifications, remaining }));
+      });
+    }
+  };
+}
+// src/tools/advisor.ts
+var ADVISOR_DEFAULT_MAX_CHARS = 20000;
+var OPAQUE_MARKERS = ["encrypted_content", "reasoning_item", "signature", "thinking", "redacted_thinking"];
+function stripOpaqueMarkers(text) {
+  return text.split(`
+`).filter((line) => !OPAQUE_MARKERS.some((marker) => line.toLowerCase().includes(marker))).join(`
+`);
+}
+function assembleReviewerMessages(entries, maxChars = ADVISOR_DEFAULT_MAX_CHARS) {
+  const cleaned = entries.map((e) => ({ role: e.role, text: stripOpaqueMarkers(e.text) }));
+  const kept = [];
+  let total = 0;
+  let truncated = false;
+  for (let i = cleaned.length - 1;i >= 0; i--) {
+    const entry = cleaned[i];
+    if (!entry)
+      continue;
+    if (total + entry.text.length > maxChars) {
+      if (kept.length === 0) {
+        kept.unshift({ role: entry.role, text: entry.text.slice(Math.max(0, entry.text.length - maxChars)) });
+      }
+      truncated = true;
+      break;
+    }
+    kept.unshift(entry);
+    total += entry.text.length;
+  }
+  return { messages: kept.map((e) => ({ role: e.role, content: e.text })), truncated };
+}
+function error(body) {
+  return { text: body, isError: true };
+}
+function describe2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function createAdvisorToolHandler(deps) {
+  return async () => {
+    let reviewer;
+    try {
+      reviewer = deps.resolveReviewer();
+    } catch (err) {
+      return error(`Error: advisor failed to resolve a reviewer model: ${describe2(err)}`);
+    }
+    if (!reviewer) {
+      return error(`Error: advisor is unavailable -- no reviewer model is resolvable in this session's provider catalog (WS-06 §4: "Reviewer unavailable/timeout -> ordinary tool error; never blocks the turn").`);
+    }
+    let entries;
+    try {
+      entries = await deps.transcriptSource.getEntries();
+    } catch (err) {
+      return error(`Error: advisor failed to assemble the session transcript: ${describe2(err)}`);
+    }
+    const { messages, truncated } = assembleReviewerMessages(entries, deps.maxChars ?? ADVISOR_DEFAULT_MAX_CHARS);
+    let turn;
+    try {
+      turn = await reviewer.provider.generate({ messages });
+    } catch (err) {
+      return error(`Error: advisor's reviewer model failed: ${describe2(err)}`);
+    }
+    if (turn.kind !== "text" || typeof turn.text !== "string") {
+      return error(`Error: advisor's reviewer model returned a non-text response (kind: "${turn.kind}"); advisor has no tool-execution loop to act on it.`);
+    }
+    return { text: JSON.stringify({ advice: turn.text, model: reviewer.model, ...truncated ? { truncated: true } : {} }) };
+  };
+}
+function entryText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return;
+  const parts = content.flatMap((block) => {
+    if (typeof block !== "object" || block === null)
+      return [];
+    const record = block;
+    return record.type === "text" && typeof record.text === "string" ? [record.text] : [];
+  });
+  return parts.length === 0 ? undefined : parts.join(`
+`);
+}
+function toTranscriptEntry(entry) {
+  if (entry.type !== "user" && entry.type !== "assistant")
+    return;
+  const message = entry["message"];
+  if (typeof message !== "object" || message === null)
+    return;
+  const text = entryText(message.content);
+  if (text === undefined || text.length === 0)
+    return;
+  return { role: entry.type, text };
+}
+function transcriptSourceForSessionKey(key, opts = {}) {
+  const store = opts.store ?? new WinterCompatibilitySessionStore2({ winterHome: opts.winterHome ?? resolveWinterHome2() });
+  return {
+    async getEntries() {
+      const entries = await store.load(key);
+      if (entries === null)
+        return [];
+      return entries.flatMap((entry) => {
+        const mapped = toTranscriptEntry(entry);
+        return mapped === undefined ? [] : [mapped];
+      });
+    }
+  };
+}
+export {
+  ADVISOR_DEFAULT_MAX_CHARS,
+  ADVISOR_DEFINITION,
+  LIST_AGENTS_DEFINITION,
+  LIST_AGENTS_FIELD_MAX,
+  NATIVE_ADVISOR_OUTPUT_SCHEMA,
+  NATIVE_ADVISOR_SCHEMA,
+  NATIVE_LIST_AGENTS_OUTPUT_SCHEMA,
+  NATIVE_LIST_AGENTS_SCHEMA,
+  NATIVE_READ_NOTIFICATIONS_OUTPUT_SCHEMA,
+  NATIVE_READ_NOTIFICATIONS_SCHEMA,
+  NATIVE_SEND_MESSAGE_SCHEMA,
+  OPAQUE_MARKERS,
+  READ_NOTIFICATIONS_DEFINITION,
+  SEND_MESSAGE_DEFINITION,
+  SEND_MESSAGE_SUMMARY_MAX,
+  SEND_MESSAGE_TO_MAX,
+  VENDOR_TOOL_USE_ID_META_KEY,
+  WINTER_DEFAULT_TOOL_DEFINITIONS,
+  acceptNativeListAgentsArgs,
+  acceptNativeReadNotificationsArgs,
+  acceptNativeSendMessageArgs,
+  assembleReviewerMessages,
+  callerAddress2 as callerAddress,
+  createAdvisorToolHandler,
+  createMessagingToolHandlers,
+  deriveSendMessageSummary,
+  messagingToolPortFromRuntimeDeps,
+  stripOpaqueMarkers,
+  toolUseIdFromExtra,
+  transcriptSourceForSessionKey
+};

package/dist/tools/messaging-handlers.d.ts

@@ -0,0 +1,52 @@
+import { type MessagingToolPort } from "./port.js";
+/**
+ * WHO IS CALLING — bound at registration, never read out of the arguments.
+ *
+ * The standing MCP server is materialized per session (WS-14 §11), so the caller is known when the
+ * handler is built. Taking it from the ARGUMENTS instead would make the sender's identity something
+ * a model could write, and every fence in the messaging core — the owning-parent rule, the
+ * self-target refusal, WS-10 §13's sender class, WS-15 §6.2's dedupe key — is keyed on it.
+ *
+ * `toolUseId` is the second half of WS-10 §12's retry key, and it is OPTIONAL because a host that
+ * cannot supply one exists: it gets no dedupe, stated at the door rather than faked with a
+ * stable-looking key that would make two different messages one.
+ */
+export interface WinterToolCaller {
+    sessionId: string;
+    agentId?: string;
+    toolUseId?: string;
+}
+/** The host-neutral tool result: one text body, plus whether the model should read it as a failure. */
+export interface WinterToolResult {
+    text: string;
+    isError?: boolean;
+}
+export type WinterToolHandler = (args: unknown, extra?: unknown) => Promise<WinterToolResult>;
+export interface MessagingToolHandlers {
+    sendMessage: WinterToolHandler;
+    listAgents: WinterToolHandler;
+    readNotifications: WinterToolHandler;
+}
+/**
+ * WS-10 §12's RETRY KEY, on the official branch — and it exists, which was not known until it was
+ * measured.
+ *
+ * §12 wants a message id derived from (sender session, TOOL-CALL id) so "a retry allocates the SAME
+ * id" and returns the stored outcome instead of starting a second turn. On the Winter branch the
+ * caller binds `toolUseId` at registration. On the official branch the handler is inside the
+ * vendor's in-process MCP server, where the only per-call channel is the second argument the vendor
+ * passes — and the reasonable expectation was that it carries MCP request context (a JSON-RPC
+ * request id, `_meta`) rather than an Anthropic-API `tool_use_id`, which is one layer up.
+ *
+ * THE PINNED RUNTIME BRIDGES THEM. Measured on 0.3.250: `extra._meta["claudecode/toolUseId"]` is the
+ * exact id the model emitted. So the official branch gets a real §12 key rather than depending on
+ * the rapid-repeat guard, and the vendor's own namespaced `_meta` name is read rather than guessed.
+ *
+ * A VENDOR-NAMESPACED KEY IS NEVER REBRANDED (WS-01 §5): `claudecode/toolUseId` is the vendor's name
+ * for the vendor's field, exactly like `CLAUDE_CONFIG_DIR`. It is read defensively — an absent or
+ * non-string value simply falls back to the bound caller's id — because a future pin may move it,
+ * and losing the key must degrade to today's behaviour rather than to a crash.
+ */
+export declare const VENDOR_TOOL_USE_ID_META_KEY = "claudecode/toolUseId";
+export declare function toolUseIdFromExtra(extra: unknown): string | undefined;
+export declare function createMessagingToolHandlers(port: MessagingToolPort, caller: WinterToolCaller | (() => WinterToolCaller)): MessagingToolHandlers;

package/dist/tools/port.d.ts

@@ -0,0 +1,39 @@
+import { callerAddress, type ListedRuntimeObject, type MessagingRuntimeDeps, type NotificationRecord, type RuntimeAddress, type SendMessageResult } from "../messaging/index.js";
+export interface MessagingToolPort {
+    sendDetailed(request: {
+        from: RuntimeAddress;
+        to: string;
+        body: string;
+        summary?: string;
+        notifyWhenIdle?: boolean;
+        originToolCallId?: string;
+    }): Promise<SendMessageResult>;
+    listReachable(scope: {
+        from: RuntimeAddress;
+    }): Promise<ListedRuntimeObject[]>;
+    readNotifications(sessionId: string): {
+        notifications: NotificationRecord[];
+        remaining: number;
+    };
+}
+/**
+ * The Winter-runtime side of the port: `MessagingRuntimeDeps` in, `MessagingToolPort` out.
+ *
+ * `listReachable` goes through the core's own `listAgents` rather than straight to
+ * `deps.adapter.listReachable`, because the core is where the self-exclusion rule lives (WS-10
+ * §10.2) — so the handlers never filter again (they are the layer least able to know the caller's
+ * real address).
+ *
+ * WHAT THAT FILTER ACTUALLY EXCLUDES, stated precisely rather than as "never yourself" (whole-branch
+ * fix wave). The `from` address is resolved to its OWNING SESSION before the core is asked, and the
+ * core drops the row matching that session address. For a top-level caller those are the same thing
+ * and the rule reads as written. For a CHILD caller (`agent:<parent>:<child>`) they are not: the
+ * scope collapses to `session:<parent>`, so the child's OWN `agent:` row can still appear in the
+ * listing it gets back. The router's handle filters the same way, by the address it was scoped with.
+ *
+ * Pre-existing on both branches and left alone here deliberately — this round changed no behaviour,
+ * and the fix belongs where the resolution happens, not in a re-filter bolted onto the port.
+ * Ledgered for the 0.0.4 patch wave.
+ */
+export declare function messagingToolPortFromRuntimeDeps(deps: MessagingRuntimeDeps): MessagingToolPort;
+export { callerAddress };

package/dist/tools/schemas.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The self-describing shape a tool schema is stored and served as.
+ *
+ * Deliberately structural and permissive rather than a full JSON Schema type: neither host validates
+ * model input against these at all (the Winter registry's own type is explicitly "self-describing…
+ * not a validator" — the ACCEPTORS in `accept.ts` are what enforce the contract). What matters is
+ * that the advertised bytes are one object, in one place.
+ */
+export interface JsonSchemaObject {
+    type: "object";
+    properties?: Record<string, unknown>;
+    required?: readonly string[];
+    additionalProperties?: boolean;
+}
+/** WS-10 §10.1's bounds. `to`'s own limit is the messaging subpath's; this is the copy the SCHEMA advertises. */
+export declare const SEND_MESSAGE_TO_MAX = 300;
+export declare const SEND_MESSAGE_SUMMARY_MAX = 200;
+/** WS-10 §10.2's bound on both reserved `ListAgents` fields. */
+export declare const LIST_AGENTS_FIELD_MAX = 256;
+export declare const NATIVE_SEND_MESSAGE_SCHEMA: JsonSchemaObject;
+export declare const NATIVE_LIST_AGENTS_SCHEMA: JsonSchemaObject;
+/**
+ * WS-10 §10.2: "`ListAgents` output is EXACTLY `{ listing: string }`."
+ *
+ * "Exactly" is spelled `additionalProperties: false` here, which neither former copy said out loud
+ * (both merely listed the one property). It is the whole content of §10.2's sentence, and it is the
+ * half a reader of the schema alone would otherwise have to take on trust.
+ */
+export declare const NATIVE_LIST_AGENTS_OUTPUT_SCHEMA: JsonSchemaObject;
+/** WS-06 §3.6: the ordinary call is `{}` and nothing else. */
+export declare const NATIVE_READ_NOTIFICATIONS_SCHEMA: JsonSchemaObject;
+/**
+ * The drained PAGE, not one notification: the pinned vendor shape is an ARRAY per call plus what is
+ * left behind, so a model that drains knows whether to drain again.
+ */
+export declare const NATIVE_READ_NOTIFICATIONS_OUTPUT_SCHEMA: JsonSchemaObject;
+/**
+ * WS-06 §4: input is `{}` — the runtime forwards the session's own history; no model-supplied
+ * parameters.
+ *
+ * NO `additionalProperties` KEY, DELIBERATELY. Neither host validates model input against a JSON
+ * Schema, so the keyword would be decorative — and the posture is applied uniformly across the
+ * parameterless tools rather than declared on one and not the others. The ACCEPTOR is where "no
+ * more" is actually enforced (ruling P-4), and it is enforced for `read_notifications` too, whose
+ * schema does carry the keyword because its pinned vendor shape does.
+ */
+export declare const NATIVE_ADVISOR_SCHEMA: JsonSchemaObject;
+export declare const NATIVE_ADVISOR_OUTPUT_SCHEMA: JsonSchemaObject;

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanlinglabs/winter-agent-sdk",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "license": "MIT",
   "type": "module",
   "engines": {
@@ -21,6 +21,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./messaging": {
+      "types": "./dist/messaging/index.d.ts",
+      "default": "./dist/messaging/index.js"
+    },
+    "./tools": {
+      "types": "./dist/tools/index.d.ts",
+      "default": "./dist/tools/index.js"
     }
   },
   "files": [
@@ -37,15 +45,15 @@
     }
   },
   "dependencies": {
-    "@yanlinglabs/winter-provider-catalog": "0.0.1"
+    "@yanlinglabs/winter-provider-catalog": "0.0.3"
   },
   "optionalDependencies": {
-    "@yanlinglabs/winter-agent-sdk-darwin-arm64": "0.0.1"
+    "@yanlinglabs/winter-agent-sdk-darwin-arm64": "0.0.3"
   },
   "devDependencies": {
     "@types/node": "^26.4.0",
-    "@yanlinglabs/winter-conformance": "0.0.1",
-    "winter-agent-runtime": "0.0.1"
+    "@yanlinglabs/winter-conformance": "0.0.3",
+    "winter-agent-runtime": "0.0.3"
   },
   "scripts": {}
 }