@ingram-cloud/sdk 1.0.0

package/dist/zod/schedules.js

@@ -0,0 +1,71 @@
+/**
+ * Hand-authored Zod schemas for the `schedules` resource — cron-triggered runs
+ * on a smith's agent — the wire's source of truth, replacing the loose
+ * generated `schemas.ts` 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.
+ */
+import { z } from "zod";
+/** 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
+    .object({
+    id: z.string(),
+    name: z.string().nullable(),
+    cron: z.string(),
+    timezone: z.string(),
+    /** Messages replayed as the run input on each fire. */
+    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" });
+/** `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. */
+export const ScheduleRunNowOut = z
+    .object({
+    schedule_id: z.string(),
+    delivery_id: z.string(),
+    status: z.literal("queued"),
+})
+    .meta({ id: "ScheduleRunNowOut" });
+// ── Request bodies ──────────────────────────────────────────────────────────
+export const ScheduleIn = z
+    .object({
+    cron: z.string(),
+    name: z.string().nullish(),
+    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" });
+export const SchedulePatch = z
+    .object({
+    name: z.string().nullish(),
+    cron: z.string().nullish(),
+    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" });

package/dist/zod/slack.js

@@ -0,0 +1,69 @@
+/**
+ * Hand-authored Zod schemas for the `slack` channel-config resource — the
+ * wire's source of truth for `PUT/GET /v1/tenant/slack`.
+ *
+ * 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 here and re-exported by `../responses`. No Zod is pulled
+ * into a type-only consumer — `responses.ts` re-exports this as `export type`.
+ *
+ * `.meta({ id })` names the component so the emitted OpenAPI references it as
+ * `#/components/schemas/<id>` rather than inlining it.
+ */
+import { z } from "zod";
+// ── Config status (GET/PUT response) ─────────────────────────────────────────
+/** App factory posture: whether the tenant has minted-app credentials stored. */
+export const SlackFactoryStatus = z
+    .object({ configured: z.boolean() })
+    .meta({ id: "SlackFactoryStatus" });
+/**
+ * The tenant's Slack posture, as `tenantStatus` builds it. `configured`,
+ * `factory`, and `oauth_redirect_url` are always emitted; the shared-app
+ * details (`bot_user_id`, `team_id`, `events_url`, `oauth_ready`) only appear
+ * once a shared app is configured, and `return_url` only when one is set.
+ */
+export const SlackAppOut = z
+    .object({
+    configured: z.boolean(),
+    bot_user_id: z.string().optional(),
+    team_id: z.string().optional(),
+    events_url: z.string().optional(),
+    /** Shared app's OAuth client is set — "Add to Slack" installs work. */
+    oauth_ready: z.boolean().optional(),
+    oauth_redirect_url: z.string().optional(),
+    /** Where the OAuth redirect sends installers back (?slack=… appended). */
+    return_url: z.string().optional(),
+    /** App factory: mints per-smith Slack apps from the manifest template. */
+    factory: SlackFactoryStatus.optional(),
+})
+    .meta({ id: "SlackAppOut" });
+// ── Request bodies (PUT /v1/tenant/slack) ────────────────────────────────────
+/**
+ * The app-factory block: a delegated app-config token pair plus the Slack app
+ * manifest template that minted per-smith apps are instantiated from.
+ */
+export const SlackFactoryIn = z
+    .object({
+    config_token: z.string(),
+    config_refresh_token: z.string().nullish(),
+    manifest_template: z.record(z.string(), z.unknown()),
+})
+    .meta({ id: "SlackFactoryIn" });
+/**
+ * Register or rotate the tenant's Slack posture: a shared app (bot_token +
+ * signing_secret, optionally the OAuth client fields), a factory block, and/or
+ * the return_url. Every field is optional — the handler applies whichever
+ * blocks are present.
+ */
+export const SlackAppIn = z
+    .object({
+    bot_token: z.string().nullish(),
+    signing_secret: z.string().nullish(),
+    client_id: z.string().nullish(),
+    client_secret: z.string().nullish(),
+    oauth_scopes: z.string().nullish(),
+    oauth_user_scopes: z.string().nullish(),
+    return_url: z.string().nullish(),
+    factory: SlackFactoryIn.nullish(),
+})
+    .meta({ id: "SlackAppIn" });

package/dist/zod/smith-revisions.js

@@ -0,0 +1,42 @@
+/**
+ * Hand-authored Zod schemas for the `smith-revisions` resource — the wire's
+ * source of truth for `/v1/smiths/{id}/revisions`.
+ *
+ * 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 them here and re-exported by `../responses`. No Zod
+ * is pulled into a type-only consumer — `responses.ts` re-exports as types.
+ *
+ * A smith's behaviour config (instructions / model / hosted tools / auto-memory)
+ * is mutable; every change is snapshotted as an immutable *revision* and an
+ * operator can roll back. History is append-only — a *restore* re-applies an old
+ * snapshot as a brand-new revision.
+ *
+ * `.meta({ id })` names the component so the emitted OpenAPI references it as
+ * `#/components/schemas/<id>` rather than inlining it.
+ */
+import { z } from "zod";
+/** An immutable snapshot of a smith's effective behaviour config at one revision. */
+export const SmithRevisionOut = z
+    .object({
+    version: z.number().int(),
+    snapshot: z.object({
+        instructions: z.string().nullish(),
+        model: z.string().nullish(),
+        enabled_hosted_tools: z.array(z.string()).optional(),
+        vector_store_ids: z.array(z.string()).optional(),
+        auto_memory: z.boolean().optional(),
+        memory_consolidation: z.boolean().optional(),
+    }),
+    created_by: z.string().nullish(),
+    note: z.string().nullish(),
+    created_at: z.string().nullish(),
+})
+    .meta({ id: "SmithRevisionOut" });
+export const RevisionListOut = z
+    .object({ data: z.array(SmithRevisionOut) })
+    .meta({ id: "RevisionListOut" });
+// ── Request bodies ──────────────────────────────────────────────────────────
+export const RestoreIn = z
+    .object({ note: z.string().nullish() })
+    .meta({ id: "RestoreIn" });

package/dist/zod/smiths.js

@@ -0,0 +1,108 @@
+/**
+ * Hand-authored Zod schemas for the `smiths` resource — the wire's source of
+ * truth, replacing the loose generated `schemas.ts` 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`.
+ *
+ * A smith is one running clone of an agent (`/v1/smiths`, `smt_` ids), the unit
+ * of data isolation. Its identity fields live alongside its *effective* agent
+ * config (model/instructions/tools), flattened onto the resource. Memory is a
+ * separate sub-resource (`/v1/smiths/{id}/memory`, schemas in `./memories`).
+ *
+ * `.meta({ id })` names the component so the emitted OpenAPI references it as
+ * `#/components/schemas/<id>` rather than inlining it.
+ */
+import { z } from "zod";
+// ── Smith response ───────────────────────────────────────────────────────────
+export const SmithOut = z
+    .object({
+    id: z.string(),
+    external_id: z.string().nullable(),
+    display_name: z.string().nullable(),
+    locale: z.string().nullable(),
+    timezone: z.string().nullable(),
+    /** The customer (billable party) this smith's usage rolls up to. */
+    customer_id: z.string().nullish(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    // The *effective* agent config (agent-resolved when attached).
+    model: z.string(),
+    /** The raw instructions template (may contain {{ variables }}). */
+    instructions: z.string(),
+    /** What this smith actually runs with — {{ variables }} bound per-smith. */
+    rendered_instructions: z.string().nullish(),
+    enabled_hosted_tools: z.array(z.string()).optional(),
+    vector_store_ids: z.array(z.string()).optional(),
+    auto_memory: z.boolean().optional(),
+    memory_consolidation: z.boolean().optional(),
+    /** How the config resolved: by reference, with overrides, or embedded. */
+    config_source: z.enum(["agent", "override", "custom"]).optional(),
+    agent_id: z.string().nullish(),
+    agent_version: z.number().int().nullish(),
+    pin: z.number().int().nullish(),
+    /** Which config fields this smith overrides on top of its agent version.
+     *  The rest track the agent. Empty for a clean reference or a standalone
+     *  smith. Clear an override by PATCHing that field to `null`. */
+    override_keys: z.array(z.string()).optional(),
+    /** What each field reverts to — the agent version's value, before this
+     *  smith's overrides. `null` for a standalone smith (nothing to inherit). */
+    inherited: z
+        .object({
+        model: z.string(),
+        instructions: z.string().nullable(),
+        enabled_hosted_tools: z.array(z.string()),
+        vector_store_ids: z.array(z.string()),
+        auto_memory: z.boolean().nullable(),
+        memory_consolidation: z.boolean().nullable(),
+    })
+        .nullish(),
+    created_at: z.string(),
+})
+    .meta({ id: "SmithOut" });
+/** Cursor-paginated smith list: `data` + `has_more` (+ opaque `next_cursor`). */
+export const SmithListOut = z
+    .object({
+    data: z.array(SmithOut),
+    has_more: z.boolean(),
+    next_cursor: z.string().nullish(),
+})
+    .meta({ id: "SmithListOut" });
+// ── Request bodies ──────────────────────────────────────────────────────────
+export const SmithCreate = z
+    .object({
+    external_id: z.string().nullish(),
+    display_name: z.string().nullish(),
+    locale: z.string().nullish(),
+    timezone: z.string().nullish(),
+    customer_id: z.string().nullish(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    agent_id: z.string().nullish(),
+    pin: z.number().int().nullish(),
+    model: z.string().nullish(),
+    instructions: z.string().nullish(),
+    enabled_hosted_tools: z.array(z.string()).nullish(),
+    vector_store_ids: z.array(z.string()).nullish(),
+    auto_memory: z.boolean().nullish(),
+    memory_consolidation: z.boolean().nullish(),
+})
+    .meta({ id: "SmithCreate" });
+export const SmithPatch = z
+    .object({
+    display_name: z.string().nullish(),
+    locale: z.string().nullish(),
+    timezone: z.string().nullish(),
+    customer_id: z.string().nullish(),
+    metadata: z.record(z.string(), z.unknown()).nullish(),
+    agent_id: z.string().nullish(),
+    pin: z.number().int().nullish(),
+    model: z.string().nullish(),
+    instructions: z.string().nullish(),
+    enabled_hosted_tools: z.array(z.string()).nullish(),
+    vector_store_ids: z.array(z.string()).nullish(),
+    auto_memory: z.boolean().nullish(),
+    memory_consolidation: z.boolean().nullish(),
+})
+    .meta({ id: "SmithPatch" });

package/dist/zod/telegram.js

@@ -0,0 +1,36 @@
+/**
+ * Hand-authored Zod schemas for the `telegram` channel-config resource — 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.
+ */
+import { z } from "zod";
+/**
+ * The tenant's Telegram bot config status. The token itself is never returned;
+ * the optional fields are present only once `configured` is true (`has_token`
+ * appears on the read path, not the just-configured write response).
+ */
+export const TelegramBotOut = z
+    .object({
+    configured: z.boolean(),
+    bot_username: z.string().optional(),
+    bot_id: z.number().int().optional(),
+    has_token: z.boolean().optional(),
+    webhook_url: z.string().optional(),
+})
+    .meta({ id: "TelegramBotOut" });
+// ── Request bodies ──────────────────────────────────────────────────────────
+export const TelegramBotIn = z
+    .object({
+    bot_token: z.string(),
+    webhook_secret: z.string().nullish(),
+})
+    .meta({ id: "TelegramBotIn" });

package/dist/zod/tenant.js

@@ -0,0 +1,219 @@
+/**
+ * Hand-authored Zod schemas for the `tenant` config plane — the grab-bag router
+ * (`api/src/routes/tenant.ts`) serving the events feed, hosted-tool catalog,
+ * BYOK model keys, the model catalog, OAuth client providers, minted tokens, the
+ * usage summary, and webhooks.
+ *
+ * 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`.
+ *
+ * `.meta({ id })` names the component so the emitted OpenAPI references it as
+ * `#/components/schemas/<id>` rather than inlining it.
+ */
+import { z } from "zod";
+import { pageOut } from "./_page.js";
+// ── Events (poll mirror of the webhook firehose) ─────────────────────────────
+/** One event in the `/v1/events` feed — the `{v:1}` envelope (sans `tenant_id`,
+ *  which the feed omits since the tenant is implicit in the token). */
+export const EventOut = z
+    .object({
+    /** Envelope schema version (always `1` today). */
+    v: z.number().int(),
+    id: z.string(),
+    type: z.string(),
+    smith_id: z.string().nullable(),
+    data: z.record(z.string(), z.unknown()),
+    created_at: z.string().nullable(),
+})
+    .meta({ id: "EventOut" });
+export const EventListOut = pageOut(EventOut, "EventListOut");
+// ── Webhooks ─────────────────────────────────────────────────────────────────
+export const WebhookOut = z
+    .object({
+    id: z.string(),
+    url: z.string(),
+    events: z.array(z.string()),
+    active: z.boolean(),
+    created_at: z.string().nullable(),
+})
+    .meta({ id: "WebhookOut" });
+export const WebhookListOut = pageOut(WebhookOut, "WebhookListOut");
+/** The create response — the signing `secret` is returned EXACTLY ONCE, here. */
+export const WebhookCreateOut = z
+    .object({
+    id: z.string(),
+    url: z.string(),
+    events: z.array(z.string()),
+    active: z.boolean(),
+    secret: z.string(),
+})
+    .meta({ id: "WebhookCreateOut" });
+/** The patch/delete-adjacent ack shape (just the id). */
+export const WebhookIdOut = z
+    .object({ id: z.string() })
+    .meta({ id: "WebhookIdOut" });
+export const WebhookIn = z
+    .object({
+    url: z.string(),
+    events: z.array(z.string()).default([]),
+    active: z.boolean().default(true),
+})
+    .meta({ id: "WebhookIn" });
+export const WebhookPatch = z
+    .object({
+    url: z.string().nullish(),
+    events: z.array(z.string()).nullish(),
+    active: z.boolean().nullish(),
+})
+    .meta({ id: "WebhookPatch" });
+// ── Tokens (mint / list / revoke RS256 JWTs) ─────────────────────────────────
+/** A minted-token *summary* — the list/listing shape. The secret `token` is
+ *  NEVER echoed here; it only appears in {@link MintedTokenOut} on create. */
+export const TokenOut = z
+    .object({
+    id: z.string(),
+    name: z.string().nullable(),
+    sub: z.string(),
+    scopes: z.array(z.string()),
+    prefix: z.string().nullable(),
+    created_at: z.string().nullable(),
+    expires_at: z.string().nullable(),
+    revoked_at: z.string().nullable(),
+})
+    .meta({ id: "TokenOut" });
+export const TokenListOut = pageOut(TokenOut, "TokenListOut");
+/** The create response — carries the secret `token` exactly once. */
+export const MintedTokenOut = z
+    .object({
+    id: z.string(),
+    token: z.string(),
+    scope: z.string(),
+    sub: z.string(),
+    scopes: z.array(z.string()),
+    expires_at: z.string().nullable(),
+})
+    .meta({ id: "MintedTokenOut" });
+export const TokenIn = z
+    .object({
+    scope: z.string().default("smith"),
+    smith_id: z.string().nullish(),
+    permissions: z.array(z.string()).nullish(),
+    ttl_seconds: z.number().int().nullish(),
+    name: z.string().nullish(),
+})
+    .meta({ id: "TokenIn" });
+// ── Usage (aggregated token usage across the tenant's runs, by day) ──────────
+export const UsageOut = z
+    .object({
+    totals: z.object({
+        runs: z.number().int(),
+        input_tokens: z.number().int(),
+        output_tokens: z.number().int(),
+        total_tokens: z.number().int(),
+    }),
+    series: z.array(z.object({
+        date: z.string(),
+        runs: z.number().int(),
+        total_tokens: z.number().int(),
+    })),
+})
+    .meta({ id: "UsageOut" });
+// ── Model catalog + BYOK keys ────────────────────────────────────────────────
+/** One selectable model in the `/v1/tenant/models` catalog. */
+export const ModelOut = z
+    .object({
+    id: z.string(),
+    provider: z.string(),
+    label: z.string(),
+    available: z.boolean(),
+    /** Whose key a run would use: the tenant's ("byok") or Ingram-hosted ("hosted"). */
+    source: z.enum(["byok", "hosted"]).nullish(),
+})
+    .meta({ id: "ModelOut" });
+/** A runnable backend in the model catalog (NB `base_url` is a *bool flag* — does
+ *  the provider accept a base-url override — not a URL). */
+export const ModelProviderOut = z
+    .object({
+    id: z.string(),
+    label: z.string(),
+    base_url: z.boolean(),
+    /** True when Ingram hosts a key for this provider (runnable without a tenant key). */
+    hosted: z.boolean().optional(),
+})
+    .meta({ id: "ModelProviderOut" });
+export const ModelsListOut = z
+    .object({
+    data: z.array(ModelOut),
+    providers: z.array(ModelProviderOut),
+})
+    .meta({ id: "ModelsListOut" });
+/** A BYOK model key — the `api_key` is NEVER echoed, only its presence. */
+export const ModelKeyOut = z
+    .object({
+    provider: z.string(),
+    base_url: z.string().nullable(),
+    has_key: z.boolean(),
+    updated_at: z.string().nullable(),
+})
+    .meta({ id: "ModelKeyOut" });
+export const ModelKeyListOut = z
+    .object({ data: z.array(ModelKeyOut) })
+    .meta({ id: "ModelKeyListOut" });
+/** The PUT ack — never echoes the key, only presence + the (non-secret) base_url. */
+export const ModelKeyConfiguredOut = z
+    .object({
+    provider: z.string(),
+    configured: z.boolean(),
+    base_url: z.string().nullable(),
+})
+    .meta({ id: "ModelKeyConfiguredOut" });
+export const ModelKeyIn = z
+    .object({
+    api_key: z.string(),
+    base_url: z.string().nullish(),
+})
+    .meta({ id: "ModelKeyIn" });
+// ── Providers (tenant OAuth client credentials) ──────────────────────────────
+/** A provider's OAuth client config — the `client_secret` is NEVER echoed, only
+ *  `has_client_secret`. */
+export const ProviderOut = z
+    .object({
+    provider: z.string(),
+    client_id: z.string().nullable(),
+    token_uri: z.string().nullable(),
+    scopes_allowed: z.array(z.string()),
+    refresh_webhook: z.string().nullable(),
+    has_client_secret: z.boolean(),
+})
+    .meta({ id: "ProviderOut" });
+export const ProviderListOut = z
+    .object({ data: z.array(ProviderOut) })
+    .meta({ id: "ProviderListOut" });
+/** The PUT ack. */
+export const ProviderConfiguredOut = z
+    .object({
+    provider: z.string(),
+    configured: z.boolean(),
+})
+    .meta({ id: "ProviderConfiguredOut" });
+export const ProviderIn = z
+    .object({
+    client_id: z.string().nullish(),
+    client_secret: z.string().nullish(),
+    token_uri: z.string().nullish(),
+    scopes_allowed: z.array(z.string()).default([]),
+    refresh_webhook: z.string().nullish(),
+})
+    .meta({ id: "ProviderIn" });
+// ── Hosted-tool catalog ──────────────────────────────────────────────────────
+/** One tool hosted by Ingram Cloud that the catalog advertises. */
+export const HostedToolOut = z
+    .object({
+    name: z.string(),
+    description: z.string(),
+})
+    .meta({ id: "HostedToolOut" });
+export const HostedToolsListOut = z
+    .object({ data: z.array(HostedToolOut) })
+    .meta({ id: "HostedToolsListOut" });