@ingram-cloud/sdk 1.4.0 → 1.5.0

package/ts/responses.ts

@@ -25,6 +25,23 @@ export interface ICPaginatedResponse<T> {
 	next_cursor?: string | null;
 }
 
+/** One embedded input from `POST /v1/embeddings`, on the OpenAI wire. */
+export interface ICEmbedding {
+	object: "embedding";
+	index: number;
+	embedding: number[];
+}
+
+/** The `POST /v1/embeddings` response — the OpenAI `list`-of-`embedding` shape.
+ *  Declared inline (not `z.infer`red) because that route is a hand-shaped
+ *  OpenAI-compatible front door with no Zod on the API side to share. */
+export interface ICEmbeddingList {
+	object: "list";
+	data: ICEmbedding[];
+	model: string;
+	usage: { prompt_tokens: number; total_tokens: number };
+}
+
 // ── Re-exported from the hand-authored Zod source of truth (./zod/*) ──────────
 export type {
 	ICAgent,
@@ -34,12 +51,24 @@ export type {
 	ICUiResourceTool,
 } from "./zod/agents.js";
 export type { ICApproval } from "./zod/approvals.js";
+export type {
+	ICAutoreload,
+	ICBalance,
+	ICLedgerEntry,
+	ICOrgUsage,
+	ICOrgUsageProject,
+	ICOrgUsageSeries,
+} from "./zod/billing.js";
 export type { ICBudget, ICBudgetStatus } from "./zod/budgets.js";
 export type { ICCatalogEntry } from "./zod/catalog.js";
 export type { ICConnection } from "./zod/connections.js";
 export type { ICConversation, ICConversationItem } from "./zod/conversations.js";
 export type { ICCustomer } from "./zod/customers.js";
-export type { ICDeployment, ICDeploymentCreated } from "./zod/deployments.js";
+export type {
+	ICDeployment,
+	ICDeploymentCreated,
+	ICInboundEvent,
+} from "./zod/deployments.js";
 export type { ICDiscordApp } from "./zod/discord.js";
 export type { ICEmailConfig } from "./zod/email.js";
 export type { ICFile, ICFileList } from "./zod/files.js";
@@ -48,6 +77,7 @@ export type { ICWorkingMemory, ICRecallHit } from "./zod/memories.js";
 export type {
 	ICSpanKind,
 	ICSpan,
+	ICSpanIn,
 	ICSpanNode,
 	ICTrace,
 	ICTraceDetail,
@@ -55,8 +85,16 @@ export type {
 	ICUsageEvent,
 } from "./zod/observability.js";
 export type { ICProject } from "./zod/projects.js";
-export type { ICRun, ICRunUsage, ICInputMessage, ICRunEvent } from "./zod/runs.js";
+export type { ICActor } from "./zod/_actor.js";
+export type {
+	ICRun,
+	ICRunUsage,
+	ICRunWarning,
+	ICInputMessage,
+	ICRunEvent,
+} from "./zod/runs.js";
 export type { ICSchedule } from "./zod/schedules.js";
+export type { ICSkill, ICSkillVersion, ICSkillReference } from "./zod/skills.js";
 export type { ICSlackApp } from "./zod/slack.js";
 export type { ICSmith } from "./zod/smiths.js";
 export type { ICSmithRevision } from "./zod/smith-revisions.js";

package/ts/scopes.ts

@@ -0,0 +1,57 @@
+/**
+ * The closed permission vocabulary a smith token may carry, in mint order.
+ *
+ * It lives here rather than in the API because it is wire contract: a caller
+ * minting a token has to name the scopes it wants (`permissions` is required —
+ * there is no "grant everything" default), and the console's token form needs
+ * the same list to offer full access. One definition, so a new scope reaches
+ * every minting surface at once instead of drifting into a stale copy.
+ *
+ * Not in here: the admin markers (`tenant:*`, `operator:*`) and the account key
+ * (`organization:*`). Those are postures, not permissions — they are never a
+ * legal `permissions` entry, and the API refuses them as unknown scopes.
+ */
+export const V1_SCOPES = [
+	"runs:read",
+	"runs:write",
+	"conversations:read",
+	"conversations:write",
+	"memories:read",
+	"memories:write",
+	"connections:read",
+	"connections:write",
+	"deployments:read",
+	"deployments:write",
+	"schedules:read",
+	"schedules:write",
+	"approvals:read",
+	"approvals:write",
+	"traces:read",
+	"traces:write",
+	"usage:read",
+	"usage:write",
+	"customers:read",
+	"customers:write",
+	"files:read",
+	"files:write",
+	"vector_stores:read",
+	"vector_stores:write",
+	// Smith-level provider keys (#170, end-user BYOK): an end-user sets their own
+	// key; a tenant token manages any of its smiths' keys.
+	"model_keys:read",
+	"model_keys:write",
+	// Agent Skills (#175): a tenant's skill bundles and their immutable versions.
+	"skills:read",
+	"skills:write",
+	// Embeddings: the stateless text→vector compute endpoint (POST /v1/embeddings).
+	// Write-only — it produces a result, it reads no stored state.
+	"embeddings:write",
+] as const;
+
+export type V1Scope = (typeof V1_SCOPES)[number];
+
+/** The read half of the vocabulary — the scope set for a token that must not
+ *  change anything. Derived, so it cannot fall behind {@link V1_SCOPES}. */
+export const V1_READ_SCOPES: readonly V1Scope[] = V1_SCOPES.filter(
+	(s): s is Extract<V1Scope, `${string}:read`> => s.endsWith(":read"),
+);

package/ts/zod/.impeccable/hook.cache.json

@@ -0,0 +1 @@
+{"version":1,"sessions":{"409c438b-72a6-412d-9a44-013a81c0f846":{"updatedAt":1784658629665,"files":{"/home/adys/src/cloud.ingram.tech/sdk/ts/client.ts":{"editCount":2,"findings":[]}}}}}

package/ts/zod/_actor.ts

@@ -0,0 +1,36 @@
+/**
+ * The acting principal — who a run or an event is attributable to.
+ *
+ * Resolved from the authenticated caller at the point of action and stamped on
+ * the record it produced; never inferred afterwards. Every event a run produces
+ * inherits the run's actor, so a whole turn is attributable to one identity.
+ */
+import { z } from "zod";
+
+export const Actor = z
+	.object({
+		/** `smith` — a smith acted (a smith-bound token, or the smith itself on an
+		 *  autonomous turn); `tenant` — a tenant-admin token acted on a smith's
+		 *  behalf; `operator` — Ingram staff acted through the operator console. */
+		kind: z.enum(["smith", "tenant", "operator"]),
+		/** The smith id, tenant id, or operator email, per `kind`. */
+		id: z.string(),
+		/** `jti` of the token that authorized the action. Empty when no token
+		 *  acted — a scheduled or channel-driven turn the platform ran itself, or a
+		 *  console session, which signs a short-lived per-request token that is never
+		 *  registered. Read it with `email`: both empty means the platform acted. */
+		token_id: z.string(),
+		/** The human behind the action, when one is named — the signed-in console user
+		 *  or the Ingram operator. Empty for a machine caller (an API token, a smith
+		 *  acting for itself) and for autonomous work.
+		 *
+		 *  This is what makes a config change attributable to a *person* rather than to
+		 *  the tenant they share: console mutations all carry `kind: "tenant"`, so
+		 *  without this every colleague's action looked identical. Defaulted rather than
+		 *  optional so records written before it existed read as "no human named"
+		 *  instead of failing to parse. */
+		email: z.string().default(""),
+	})
+	.meta({ id: "Actor" });
+
+export type ICActor = z.infer<typeof Actor>;

package/ts/zod/_page.ts

@@ -1,8 +1,10 @@
 /**
- * The shared cursor-paginated list envelope. One definition so every paginated
- * `/v1` list reads back the same shape: `data` + the opaque `next_cursor` (null
- * on the last page) + `has_more`. The cursor is an opaque, short-lived token —
- * pass it straight back as `?cursor=`, never parse it.
+ * The two `/v1` list envelopes, one definition each. Native resources page by
+ * keyset: `data` + the opaque `next_cursor` (null on the last page) + `has_more`
+ * — the cursor is an opaque, short-lived token; pass it straight back as
+ * `?cursor=`, never parse it. OpenAI-mirrored resources use the OpenAI `list`
+ * envelope instead: `object:"list"` + `first_id`/`last_id` + `has_more`, paged
+ * by passing `last_id` back as `?after=`.
  */
 import { z } from "zod";
 
@@ -16,3 +18,16 @@ export function pageOut<T extends z.ZodTypeAny>(item: T, id: string) {
 		})
 		.meta({ id });
 }
