@ingram-cloud/sdk 1.0.0

package/dist/zod/discord.js

@@ -0,0 +1,32 @@
+/**
+ * Hand-authored Zod schemas for the `discord` channel-config resource — the wire's
+ * source of truth, mirroring `telegram.ts`.
+ *
+ * Discord is delivered over its HTTP Interactions endpoint: the tenant registers one
+ * Discord application (its public key + a bot token) and Ingram Cloud verifies every
+ * inbound interaction's Ed25519 signature with that public key, so there is no shared
+ * webhook secret. Secrets are never returned.
+ */
+import { z } from "zod";
+/**
+ * The tenant's Discord app config status. The bot token is never returned; the
+ * optional fields are present once `configured` is true. `webhook_url` is the
+ * Interactions Endpoint URL to register in the Discord Developer Portal.
+ */
+export const DiscordAppOut = z
+    .object({
+    configured: z.boolean(),
+    application_id: z.string().optional(),
+    public_key: z.string().optional(),
+    has_bot_token: z.boolean().optional(),
+    webhook_url: z.string().optional(),
+})
+    .meta({ id: "DiscordAppOut" });
+// ── Request bodies ──────────────────────────────────────────────────────────
+export const DiscordAppIn = z
+    .object({
+    application_id: z.string(),
+    public_key: z.string(),
+    bot_token: z.string(),
+})
+    .meta({ id: "DiscordAppIn" });

package/dist/zod/email.js

@@ -0,0 +1,45 @@
+/**
+ * Hand-authored Zod schemas for the `email` channel-config resource — the
+ * wire's source of truth for the tenant Cloudflare sending config.
+ *
+ * One source, three outputs: the API imports these into its `createRoute`
+ * definitions (validation + emitted OpenAPI), and the consumer-facing `IC*`
+ * type is `z.infer`red from `EmailConfigOut` here and re-exported by
+ * `../responses` as `export type` — no Zod is pulled into a type-only consumer.
+ *
+ * `.meta({ id })` names the component so the emitted OpenAPI references it as
+ * `#/components/schemas/<id>` rather than inlining it.
+ *
+ * The out shape is the union of two builders in `api/src/routes/email.ts`
+ * (via `runtime/email.ts`):
+ *  - GET `/v1/tenant/email` (`configStatus`) — `{ configured: false }`, or
+ *    `{ configured: true, from_domain, display_name, has_token, inbound_url }`.
+ *  - PUT `/v1/tenant/email` (`configureEmail`) — `{ configured: true,
+ *    from_domain, display_name, inbound_url, inbound_secret }`.
+ * Hence `configured` is the only required field; everything else is optional,
+ * and `inbound_secret` is present only on the PUT response (shown once).
+ */
+import { z } from "zod";
+export const EmailConfigOut = z
+    .object({
+    /** False when the tenant has no email config; true otherwise. */
+    configured: z.boolean(),
+    from_domain: z.string().optional(),
+    display_name: z.string().nullish(),
+    /** Present on GET when configured — the API token is never returned. */
+    has_token: z.boolean().optional(),
+    inbound_url: z.string().optional(),
+    /** Only present on PUT (shown once) — wire it into the inbound worker. */
+    inbound_secret: z.string().optional(),
+})
+    .meta({ id: "EmailConfigOut" });
+// ── Request body ─────────────────────────────────────────────────────────────
+export const EmailConfigIn = z
+    .object({
+    cloudflare_account_id: z.string(),
+    cloudflare_api_token: z.string(),
+    from_domain: z.string(),
+    display_name: z.string().nullish(),
+    inbound_secret: z.string().nullish(),
+})
+    .meta({ id: "EmailConfigIn" });

package/dist/zod/files.js

