@ingram-cloud/sdk 1.0.0

package/ts/zod/vector-stores.ts

@@ -0,0 +1,296 @@
+/**
+ * Hand-authored Zod schemas for the `vector_stores` resource — the wire's
+ * source of truth, mapped onto the OpenAI **Vector Stores API** so an OpenAI
+ * client library talks to it unchanged.
+ *
+ * Standards mapping: objects, statuses, chunking strategies, the attribute
+ * filter grammar, and the `search_results.page` envelope are OpenAI's, wart for
+ * wart (modify is `POST`, the batch object is `vector_store.files_batch`, the
+ * search page uses a `next_page` token while CRUD lists use `first_id`/
+ * `last_id`). `smith_id` is the one documented IC extension: it scopes a store
+ * to a single smith ("" = tenant-wide), the same isolation boundary every other
+ * smith-owned resource has. Expiration policies (`expires_after`), query
+ * rewriting, and rankers are not implemented — the fields don't exist here
+ * rather than being accepted and ignored.
+ */
+import { z } from "zod";
+
+// ── Chunking ─────────────────────────────────────────────────────────────────
+
+/** Static chunking params. Overlap must not exceed half the chunk size. */
+export const StaticChunkingConfig = z
+	.object({
+		max_chunk_size_tokens: z.number().int().min(100).max(4096),
+		chunk_overlap_tokens: z.number().int().min(0),
+	})
+	.refine((v) => v.chunk_overlap_tokens <= Math.floor(v.max_chunk_size_tokens / 2), {
+		message: "chunk_overlap_tokens must not exceed max_chunk_size_tokens / 2",
+	});
+
+/** Request-side chunking strategy: `auto` (800/400) or explicit `static`. */
+export const ChunkingStrategyIn = z
+	.union([
+		z.object({ type: z.literal("auto") }),
+		z.object({ type: z.literal("static"), static: StaticChunkingConfig }),
+	])
+	.meta({ id: "ChunkingStrategyIn" });
+
+/** Response-side strategy: always the resolved `static` values (never `auto`). */
+export const ChunkingStrategyOut = z
+	.object({
+		type: z.literal("static"),
+		static: z.object({
+			max_chunk_size_tokens: z.number().int(),
+			chunk_overlap_tokens: z.number().int(),
+		}),
+	})
+	.meta({ id: "ChunkingStrategyOut" });
+
+// ── Attributes & filters ─────────────────────────────────────────────────────
+
+/** File attributes: ≤16 keys, key ≤64 chars, value string(≤512)|number|bool. */
+export const VectorStoreAttributes = z
+	.record(z.string().max(64), z.union([z.string().max(512), z.number(), z.boolean()]))
+	.refine((v) => Object.keys(v).length <= 16, { message: "at most 16 attribute keys" });
+
+/** A filter node: a comparison (`type` eq/ne/gt/gte/lt/lte/in/nin over `key`/
+ *  `value`) or a compound (`type` and/or over nested `filters`). The grammar is
+ *  recursive; the schema validates one node and the API validates nested nodes
+ *  when it compiles the filter (the OpenAPI generator cannot express the
+ *  recursion).
+ */
+export const VectorStoreFilter = z
+	.object({
+		type: z.enum(["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "and", "or"]),
+		key: z.string().optional(),
+		value: z
+			.union([
+				z.string(),
+				z.number(),
+				z.boolean(),
+				z.array(z.union([z.string(), z.number()])),
+			])
+			.optional(),
+		filters: z.array(z.record(z.string(), z.unknown())).optional(),
+	})
+	.meta({ id: "VectorStoreFilter" });
+
+export type ICVectorStoreFilter =
+	| {
+			type: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "nin";
+			key: string;
+			value: string | number | boolean | Array<string | number>;
+	  }
+	| { type: "and" | "or"; filters: ICVectorStoreFilter[] };
+
+// ── Vector store ─────────────────────────────────────────────────────────────
+
+export const VectorStoreIn = z
+	.object({
+		name: z.string().optional(),
+		description: z.string().optional(),
+		/** Files to attach at create; more can be attached later. */
+		file_ids: z.array(z.string()).max(500).optional(),
+		chunking_strategy: ChunkingStrategyIn.optional(),
+		metadata: z.record(z.string(), z.unknown()).optional(),
+		/** IC extension: own the store to one smith ("" / omitted = tenant-wide). */
+		smith_id: z.string().optional(),
+	})
+	.meta({ id: "VectorStoreIn" });
+
+export const VectorStoreFileCounts = z.object({
+	in_progress: z.number().int(),
+	completed: z.number().int(),
+	failed: z.number().int(),
+	cancelled: z.number().int(),
+	total: z.number().int(),
+});
+
+/** The OpenAI vector store object (+ `smith_id`, the IC extension). */
+export const VectorStoreOut = z
+	.object({
+		id: z.string(),
+		object: z.literal("vector_store"),
+		/** Unix seconds, like every OpenAI object. */
+		created_at: z.number().int(),
+		name: z.string(),
+		description: z.string().nullable(),
+		usage_bytes: z.number().int(),
+		/** `in_progress` while any attached file is still indexing. */
+		status: z.enum(["in_progress", "completed"]),
+		file_counts: VectorStoreFileCounts,
+		/** Unix seconds of the last search against the store. */
+		last_active_at: z.number().int().nullable(),
+		metadata: z.record(z.string(), z.unknown()),
+		/** IC extension: the owning smith ("" = tenant-wide). */
+		smith_id: z.string(),
+	})
+	.meta({ id: "VectorStoreOut" });
+
+/** Vector stores, in OpenAI's `list` envelope. */
+export const VectorStoreListOut = z
+	.object({
+		object: z.literal("list"),
+		data: z.array(VectorStoreOut),
+		first_id: z.string().nullable(),
+		last_id: z.string().nullable(),
+		has_more: z.boolean(),
+	})
+	.meta({ id: "VectorStoreListOut" });
+
+/** Modify body (OpenAI uses `POST`, not `PATCH`). */
+export const VectorStorePatch = z
+	.object({
+		name: z.string().nullish(),
+		description: z.string().nullish(),
+		metadata: z.record(z.string(), z.unknown()).nullish(),
+	})
+	.meta({ id: "VectorStorePatch" });
+
+export const VectorStoreDeleted = z
+	.object({
+		id: z.string(),
+		object: z.literal("vector_store.deleted"),
+		deleted: z.literal(true),
+	})
+	.meta({ id: "VectorStoreDeleted" });
+
+// ── Vector store files ───────────────────────────────────────────────────────
+
+export const VectorStoreFileIn = z
+	.object({
+		file_id: z.string(),
+		attributes: VectorStoreAttributes.nullish(),
+		chunking_strategy: ChunkingStrategyIn.optional(),
+	})
+	.meta({ id: "VectorStoreFileIn" });
+
+/** The OpenAI vector store file object. Its `id` IS the Files-API file id. */
+export const VectorStoreFileOut = z
+	.object({
+		id: z.string(),
+		object: z.literal("vector_store.file"),
+		usage_bytes: z.number().int(),
+		created_at: z.number().int(),
+		vector_store_id: z.string(),
+		status: z.enum(["in_progress", "completed", "failed", "cancelled"]),
+		last_error: z
+			.object({
+				code: z.enum(["server_error", "unsupported_file", "invalid_file"]),
+				message: z.string(),
+			})
+			.nullable(),
+		chunking_strategy: ChunkingStrategyOut,
+		attributes: VectorStoreAttributes.nullable(),
+	})
+	.meta({ id: "VectorStoreFileOut" });
+
+export const VectorStoreFileListOut = z
+	.object({
+		object: z.literal("list"),
+		data: z.array(VectorStoreFileOut),
+		first_id: z.string().nullable(),
+		last_id: z.string().nullable(),
+		has_more: z.boolean(),
+	})
+	.meta({ id: "VectorStoreFileListOut" });
+
+/** Update body: attributes only (chunking is frozen once indexed). */
+export const VectorStoreFileUpdate = z
+	.object({
+		attributes: VectorStoreAttributes.nullable(),
+	})
+	.meta({ id: "VectorStoreFileUpdate" });
+
+export const VectorStoreFileDeleted = z
+	.object({
+		id: z.string(),
+		object: z.literal("vector_store.file.deleted"),
+		deleted: z.literal(true),
+	})
+	.meta({ id: "VectorStoreFileDeleted" });
+
+// ── File batches ─────────────────────────────────────────────────────────────
+
+/** Batch create: either flat `file_ids` (shared attributes/chunking) or
+ *  per-file `files` entries — exactly one of the two. */
+export const VectorStoreFileBatchIn = z
+	.object({
+		file_ids: z.array(z.string()).min(1).max(2000).optional(),
+		attributes: VectorStoreAttributes.nullish(),
+		chunking_strategy: ChunkingStrategyIn.optional(),
+		files: z
+			.array(
+				z.object({
+					file_id: z.string(),
+					attributes: VectorStoreAttributes.nullish(),
+					chunking_strategy: ChunkingStrategyIn.optional(),
+				}),
+			)
+			.min(1)
+			.max(2000)
+			.optional(),
+	})
+	.refine((v) => !!v.file_ids !== !!v.files, {
+		message: "provide exactly one of file_ids or files",
+	})
+	.meta({ id: "VectorStoreFileBatchIn" });
+
+/** The batch object — wire `object` is `vector_store.files_batch` (plural,
+ *  matching OpenAI's spec; their docs prose says `file_batch`). */
+export const VectorStoreFileBatchOut = z
+	.object({
+		id: z.string(),
+		object: z.literal("vector_store.files_batch"),
+		created_at: z.number().int(),
+		vector_store_id: z.string(),
+		status: z.enum(["in_progress", "completed", "cancelled", "failed"]),
+		file_counts: VectorStoreFileCounts,
+	})
+	.meta({ id: "VectorStoreFileBatchOut" });
+
+// ── Search ───────────────────────────────────────────────────────────────────
+
+export const VectorStoreSearchIn = z
+	.object({
+		query: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]),
+		max_num_results: z.number().int().min(1).max(50).optional(),
+		filters: VectorStoreFilter.nullish(),
+		ranking_options: z
+			.object({
+				score_threshold: z.number().min(0).max(1).optional(),
+			})
+			.optional(),
+	})
+	.meta({ id: "VectorStoreSearchIn" });
+
+export const VectorStoreSearchResult = z
+	.object({
+		file_id: z.string(),
+		filename: z.string(),
+		/** Cosine similarity in [0, 1]. */
+		score: z.number(),
+		attributes: VectorStoreAttributes.nullable(),
+		content: z.array(z.object({ type: z.literal("text"), text: z.string() })),
+	})
+	.meta({ id: "VectorStoreSearchResult" });
+
+/** The search page — OpenAI's `search_results.page` envelope. `search_query`
+ *  is an array even for a single query, per the OpenAI spec. */
+export const VectorStoreSearchOut = z
+	.object({
+		object: z.literal("vector_store.search_results.page"),
+		search_query: z.array(z.string()),
+		data: z.array(VectorStoreSearchResult),
+		has_more: z.boolean(),
+		next_page: z.string().nullable(),
+	})
+	.meta({ id: "VectorStoreSearchOut" });
+
+// ── Inferred consumer-facing types (re-exported by ../responses) ─────────────
+
+export type ICVectorStore = z.infer<typeof VectorStoreOut>;
+export type ICVectorStoreFile = z.infer<typeof VectorStoreFileOut>;
+export type ICVectorStoreFileBatch = z.infer<typeof VectorStoreFileBatchOut>;
+export type ICVectorStoreSearchPage = z.infer<typeof VectorStoreSearchOut>;
+export type ICVectorStoreAttributes = z.infer<typeof VectorStoreAttributes>;