+
+/** Wrap an item schema in the OpenAI `list` envelope, named `id` in the spec. */
+export function oaiListOut<T extends z.ZodTypeAny>(item: T, id: string) {
+	return z
+		.object({
+			object: z.literal("list"),
+			data: z.array(item),
+			first_id: z.string().nullable(),
+			last_id: z.string().nullable(),
+			has_more: z.boolean(),
+		})
+		.meta({ id });
+}

package/ts/zod/agents.ts

@@ -13,6 +13,7 @@
  */
 import { z } from "zod";
 import { pageOut } from "./_page.js";
+import { SkillRef } from "./skills.js";
 
 /** A per-smith variable an agent declares; bound at run time. */
 export const AgentVariable = z
@@ -74,6 +75,8 @@ export const AgentDraft = z
 		vector_store_ids: z.array(z.string()),
 		/** Registered MCP servers this agent's smiths load, by name. Null = all. */
 		mcp_servers: z.array(z.string()).nullable(),
+		/** Skills this agent's smiths carry. Frozen into the snapshot at publish. */
+		skills: z.array(SkillRef),
 		auto_memory: z.boolean().nullable(),
 		memory_consolidation: z.boolean().nullable(),
 		variables: z.array(AgentVariable),
@@ -114,6 +117,7 @@ export const AgentVersionOut = z
 			enabled_hosted_tools: z.array(z.string()).optional(),
 			vector_store_ids: z.array(z.string()).optional(),
 			mcp_servers: z.array(z.string()).nullish(),