@@ -0,0 +1,55 @@
+/**
+ * Hand-authored Zod schemas for the `files` resource — the wire's source of
+ * truth, mapped onto the OpenAI **Files API** so an OpenAI client library talks
+ * to it unchanged.
+ *
+ * The File object is exactly OpenAI's (`status`/`status_details` included, inert
+ * upstream and here). Upload is `multipart/form-data`, so there is no `In`
+ * schema — the route reads the form directly. The list uses OpenAI's `list`
+ * envelope with `after`/`limit`/`order` paging and enumerates Files-API uploads
+ * only; files inlined into a conversation stay reachable by id but are not
+ * listed.
+ */
+import { z } from "zod";
+/** OpenAI's upload purposes. Vector-store source files are `assistants`. */
+export const FilePurpose = z.enum([
+    "assistants",
+    "batch",
+    "fine-tune",
+    "vision",
+    "user_data",
+    "evals",
+]);
+/** The OpenAI File object. */
+export const FileOut = z
+    .object({
+    id: z.string(),
+    object: z.literal("file"),
+    bytes: z.number().int(),
+    /** Unix seconds, like every OpenAI object. */
+    created_at: z.number().int(),
+    filename: z.string(),
+    purpose: z.string(),
+    /** Deprecated upstream; always `processed` here. */
+    status: z.literal("processed"),
+    status_details: z.null(),
+})
+    .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" });
+/** The delete acknowledgement, in OpenAI's `*.deleted` shape. */
+export const FileDeleted = z
+    .object({
+    id: z.string(),
+    object: z.literal("file"),
+    deleted: z.literal(true),
+})
+    .meta({ id: "FileDeleted" });

package/dist/zod/index.js