package/ts/zod/whatsapp.ts

@@ -0,0 +1,54 @@
+/**
+ * Hand-authored Zod schemas for the `whatsapp` 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";
+
+/**
+ * A tenant's WhatsApp number as hosted under Ingram Cloud's shared Meta app.
+ * Secrets are never returned; the optional fields are present only once
+ * `configured` is true. `display_phone_number` is the E.164 number Meta has on
+ * file for the registered `phone_number_id`, and can be null until Meta reports
+ * it. `webhook_url` is IC's single app-level webhook (informational — IC
+ * subscribes the number to it for you).
+ */
+export const WhatsAppConfigOut = z
+	.object({
+		configured: z.boolean(),
+		phone_number_id: z.string().optional(),
+		display_phone_number: z.string().nullable().optional(),
+		waba_id: z.string().nullable().optional(),
+		webhook_url: z.string().optional(),
+	})
+	.meta({ id: "WhatsAppConfigOut" });
+
+// ── Request bodies ──────────────────────────────────────────────────────────
+
+/**
+ * Register (or rotate) a tenant's WhatsApp number. IC validates the token,
+ * subscribes its shared app to the WABA so inbound flows to the app-level
+ * webhook, and stores the mapping. All three fields are required; they're
+ * optional at the shape layer so the handler returns its specific
+ * `empty_config` code rather than a pre-handler `invalid_request`.
+ */
+export const WhatsAppConfigIn = z
+	.object({
+		phone_number_id: z.string().optional(),
+		access_token: z.string().optional(),
+		waba_id: z.string().optional(),
+	})
+	.meta({ id: "WhatsAppConfigIn" });
+
+// ── Inferred consumer-facing types (re-exported by ../responses) ─────────────
+
+export type ICWhatsAppConfig = z.infer<typeof WhatsAppConfigOut>;