+			skills: z.array(SkillRef).optional(),
 			auto_memory: z.boolean().nullish(),
 			memory_consolidation: z.boolean().nullish(),
 			variables: z.array(AgentVariable).optional(),
@@ -125,9 +129,7 @@ export const AgentVersionOut = z
 	})
 	.meta({ id: "AgentVersionOut" });
 
-export const AgentVersionListOut = z
-	.object({ data: z.array(AgentVersionOut) })
-	.meta({ id: "AgentVersionListOut" });
+export const AgentVersionListOut = pageOut(AgentVersionOut, "AgentVersionListOut");
 
 // ── Request bodies ──────────────────────────────────────────────────────────
 
@@ -141,6 +143,7 @@ export const AgentIn = z
 		vector_store_ids: z.array(z.string()).nullish(),
 		/** Scope runs to these registered MCP servers (by name). Null/omitted = all. */
 		mcp_servers: z.array(z.string()).nullish(),
+		skills: z.array(SkillRef).nullish(),
 		auto_memory: z.boolean().nullish(),
 		memory_consolidation: z.boolean().nullish(),
 		variables: z.array(AgentVariable).nullish(),
@@ -157,6 +160,7 @@ export const AgentPatch = z
 		/** Scope runs to these registered MCP servers (by name). An explicit null
 		 *  clears the restriction (= all); omitted leaves it unchanged. */
 		mcp_servers: z.array(z.string()).nullish(),
+		skills: z.array(SkillRef).nullish(),
 		auto_memory: z.boolean().nullish(),
 		memory_consolidation: z.boolean().nullish(),
 		variables: z.array(AgentVariable).nullish(),

package/ts/zod/billing.ts