@@ -0,0 +1,35 @@
+/**
+ * Hand-authored Zod schemas — the wire's source of truth, one resource module
+ * per file. The API imports these into its `createRoute` definitions (runtime
+ * validation + emitted OpenAPI); `../responses` re-exports the `z.infer`red
+ * `IC*` types from them.
+ *
+ * Resources are migrated here off the generated `../schemas.ts` one at a time;
+ * 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 "./_page.js";
+export * from "./agents.js";
+export * from "./approvals.js";
+export * from "./budgets.js";
+export * from "./catalog.js";
+export * from "./connections.js";
+export * from "./conversations.js";
+export * from "./deployments.js";
+export * from "./customers.js";
+export * from "./discord.js";
+export * from "./email.js";
+export * from "./files.js";
+export * from "./mcp.js";
+export * from "./memories.js";
+export * from "./observability.js";
+export * from "./projects.js";
+export * from "./runs.js";
+export * from "./schedules.js";
+export * from "./slack.js";
+export * from "./smith-revisions.js";
+export * from "./smiths.js";
+export * from "./telegram.js";
+export * from "./tenant.js";
+export * from "./vector-stores.js";
+export * from "./whatsapp.js";

package/dist/zod/mcp.js

@@ -0,0 +1,107 @@
+/**
+ * Hand-authored Zod schemas for the `mcp` resource — the tenant config plane for
+ * registering third-party MCP tool servers (`/v1/tenant/mcp/...`).
+ *
+ * One source, three outputs: the API imports these into its `createRoute`
+ * definitions (validation + emitted OpenAPI), and the consumer-facing `IC*`
+ * types are `z.infer`red from them here and re-exported by `../responses`. No
+ * Zod is pulled into a type-only consumer — `responses.ts` re-exports these as
+ * `export type`.
+ *
+ * `.meta({ id })` names the component so the emitted OpenAPI references it as
+ * `#/components/schemas/<id>` rather than inlining it. `ApprovalRule` and
+ * `McpTool` are standalone named schemas referenced by `McpServerOut`, so they
+ * emit as `$ref` components rather than inlined objects.
+ */
+import { z } from "zod";
+/** 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. */
+export const ApprovalRule = z
+    .object({
+    match: z.string(),
+    require: z.string().optional(),
+})
+    .meta({ id: "ApprovalRule" });
+/** The rule shape on *input* (`McpServerIn.approval_policy`). Loose, so unknown
+ *  clauses (e.g. an arg-conditional `when`) reach the handler, which rejects them
+ *  with its own `unsupported_policy_rule` (422) rather than being silently
+ *  stripped by a strict object. */
+export const ApprovalRuleIn = z.looseObject({
+    match: z.string(),
+    require: z.string().optional(),
+});
+/** A discovered MCP tool, with its *effective* gating folded in by the
+ *  serializer: `enabled` reflects the default-deny `tool_allowlist`,
+ *  `requires_approval` folds the server's destructive hint with the approval
+ *  policy. */
+export const McpTool = z
+    .object({
+    name: z.string(),
+    description: z.string().nullable(),
+    /** Effective gate: server destructiveHint OR an approval_policy match. */
+    requires_approval: z.boolean(),
+    /** Passes the default-deny tool_allowlist (always true when no allow-list). */
+    enabled: z.boolean(),
+})
+    .meta({ id: "McpTool" });
+/** Secret-free auth descriptor returned for a registered server. */
+export const McpAuth = z
+    .object({
+    kind: z.string(),
+    provider: z.string().nullable(),
+    client_mode: z.string().optional(),
+})
+    .meta({ id: "McpAuth" });
+export const McpServerOut = z
+    .object({
+    id: z.string(),
+    name: z.string(),
+    url: z.string(),
+    auth: McpAuth,
+    /** tenant_owned | tenant_registered | catalog. */
+    origin: z.string().optional(),
+    catalog_slug: z.string().nullish(),
+    /** null = expose all discovered tools; otherwise the default-deny set. */
+    tool_allowlist: z.array(z.string()).nullish(),
+    approval_policy: z.array(ApprovalRule).optional(),
+    tools: z.array(McpTool),
+    tools_refreshed_at: z.string().nullable(),
+    /** `degraded` when the edge failed discovery or its secret can't be decoded
+     *  at run time; otherwise the stored lifecycle status. */
+    status: z.string(),
+    /** Last discovery/runtime-load failure, or null when the edge is healthy. */
+    discovery_error: z.string().nullable(),
+    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" });
+// ── Request bodies ──────────────────────────────────────────────────────────
+/** Auth block on a register/replace body. `secret` is write-only (a static
+ *  bearer) — never echoed back. */
+export const McpAuthIn = z
+    .object({
+    kind: z.string().nullish(),
+    provider: z.string().nullish(),
+    secret: z.string().nullish(),
+    client_mode: z.string().nullish(),
+})
+    .meta({ id: "McpAuthIn" });
+/** Register or replace a server: supply a raw `url` + `auth`, or a `catalog`
+ *  slug (catalog defaults are stamped down, body fields override). */
+export const McpServerIn = z
+    .object({
+    url: z.string().nullish(),
+    catalog: z.string().nullish(),
+    auth: McpAuthIn.nullish(),
+    tool_allowlist: z.array(z.string()).nullish(),
+    approval_policy: z.array(ApprovalRuleIn).nullish(),
+})
+    .meta({ id: "McpServerIn" });

package/dist/zod/memories.js

@@ -0,0 +1,43 @@
+/**
+ * Hand-authored Zod schemas for the `memory` resource — the wire's source of
+ * truth, imported by the API's `createRoute` definitions (validation + emitted
+ * OpenAPI) and `z.infer`red into the consumer-facing `IC*` types re-exported by
+ * `../responses`.
+ *
+ * Memory is Mastra-native (workstream #65): a smith has one **working-memory**
+ * doc (structured, auto-maintained) plus automatic **semantic recall** over its
+ * past messages. There is no standalone "file a fact" CRUD — recall is over the
+ * conversation history the smith already produced.
+ *
+ * `.meta({ id })` names the component so the emitted OpenAPI references it as
+ * `#/components/schemas/<id>`.
+ */
+import { z } from "zod";
+/** A smith's working-memory doc — the structured text the agent maintains about
+ *  its end user, shared across the smith's threads (resource-scoped). */
+export const WorkingMemoryOut = z
+    .object({ content: z.string() })
+    .meta({ id: "WorkingMemoryOut" });
+/** Replace a smith's working-memory doc. */
+export const WorkingMemorySet = z
+    .object({ content: z.string() })
+    .meta({ id: "WorkingMemorySet" });
+/** Recall query over a smith's past messages. */
+export const RecallBody = z
+    .object({
+    query: z.string(),
+    limit: z.number().int().default(10),
+})
+    .meta({ id: "RecallBody" });
+/** One recall hit — a relevant past message range with its similarity `score`. */
+export const RecallHit = z
+    .object({
+    thread_id: z.string(),
+    content: z.string(),
+    score: z.number(),
+})
+    .meta({ id: "RecallHit" });
+/** Recall response envelope — ranked hits. */
+export const RecallOut = z
+    .object({ data: z.array(RecallHit) })
+    .meta({ id: "RecallOut" });

package/dist/zod/observability.js

@@ -0,0 +1,133 @@
+/**
+ * Hand-authored Zod schemas for the `observability` resource — traces, spans,
+ * and the usage breakdown. The wire's source of truth, replacing the loose
+ * generated shapes for this resource.
+ *
+ * One source, three outputs: the API imports these into its `createRoute`
+ * definitions (validation + emitted OpenAPI), and the consumer-facing `IC*`
+ * types are `z.infer`red from them here and re-exported by `../responses`. No
+ * Zod is pulled into a type-only consumer — `responses.ts` re-exports these as
+ * `export type`.
+ *
+ * `.meta({ id })` names the component so the emitted OpenAPI references it as
+ * `#/components/schemas/<id>` rather than inlining it.
+ *
+ * Shapes follow the `responses.ts` interfaces (the source of truth), not the
+ * relic's looser `SpanOut`/`TraceOut`: the relic flattened `children`, `spans`,
+ * and `span_tree` onto every span/trace and made `kind`/timestamps nullable. We
+ * split them — `SpanOut` has no `children`, the recursive `SpanNodeOut` adds
+ * it; `TraceOut` carries no `spans`/`span_tree`, `TraceDetailOut` adds them.
+ */
+import { z } from "zod";
+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",
+])
+    .meta({ id: "SpanKind" });
+/** A single timed unit of work inside a trace. */
+export const SpanOut = z
+    .object({
+    id: z.string(),
+    trace_id: z.string(),
+    parent_span_id: z.string().nullable(),
+    kind: ICSpanKindEnum,
+    name: z.string(),
+    status: z.string(),
+    started_at: z.string(),
+    ended_at: z.string().nullable(),
+    duration_ms: z.number().int().nullable(),
+    model: z.string().nullable(),
+    input_tokens: z.number().int().nullable(),
+    output_tokens: z.number().int().nullable(),
+    cost: z.number().nullable(),
+    attributes: z.record(z.string(), z.unknown()),
+})
+    .meta({ id: "SpanOut" });
+/** A span node in the nested `span_tree` (same shape + recursive children). */
+export const SpanNodeOut = SpanOut.extend({
+    get children() {
+        return z.array(SpanNodeOut);
+    },
+}).meta({ id: "SpanNodeOut" });
+/** Top-level trace — one end-to-end agent operation. */
+export const TraceOut = z
+    .object({
+    id: z.string(),
+    smith_id: z.string(),
+    app_id: z.string().nullable(),
+    root_kind: ICSpanKindEnum,
+    name: z.string(),
+    status: z.string(),
+    started_at: z.string(),
+    ended_at: z.string().nullable(),
+    duration_ms: z.number().int().nullable(),
+    total_tokens: z.number().int().nullable(),
+    total_cost: z.number().nullable(),
+    attributes: z.record(z.string(), z.unknown()),
+})
+    .meta({ id: "TraceOut" });
+/** A trace plus its flat spans and nested tree. */
+export const TraceDetailOut = TraceOut.extend({
+    spans: z.array(SpanOut),
+    span_tree: z.array(SpanNodeOut),
+}).meta({ id: "TraceDetailOut" });
+export const TraceListOut = pageOut(TraceOut, "TraceListOut");
+/** Aggregated usage grouped by app, smith, model, or customer. */
+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({
+        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(),
+    })),
+    /** Custom billable events aggregated per meter over the same filters. */
+    meters: z
+        .array(z.object({
+        meter: z.string(),
+        customer: z.string().nullable().optional(),
+        quantity: z.number(),
+        events: z.number(),
+    }))
+        .optional(),
+})
+    .meta({ id: "UsageBreakdownOut" });
+/** One recorded billable usage event. */
+export const UsageEventOut = z
+    .object({
+    id: z.string(),
+    smith_id: z.string(),
+    customer_id: z.string().nullable(),
+    meter: z.string(),
+    quantity: z.number(),
+    day: z.string(),
+    metadata: z.record(z.string(), z.unknown()),
+    created_at: z.string().nullable(),
+})
+    .meta({ id: "UsageEventOut" });
+/** A page of usage events (keyset pagination). */
+export const UsageEventListOut = z
+    .object({
+    data: z.array(UsageEventOut),
+    next_cursor: z.string().nullable(),
+    has_more: z.boolean(),
+})
+    .meta({ id: "UsageEventListOut" });

