@ingram-cloud/sdk 1.4.0 → 1.6.0

package/dist/zod/agents.js

@@ -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
     .object({
@@ -69,6 +70,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),
@@ -106,6 +109,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(),
@@ -116,9 +120,7 @@ export const AgentVersionOut = z
     created_at: z.string().nullable(),
 })
     .meta({ id: "AgentVersionOut" });
-export const AgentVersionListOut = z
-    .object({ data: z.array(AgentVersionOut) })
-    .meta({ id: "AgentVersionListOut" });
+export const AgentVersionListOut = pageOut(AgentVersionOut, "AgentVersionListOut");
 // ── Request bodies ──────────────────────────────────────────────────────────
 export const AgentIn = z
     .object({
@@ -130,6 +132,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(),
@@ -145,6 +148,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/dist/zod/approvals.js

@@ -27,6 +27,15 @@ export const ApprovalOut = z
     tool: z.string().nullable(),
     /** The tool-call arguments awaiting a decision; `{}` when none. */
     args: z.record(z.string(), z.unknown()),
+    /** Set when the pause is a remote MCP tool asking the end-user for input
+     *  (not a gate before a tool runs): the prompt and the JSON Schema the
+     *  answer must match. Approve with `content` to answer it. */
+    elicitation: z
+        .object({
+        message: z.string(),
+        requested_schema: z.record(z.string(), z.unknown()),
+    })
+        .nullable(),
     /** pending | approved | rejected. */
     status: z.string(),
     actor: z.string().nullable(),

package/dist/zod/billing.js

@@ -0,0 +1,136 @@
+/**
+ * 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" });

package/dist/zod/budgets.js

@@ -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). */
 export const BudgetScope = z.enum(["tenant", "agent", "smith", "customer"]);
@@ -40,9 +41,7 @@ export const BudgetStatusOut = BudgetOut.extend({
     pct: z.number(),
     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 ──────────────────────────────────────────────────────────
 export const BudgetIn = z
     .object({

package/dist/zod/connections.js

@@ -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. */
 export const Credential = z
@@ -41,9 +42,7 @@ export const ConnectionOut = z
     created_at: z.string().nullable(),
 })
     .meta({ id: "ConnectionOut" });
-export const ConnectionListOut = z
-    .object({ data: z.array(ConnectionOut) })
-    .meta({ id: "ConnectionListOut" });
+export const ConnectionListOut = pageOut(ConnectionOut, "ConnectionListOut");
 // ── Request bodies ──────────────────────────────────────────────────────────
 export const ConnectionIn = z
     .object({

package/dist/zod/conversations.js

@@ -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
     .object({
@@ -35,7 +35,8 @@ export const ConversationOut = z
     metadata: z.record(z.string(), z.unknown()),
 })
     .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
     .object({
@@ -66,15 +67,7 @@ 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
     .object({

package/dist/zod/deployments.js

@@ -103,3 +103,35 @@ export const DeploymentPatch = z
     owner_email: z.string().nullish(),
 })
     .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");

package/dist/zod/files.js

@@ -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([
     "assistants",
@@ -36,15 +37,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
     .object({

package/dist/zod/index.js

@@ -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/dist/zod/mcp.js

@@ -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
  *  value); arg-conditional (`when`) gating is rejected, not stored. */
@@ -66,6 +67,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;
@@ -81,17 +86,10 @@ export const McpServerOut = z
     created_at: z.string().nullable(),
 })
     .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(),

package/dist/zod/observability.js

@@ -23,14 +23,7 @@ import { pageOut } from "./_page.js";
 /** Span kinds emitted by the observability backend. `retrieval` covers vector-store
  *  search (the hosted `file_search` tool, and externally-pushed RAG spans). */
 export const ICSpanKindEnum = z
-    .enum([
-    "run",
-    "model_call",
-    "tool_call",
-    "memory_op",
-    "retrieval",
-    "runtime_event",
-])
+    .enum(["run", "model_call", "tool_call", "memory_op", "retrieval", "runtime_event"])
     .meta({ id: "SpanKind" });
 /** A single timed unit of work inside a trace. */
 export const SpanOut = z
@@ -61,7 +54,10 @@ export const SpanNodeOut = SpanOut.extend({
 export const TraceOut = z
     .object({
     id: z.string(),
-    smith_id: z.string(),
+    /** Null for a trace no smith owns — an external `/v1/traces:ingest` under a
+     *  tenant token attributes to none. Such a trace is tenant-scope only: a
+     *  smith-bound token cannot read it. */
+    smith_id: z.string().nullable(),
     app_id: z.string().nullable(),
     run_id: z.string().nullable(),
     root_kind: ICSpanKindEnum,
@@ -82,24 +78,32 @@ export const TraceDetailOut = TraceOut.extend({
 }).meta({ id: "TraceDetailOut" });
 export const TraceListOut = pageOut(TraceOut, "TraceListOut");
 /** Aggregated usage grouped by app, smith, model, or customer. */
+/** The token/cost amounts a usage bucket reports. `tokens` is the grand total
+ *  (input + output); `input_tokens` is the input slice, and `cache_read_tokens`
+ *  / `cache_write_tokens` are sub-slices of input (reads served from the
+ *  provider's prompt cache, writes billed at the cache-write premium). The cache
+ *  hit rate is `cache_read_tokens / input_tokens`. */
+const UsageAmounts = z.object({
+    tokens: z.number(),
+    input_tokens: z.number(),
+    cache_read_tokens: z.number(),
+    cache_write_tokens: z.number(),
+    cost: z.number(),
+    run_count: z.number(),
+});
 export const UsageBreakdownOut = z
     .object({
     group_by: z.enum(["app", "smith", "model", "customer"]),
-    totals: z.object({
-        tokens: z.number(),
-        cost: z.number(),
-        run_count: z.number(),
-    }),
-    groups: z.array(z.object({
+    totals: UsageAmounts,
+    groups: z.array(z
+        .object({
         app: z.string().nullable().optional(),
         smith: z.string().nullable().optional(),
         model: z.string().nullable().optional(),
         // Customer-grouped views label unassigned usage `principal:<smith id>`.
         customer: z.string().nullable().optional(),
-        tokens: z.number(),
-        cost: z.number(),
-        run_count: z.number(),
-    })),
+    })
+        .extend(UsageAmounts.shape)),
     /** Custom billable events aggregated per meter over the same filters. */
     meters: z
         .array(z.object({
@@ -132,3 +136,18 @@ export const UsageEventListOut = z
     has_more: z.boolean(),
 })
     .meta({ id: "UsageEventListOut" });
+// ── Span ingestion (POST /v1/traces:ingest) ─────────────────────────────────
+/** The request body for span ingestion (externally-pushed spans / OTel).
+ *
+ *  Deliberately permissive: the handler normalizes rather than rejects — an
+ *  unrecognized `kind` degrades to `runtime_event`, missing ids and timestamps
+ *  are generated. Validating {@link ICSpanIn} here would 422 exactly the sloppy
+ *  exporter payloads the endpoint exists to absorb. `ICSpanIn` documents the
+ *  shape for callers; the wire stays open. */
+export const TraceIngestIn = z
+    .object({ spans: z.array(z.record(z.string(), z.unknown())).optional() })
+    .meta({ id: "TraceIngestIn" });
+/** The 202 ack for span ingestion: how many spans were written. */
+export const TraceIngestOut = z
+    .object({ accepted: z.number().int() })
+    .meta({ id: "TraceIngestOut" });

package/dist/zod/projects.js

@@ -12,6 +12,7 @@
  * `#/components/schemas/<id>` rather than inlining it.
  */
 import { z } from "zod";
+import { pageOut } from "./_page.js";
 export const ProjectOut = z
     .object({
     id: z.string(),
@@ -24,9 +25,7 @@ export const ProjectOut = z
     archived_at: z.string().nullable(),
 })
     .meta({ id: "ProjectOut" });
-export const ProjectListOut = z
-    .object({ data: z.array(ProjectOut) })
-    .meta({ id: "ProjectListOut" });
+export const ProjectListOut = pageOut(ProjectOut, "ProjectListOut");
 /**
  * The secret minted when an org mints a project (tenant-admin) token. Shape
  * matches `mintToken`'s return; the `tenant` module owns the canonical
@@ -52,7 +51,8 @@ export const ProjectIn = z
     .meta({ id: "ProjectIn" });
 export const ProjectTokenIn = z
     .object({
-    ttl_seconds: z.number().int().nullish(),
+    // Same bounds as `TokenIn.ttl_seconds` — this mints a `tenant:*` token too.
+    ttl_seconds: z.number().int().positive().max(315_360_000).nullish(),
     name: z.string().nullish(),
 })
     .meta({ id: "ProjectTokenIn" });

package/dist/zod/runs.js

@@ -20,6 +20,7 @@
  * are deliberately not modelled.
  */
 import { z } from "zod";
+import { Actor } from "./_actor.js";
 import { pageOut } from "./_page.js";
 /** One message in a run's `input`. `content` is a plain string for a text-only
  *  turn, or an array of content parts (`{type:"text"|"file"|"image", …}`) for a
@@ -28,10 +29,7 @@ import { pageOut } from "./_page.js";
 export const InputMessage = z
     .object({
     role: z.string(),
-    content: z.union([
-        z.string(),
-        z.array(z.record(z.string(), z.unknown())),
-    ]),
+    content: z.union([z.string(), z.array(z.record(z.string(), z.unknown()))]),
 })
     .meta({ id: "InputMessage" });
 /** One run's own token usage (the `usage` map on a run). Distinct from the
@@ -49,6 +47,16 @@ export const RunUsage = z
     cost: z.number().optional(),
 })
     .meta({ id: "RunUsage" });
+/** One thing that went wrong during a run without ending it — today, a tool source
+ *  the run could not reach. A run that lost its tools still answers, and the answer
+ *  is shaped like a healthy one, so this rides the run's own summary fields rather
+ *  than a nested metadata key nobody reads. */
+export const RunWarning = z
+    .object({
+    code: z.string(),
+    message: z.string(),
+})
+    .meta({ id: "RunWarning" });
 export const RunOut = z
     .object({
     id: z.string(),
@@ -75,8 +83,12 @@ export const RunOut = z
     })
         .nullable(),
     stop_reason: z.string().nullable(),
+    // Always present, `[]` on a clean run: absence must never read as "fine".
+    warnings: z.array(RunWarning),
     usage: RunUsage.nullable(),
     metadata: z.record(z.string(), z.unknown()).optional(),
+    /** Who started this run. Null on runs created before attribution shipped. */
+    actor: Actor.nullable(),
     created_at: z.string().nullable(),
     updated_at: z.string().nullable(),
 })
@@ -112,6 +124,9 @@ export const Submit = z
     result: z.record(z.string(), z.unknown()).nullish(),
     approval_id: z.string().nullish(),
     decision: z.string().nullish(),
+    /** The answer to an approval's `elicitation`, matching its
+     *  `requested_schema`; with `decision: "approve"`. */
+    content: z.record(z.string(), z.unknown()).nullish(),
     actor: z.string().nullish(),
     reason: z.string().nullish(),
     stream: z.boolean().optional(),

package/dist/zod/schedules.js

@@ -13,6 +13,7 @@
  * `#/components/schemas/<id>` rather than inlining it.
  */
 import { z } from "zod";
+import { pageOut } from "./_page.js";
 /** A schedule's stored input: messages replayed as the run input on each fire. */
 const ScheduleInput = z.array(z.record(z.string(), z.unknown()));
 export const ScheduleOut = z
@@ -25,17 +26,13 @@ export const ScheduleOut = z
     input: ScheduleInput,
     /** Thread the fired runs append to; null mints a fresh thread per fire. */
     thread_id: z.string().nullable(),
-    /** Max overlapping fired runs before new fires are skipped. */
-    max_concurrent: z.number().int(),
     enabled: z.boolean(),
     next_fire_at: z.string().nullable(),
     last_fire_at: z.string().nullable(),
     created_at: z.string().nullable(),
 })
     .meta({ id: "ScheduleOut" });
-export const ScheduleListOut = z
-    .object({ data: z.array(ScheduleOut) })
-    .meta({ id: "ScheduleListOut" });
+export const ScheduleListOut = pageOut(ScheduleOut, "ScheduleListOut");
 /** `POST .../:sid/run_now` — the fire is enqueued onto the smith's serial delivery
  *  lane (not run inline), so the response acknowledges the queued delivery rather
  *  than a completed run. Poll `/v1/events` or the smith's runs for the outcome. */
@@ -54,7 +51,6 @@ export const ScheduleIn = z
     timezone: z.string().default("UTC"),
     input: ScheduleInput.default([]),
     thread_id: z.string().nullish(),
-    max_concurrent: z.number().int().default(1),
     enabled: z.boolean().default(true),
 })
     .meta({ id: "ScheduleIn" });
@@ -65,7 +61,6 @@ export const SchedulePatch = z
     timezone: z.string().nullish(),
     input: ScheduleInput.nullish(),
     thread_id: z.string().nullish(),
-    max_concurrent: z.number().int().nullish(),
     enabled: z.boolean().nullish(),
 })
     .meta({ id: "SchedulePatch" });