@@ -0,0 +1,168 @@
+/**
+ * Hand-authored Zod schemas for platform credits — the org wallet the tenant
+ * funds to pay *Ingram* (`/v1/organization/billing/*`). One wallet pools across
+ * all of the org's projects; every endpoint needs an organization-scoped token.
+ *
+ * Source of truth is the handler (`api/src/routes/billing.ts`), which imports
+ * these for request validation and response typing. Amounts are always integer
+ * **minor units** (cents) of `currency` (ISO-4217, lower-case) — never floats.
+ *
+ * The per-endpoint query schemas stay in the handler: they carry OpenAPI
+ * `param` metadata, and the client types query args as plain TS.
+ *
+ * `.meta({ id })` names the component so the emitted OpenAPI references it as
+ * `#/components/schemas/<id>` rather than inlining it.
+ */
+import { z } from "zod";
+
+// ── Balance + ledger ────────────────────────────────────────────────────────
+
+export const BalanceOut = z
+	.object({
+		/** ISO-4217, lower-case. Clients format `balance_cents` in this currency. */
+		currency: z.string(),
+		balance_cents: z.number().int(),
+		/** Whether the org has a Stripe Customer yet (materialized on first payment). */
+		stripe_customer: z.boolean(),
+	})
+	.meta({ id: "BalanceOut" });
+
+/** One credit-ledger row. `amount_cents` is positive for money in (top-ups,
+ *  grants, redeemed codes) and negative for usage debits. */
+export const LedgerEntryOut = z
+	.object({
+		id: z.string(),
+		amount_cents: z.number().int(),
+		currency: z.string(),
+		kind: z.string(),
+		description: z.string(),
+		created_at: z.string().nullable(),
+	})
+	.meta({ id: "LedgerEntryOut" });
+
+/** A page of ledger rows (keyset pagination). */
+export const LedgerListOut = z
+	.object({
+		data: z.array(LedgerEntryOut),
+		next_cursor: z.string().nullable(),
+		has_more: z.boolean(),
+	})
+	.meta({ id: "LedgerListOut" });
+
+// ── Per-project draw from the wallet ────────────────────────────────────────
+
+/** One project's draw for a calendar month — which project is spending the
+ *  shared funds, and against what cap. */
+export const OrgUsageProject = z
+	.object({
+		project_id: z.string(),
+		name: z.string(),
+		/** Credits drawn this period (sum of the project's debit rows). */
+		drawn_cents: z.number().int(),
+		/** Tokens the project's runs consumed this period (priced daily rollup). */
+		tokens: z.number().int(),
+		/** The project's tenant-scope budget limit (billing currency, major units),
+		 *  or null when it draws freely from the org wallet. */
+		budget_limit: z.number().nullable(),
+		budget_action: z.string().nullable(),
+	})
+	.meta({ id: "OrgUsageProject" });
+
+export const OrgUsageOut = z
+	.object({
+		period: z.string(),
+		currency: z.string(),
+		total_drawn_cents: z.number().int(),
+		total_tokens: z.number().int(),
+		projects: z.array(OrgUsageProject),
+	})
+	.meta({ id: "OrgUsageOut" });
+
+/** One day/project draw. Points are sparse — a day with no draw is absent, and
+ *  the client fills the gaps with zero. */
+export const OrgUsageSeriesPoint = z
+	.object({
+		day: z.string(),
+		project_id: z.string(),
+		drawn_cents: z.number().int(),
+	})
+	.meta({ id: "OrgUsageSeriesPoint" });
+
+export const OrgUsageSeriesOut = z
+	.object({
+		currency: z.string(),
+		from: z.string(),
+		to: z.string(),
+		/** Projects with any draw in the window, ranked by total draw. */
+		projects: z.array(z.object({ project_id: z.string(), name: z.string() })),
+		points: z.array(OrgUsageSeriesPoint),
+	})
+	.meta({ id: "OrgUsageSeriesOut" });
+
+// ── Money movement ──────────────────────────────────────────────────────────
+
+export const CheckoutIn = z
+	.object({
+		amount_cents: z.number().int(),
+		/** The console's own origin URL to return to; must carry the Stripe session
+		 *  template so the page can reflect the result. */
+		return_url: z.string(),
+	})
+	.meta({ id: "CheckoutIn" });
+
+export const CheckoutOut = z.object({ url: z.string() }).meta({ id: "CheckoutOut" });
+
+export const ConfirmIn = z.object({ session_id: z.string() }).meta({ id: "ConfirmIn" });
+
+export const ConfirmOut = z
+	.object({ credited: z.boolean(), payment_status: z.string() })
+	.meta({ id: "ConfirmOut" });
+
+/** Add a card with no charge (Stripe setup-mode Checkout); on success it unlocks
+ *  the one-time welcome credit. Same return-url contract as checkout. */
+export const SetupIn = z.object({ return_url: z.string() }).meta({ id: "SetupIn" });
+
+export const SetupOut = z.object({ url: z.string() }).meta({ id: "SetupOut" });
+
+/** Redeem a one-time credit code, matched case-insensitively. */
+export const RedeemIn = z.object({ code: z.string() }).meta({ id: "RedeemIn" });
+
+export const RedeemOut = z
+	.object({
+		amount_cents: z.number().int(),
+		currency: z.string(),
+	})
+	.meta({ id: "RedeemOut" });
+
+export const AutoreloadOut = z
+	.object({
+		enabled: z.boolean(),
+		/** When the balance drops below `threshold_cents`, the saved card is charged
+		 *  for `amount_cents`. Both are integer minor units of the billing currency. */
+		threshold_cents: z.number().int(),
+		amount_cents: z.number().int(),
+	})
+	.meta({ id: "AutoreloadOut" });
+
+/** Set the same shape you read back. */
+export const AutoreloadIn = AutoreloadOut;
+
+/** `amount_cents` is optional — it defaults to the configured auto-reload amount. */
+export const ReloadIn = z
+	.object({ amount_cents: z.number().int().optional() })
+	.meta({ id: "ReloadIn" });
+
+export const ReloadOut = z
+	.object({ credited: z.boolean(), payment_status: z.string() })
+	.meta({ id: "ReloadOut" });
+
+export const PortalOut = z.object({ url: z.string() }).meta({ id: "PortalOut" });
+
+// ── Inferred consumer-facing types (re-exported by ../responses) ─────────────
+
+export type ICBalance = z.infer<typeof BalanceOut>;
+export type ICLedgerEntry = z.infer<typeof LedgerEntryOut>;
+export type ICOrgUsage = z.infer<typeof OrgUsageOut>;
+export type ICOrgUsageProject = z.infer<typeof OrgUsageProject>;
+export type ICOrgUsageSeries = z.infer<typeof OrgUsageSeriesOut>;
+export type ICAutoreload = z.infer<typeof AutoreloadOut>;