package/dist/zod/projects.js

@@ -0,0 +1,58 @@
+/**
+ * Hand-authored Zod schemas for the `projects` resource — the org control-plane
+ * surface (`/v1/organization/projects`). A project's `id` is the `tenant` that
+ * scopes all of its runtime data.
+ *
+ * Source of truth is the handler (`api/src/routes/projects.ts`): `serialize`
+ * emits the project shape, and minting (`api/src/tokens.ts::mintToken`) returns
+ * the token shape. The relic `sdk/openapi.json` supplied field/required hints
+ * only.
+ *
+ * `.meta({ id })` names the component so the emitted OpenAPI references it as
+ * `#/components/schemas/<id>` rather than inlining it.
+ */
+import { z } from "zod";
+export const ProjectOut = z
+    .object({
+    id: z.string(),
+    organization: z.string(),
+    name: z.string(),
+    metadata: z.record(z.string(), z.unknown()),
+    /** ISO timestamp; null only if the row predates the column being set. */
+    created_at: z.string().nullable(),
+    /** Set when the project is archived (soft-deleted); null while live. */
+    archived_at: z.string().nullable(),
+})
+    .meta({ id: "ProjectOut" });
+export const ProjectListOut = z
+    .object({ data: z.array(ProjectOut) })
+    .meta({ id: "ProjectListOut" });
+/**
+ * The secret minted when an org mints a project (tenant-admin) token. Shape
+ * matches `mintToken`'s return; the `tenant` module owns the canonical
+ * `ICMintedToken` re-export, so this stays project-named and project-scoped.
+ */
+export const ProjectTokenOut = z
+    .object({
+    id: z.string(),
+    /** The branded secret handle (`tha_live_…`). Shown once. */
+    token: z.string(),
+    scope: z.string(),
+    sub: z.string(),
+    scopes: z.array(z.string()),
+    expires_at: z.string().nullable(),
+})
+    .meta({ id: "ProjectTokenOut" });
+// ── Request bodies ──────────────────────────────────────────────────────────
+export const ProjectIn = z
+    .object({
+    name: z.string(),
+    metadata: z.record(z.string(), z.unknown()).nullish(),
+})
+    .meta({ id: "ProjectIn" });
+export const ProjectTokenIn = z
+    .object({
+    ttl_seconds: z.number().int().nullish(),
+    name: z.string().nullish(),
+})
+    .meta({ id: "ProjectTokenIn" });