package/ts/zod/budgets.ts

@@ -12,6 +12,7 @@
  * `#/components/schemas/<id>` rather than inlining it.
  */
 import { z } from "zod";
+import { pageOut } from "./_page.js";
 
 /** What a budget caps; `agent`/`smith`/`customer` budgets carry the id in
  *  `scope_id` (an agent design, a single smith, or one of your customers). */
@@ -45,9 +46,7 @@ export const BudgetStatusOut = BudgetOut.extend({
 	over: z.boolean(),
 }).meta({ id: "BudgetStatusOut" });
 
-export const BudgetListOut = z
-	.object({ data: z.array(BudgetOut) })
-	.meta({ id: "BudgetListOut" });
+export const BudgetListOut = pageOut(BudgetOut, "BudgetListOut");
 
 // ── Request bodies ──────────────────────────────────────────────────────────
 

package/ts/zod/connections.ts

@@ -18,6 +18,7 @@
  * `#/components/schemas/<id>` rather than inlining it.
  */
 import { z } from "zod";
+import { pageOut } from "./_page.js";
 
 /** OAuth token material the tenant pushes in; IC stores it encrypted and never
  *  echoes it back. Only `kind: "oauth_tokens"` is accepted. */
@@ -44,9 +45,7 @@ export const ConnectionOut = z
 	})
 	.meta({ id: "ConnectionOut" });
 
-export const ConnectionListOut = z
-	.object({ data: z.array(ConnectionOut) })
-	.meta({ id: "ConnectionListOut" });
+export const ConnectionListOut = pageOut(ConnectionOut, "ConnectionListOut");
 
 // ── Request bodies ──────────────────────────────────────────────────────────
 

package/ts/zod/conversations.ts

@@ -17,7 +17,7 @@
  * endpoint.
  */
 import { z } from "zod";
-import { pageOut } from "./_page.js";
+import { oaiListOut } from "./_page.js";
 
 /** A conversation — the OpenAI Conversations object + IC extensions. */
 export const ConversationOut = z
@@ -37,7 +37,8 @@ export const ConversationOut = z
 	})
 	.meta({ id: "ConversationOut" });
 
-export const ConversationListOut = pageOut(ConversationOut, "ConversationListOut");
+/** The conversation list, in OpenAI's `list` envelope (page with `?after=`). */
+export const ConversationListOut = oaiListOut(ConversationOut, "ConversationListOut");
 
 /** The delete acknowledgement, in OpenAI's `*.deleted` shape. */
 export const ConversationDeleted = z
@@ -71,15 +72,10 @@ export const ConversationItem = z
 	.meta({ id: "ConversationItem" });
 
 /** A conversation's items, in OpenAI's `list` envelope (not the IC cursor page). */
-export const ConversationItemListOut = z
-	.object({
-		object: z.literal("list"),
-		data: z.array(ConversationItem),
-		first_id: z.string().nullable(),
-		last_id: z.string().nullable(),
-		has_more: z.boolean(),
-	})
-	.meta({ id: "ConversationItemListOut" });
+export const ConversationItemListOut = oaiListOut(
+	ConversationItem,
+	"ConversationItemListOut",
+);
 
 /** Create body — OpenAI accepts `metadata`; `title` is the IC extension. */
 export const ConversationCreate = z

package/ts/zod/deployments.ts

@@ -112,7 +112,43 @@ export const DeploymentPatch = z
 	})
 	.meta({ id: "DeploymentPatch" });
 
+// ── Inbound events ───────────────────────────────────────────────────────────
+
+/**
+ * One message as it arrived, before anything interpreted it — the immutable
+ * ingest record behind every channel-triggered run, in CloudEvents terms
+ * (`source` / `type` / `subject` / `data`).
+ *
+ * It is recorded before resolution, so an event that matched no smith is here
+ * too, with `smith_id: ""` — "the webhook fired and nothing happened" is a
+ * readable answer, not an absence. `idempotency_key` is the provider's own
+ * delivery id (`Message-Id`, `X-GitHub-Delivery`); a re-delivery of the same key
+ * records once, so this log is also the dedup ledger. `""` throughout means the
+ * source supplied nothing, never "unknown".
+ */
+export const InboundEventOut = z
+	.object({
+		id: z.string(),
+		/** The channel it arrived on: `email`, `telegram`, `slack`, `whatsapp`, … */
+		source: z.string(),
+		/** The provider's event name (`email.received`); `""` if it names none. */
+		type: z.string(),
+		/** The addressed resource — inbox address, channel, repo. */
+		subject: z.string(),
+		/** The provider's delivery id, and this log's dedup key. */
+		idempotency_key: z.string(),
+		/** The smith it woke; `""` when the sender resolved to none. */
+		smith_id: z.string(),
+		/** The provider payload as received. */
+		data: z.record(z.string(), z.unknown()),
+		created_at: z.string().nullable(),
+	})
+	.meta({ id: "InboundEventOut" });
+
+export const InboundEventListOut = pageOut(InboundEventOut, "InboundEventListOut");
+
 // ── Inferred consumer-facing types (re-exported by ../responses) ─────────────
 
 export type ICDeployment = z.infer<typeof DeploymentOut>;
 export type ICDeploymentCreated = z.infer<typeof DeploymentCreatedOut>;