package/dist/zod/runs.js

@@ -0,0 +1,119 @@
+/**
+ * Hand-authored Zod schemas for the `runs` resource — the wire's source of
+ * truth, replacing the inline `IC*` run shapes previously declared in
+ * `../responses`.
+ *
+ * One source, three outputs: the API imports these into its `createRoute`
+ * definitions (validation + emitted OpenAPI), and the consumer-facing `IC*`
+ * types are `z.infer`red from them here and re-exported by `../responses`. No
+ * Zod is pulled into a type-only consumer — `responses.ts` re-exports these as
+ * `export type`.
+ *
+ * `.meta({ id })` names the component so the emitted OpenAPI references it as
+ * `#/components/schemas/<id>` rather than inlining it. `RunUsage` is standalone
+ * (`$ref`'d) so the inferred `ICRunUsage` comes out identical to its hand-written
+ * interface ancestor.
+ *
+ * Only the JSON shapes are modelled here: the run object, the run list, run
+ * events + their list, and the create/submit request bodies. The streaming
+ * surfaces emit the native `{v:1}` SSE envelope (not a single JSON schema) and
+ * are deliberately not modelled.
+ */
+import { z } from "zod";
+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
+ *  multimodal turn — the OpenAI-compatible surface and inline-file offloading both
+ *  persist the array form, so the read schema must accept both. */
+export const InputMessage = z
+    .object({
+    role: z.string(),
+    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
+ *  tenant's aggregated billing summary. Plain numbers, not ints: provider/cache
+ *  token math can be fractional, and an int assertion on a read surface buys
+ *  nothing but a 500 risk. */
+export const RunUsage = z
+    .object({
+    input_tokens: z.number(),
+    output_tokens: z.number(),
+    total_tokens: z.number(),
+    // This turn's priced cost in the account currency, computed at finish from the
+    // model's price book entry. Optional: runs metered before pricing landed — and
+    // any turn with no resolvable model — carry tokens but no `cost`.
+    cost: z.number().optional(),
+})
+    .meta({ id: "RunUsage" });
+export const RunOut = z
+    .object({
+    id: z.string(),
+    smith_id: z.string(),
+    thread_id: z.string(),
+    status: z.string(),
+    channel: z.string(),
+    input: z.array(InputMessage),
+    // `tool_calls` is an array of surface-specific call objects: the OpenAI
+    // `{id,type,function}` shape for a client-tools turn, a pending-call dict for
+    // an approval pause. Modelled loosely on purpose — a single strict struct here
+    // would 500 the read surface on the shapes actually stored.
+    output: z
+        .object({
+        content: z.string().optional(),
+        // Set by a structured (`response_format`) run: the media type of `content`
+        // (e.g. `application/json`), so a reader knows to parse it.
+        content_type: z.string().optional(),
+        tool_calls: z.array(z.record(z.string(), z.unknown())).optional(),
+        // Quick-reply chips the agent offered for this reply (via the
+        // `suggest_replies` tool). Channels with native support render them as
+        // tappable buttons; a tap arrives as the user's next message.
+        suggested_replies: z.array(z.string()).optional(),
+    })
+        .nullable(),
+    stop_reason: z.string().nullable(),
+    usage: RunUsage.nullable(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    created_at: z.string().nullable(),
+    updated_at: z.string().nullable(),
+})
+    .meta({ id: "RunOut" });
+export const RunListOut = pageOut(RunOut, "RunListOut");
+/** One recorded run event, as replayed from the event log. */
+export const RunEventOut = z
+    .object({
+    seq: z.number().int(),
+    type: z.string(),
+    data: z.record(z.string(), z.unknown()),
+    created_at: z.string().nullable(),
+})
+    .meta({ id: "RunEventOut" });
+export const RunEventListOut = z
+    .object({ data: z.array(RunEventOut) })
+    .meta({ id: "RunEventListOut" });
+// ── Request bodies ──────────────────────────────────────────────────────────
+export const RunIn = z
+    .object({
+    input: z.array(InputMessage).optional(),
+    thread_id: z.string().nullish(),
+    stream: z.boolean().optional(),
+    channel: z.string().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    response_format: z.record(z.string(), z.unknown()).nullish(),
+})
+    .meta({ id: "RunIn" });
+export const Submit = z
+    .object({
+    kind: z.string(),
+    tool_call_id: z.string().nullish(),
+    result: z.record(z.string(), z.unknown()).nullish(),
+    approval_id: z.string().nullish(),
+    decision: z.string().nullish(),
+    actor: z.string().nullish(),
+    reason: z.string().nullish(),
+    stream: z.boolean().optional(),
+})
+    .meta({ id: "Submit" });