+export type ICInboundEvent = z.infer<typeof InboundEventOut>;

package/ts/zod/files.ts

@@ -11,6 +11,7 @@
  * listed.
  */
 import { z } from "zod";
+import { oaiListOut } from "./_page.js";
 
 /** OpenAI's upload purposes. Vector-store source files are `assistants`. */
 export const FilePurpose = z.enum([
@@ -39,15 +40,7 @@ export const FileOut = z
 	.meta({ id: "FileOut" });
 
 /** Files, in OpenAI's `list` envelope (not the IC cursor page). */
-export const FileListOut = z
-	.object({
-		object: z.literal("list"),
-		data: z.array(FileOut),
-		first_id: z.string().nullable(),
-		last_id: z.string().nullable(),
-		has_more: z.boolean(),
-	})
-	.meta({ id: "FileListOut" });
+export const FileListOut = oaiListOut(FileOut, "FileListOut");
 
 /** The delete acknowledgement, in OpenAI's `*.deleted` shape. */
 export const FileDeleted = z

package/ts/zod/index.ts

@@ -8,9 +8,11 @@
  * when the last one lands, the generated file and the `openapi-zod-client` step
  * are deleted and this becomes the sole `schemas` source.
  */
+export * from "./_actor.js";
 export * from "./_page.js";
 export * from "./agents.js";
 export * from "./approvals.js";
+export * from "./billing.js";
 export * from "./budgets.js";
 export * from "./catalog.js";
 export * from "./connections.js";
@@ -26,6 +28,7 @@ export * from "./observability.js";
 export * from "./projects.js";
 export * from "./runs.js";
 export * from "./schedules.js";
+export * from "./skills.js";
 export * from "./slack.js";
 export * from "./smith-revisions.js";
 export * from "./smiths.js";

package/ts/zod/mcp.ts

@@ -14,6 +14,7 @@
  * emit as `$ref` components rather than inlined objects.
  */
 import { z } from "zod";
+import { pageOut } from "./_page.js";
 
 /** One approval-policy rule: a name glob that gates matching tools behind a
  *  human approval. `require` is always `"approval"` today (the only supported
@@ -71,6 +72,10 @@ export const McpServerOut = z
 		tool_allowlist: z.array(z.string()).nullish(),
 		approval_policy: z.array(ApprovalRule).optional(),
 		tools: z.array(McpTool),
+		/** How many tools this registration currently holds — what a run is offered,
+		 *  before the allow-list gate each tool's own `enabled` reports. Same number on
+		 *  a read as on the register/refresh response that produced it. */
+		tools_discovered: z.number().int(),
 		tools_refreshed_at: z.string().nullable(),
 		/** `degraded` when the edge failed discovery, its secret can't be decoded at
 		 *  run time, or its last `tools/call` failed at the transport level;
@@ -87,20 +92,12 @@ export const McpServerOut = z
 	})
 	.meta({ id: "McpServerOut" });
 
-export const McpServerListOut = z
-	.object({ data: z.array(McpServerOut) })
-	.meta({ id: "McpServerListOut" });
-
-/** Register/replace and refresh echo the server back plus the count of tools
- *  discovered in the just-run `tools/list`. */
-export const McpServerWriteOut = McpServerOut.extend({
-	tools_discovered: z.number().int(),
-}).meta({ id: "McpServerWriteOut" });
+export const McpServerListOut = pageOut(McpServerOut, "McpServerListOut");
 
 // ── Request bodies ──────────────────────────────────────────────────────────
 
-/** Auth block on a register/replace body. `secret` is write-only (a static
- *  bearer) — never echoed back. */
+/** Auth block on a register/replace body. `kind` is `none` | `bearer` | `oauth`;
+ *  `secret` (the shared bearer token) is write-only — never echoed back. */
 export const McpAuthIn = z
 	.object({
 		kind: z.string().nullish(),