@promptlycms/prompts 0.1.1 → 0.1.2

package/README.md

@@ -1,11 +1,12 @@
 # @promptlycms/prompts
 
-TypeScript SDK for the [Promptly CMS](https://promptlycms.com) API. Fetch prompts at runtime, get typed template variables via codegen, and integrate with the [Vercel AI SDK](https://sdk.vercel.ai).
+TypeScript SDK for the [Promptly CMS](https://promptlycms.com) API. Stop hardcoding prompts in your codebase — manage them in a purpose-built CMS with versioning and instant publishing, then fetch them at runtime with full type safety.
 
-- **Runtime client** — `getPrompt()`, `getPrompts()`, `aiParams()` with full TypeScript support
+- **Zero hardcoded prompts** — fetch prompts at runtime; update wording, models, and settings from the [CMS](https://promptlycms.com) without code changes or redeploys
+- **Runtime client** — `getPrompt()` and `getPrompts()` with full TypeScript support
 - **Codegen CLI** — generates typed template variables via declaration merging
-- **AI SDK integration** — spread-ready params for `generateText` / `streamText`
-- **Model auto-detection** — resolves Anthropic, OpenAI, Google, and Mistral models automatically
+- **AI SDK integration** — destructure directly into [Vercel AI SDK](https://ai-sdk.dev/) `generateText` / `streamText`
+- **Any AI provider** — supports [all providers](https://ai-sdk.dev/providers/ai-sdk-providers#provider-support) supported by the Vercel AI SDK
 - **Structured output** — Zod schemas built from CMS-defined output schemas
 
 ## Install
@@ -117,22 +118,22 @@ welcomePrompt.userMessage({ email: 'a@b.com', subject: 'Hi' });
 
 ## AI SDK integration
 
-`aiParams()` returns an object you can spread directly into Vercel AI SDK functions:
+Destructure `getPrompt()` and pass the properties directly to Vercel AI SDK functions:
 
 ```typescript
 import { generateText } from 'ai';
 
-const params = await promptly.aiParams('my-prompt', {
-  variables: { name: 'Alice', task: 'coding' },
-});
+const { userMessage, systemMessage, temperature, model } = await promptly.getPrompt('my-prompt');
 
 const { text } = await generateText({
-  ...params,
-  // model is already included from your CMS prompt config
+  model,
+  system: systemMessage,
+  prompt: userMessage({ name: 'Alice', task: 'coding' }),
+  temperature,
 });
 ```
 
-The model configured in the CMS is auto-resolved to the correct AI SDK provider. If the prompt has a structured output schema defined in the CMS, `params.output` is automatically populated with a Zod schema wrapped in `Output.object()`.
+The model configured in the CMS is auto-resolved to the correct AI SDK provider.
 
 ## Model auto-detection
 
@@ -220,7 +221,7 @@ try {
 | `baseUrl` | `string` | No       | API base URL (default: `https://api.promptlycms.com`) |
 | `model`   | `(modelId: string) => LanguageModel` | No | Custom model resolver — overrides auto-detection |
 
-Returns a `PromptlyClient` with `getPrompt()`, `getPrompts()`, and `aiParams()` methods.
+Returns a `PromptlyClient` with `getPrompt()` and `getPrompts()` methods.
 
 ### `client.getPrompt(promptId, options?)`
 
@@ -234,15 +235,6 @@ Fetch a single prompt. Returns `PromptResult` with typed `userMessage` when code
 
 Fetch multiple prompts in parallel. Accepts `PromptRequest[]` and returns a typed tuple matching the input order.
 
-### `client.aiParams(promptId, options?)`
-
-Fetch a prompt and return params ready to spread into AI SDK functions (`system`, `prompt`, `temperature`, `model`, and optionally `output`).
-
-| Option      | Type                    | Description                    |
-|-------------|-------------------------|--------------------------------|
-| `version`   | `string`                | Specific version to fetch      |
-| `variables` | `Record<string, string>` | Template variables to interpolate |
-
 ### `@promptlycms/prompts/schema`
 
 Subpath export for working with Zod schemas from CMS schema fields:

package/dist/cli.js

@@ -43,9 +43,6 @@ var createErrorFromResponse = async (response) => {
 import { writeFile } from "fs/promises";
 import { createRequire } from "module";
 
-// src/schema/builder.ts
-import { z } from "zod";
-
 // src/client.ts
 var PROVIDER_PREFIXES = [
   ["claude", "anthropic"],

package/dist/index.cjs

@@ -71,286 +71,6 @@ var createErrorFromResponse = async (response) => {
   }
 };
 
-// src/schema/builder.ts
-var import_zod = require("zod");
-var resolveTypeString = (typeStr) => {
-  const builder = TYPE_BUILDERS.get(typeStr);
-  if (builder) {
-    return builder({
-      id: "",
-      name: "",
-      type: typeStr,
-      validations: [],
-      params: {}
-    });
-  }
-  return import_zod.z.string();
-};
-var buildCoercible = (params, coerced, standard) => {
-  if (params.coerce) {
-    return coerced;
-  }
-  return standard;
-};
-var TYPE_BUILDERS = /* @__PURE__ */ new Map([
-  ["string", (f) => buildCoercible(f.params, import_zod.z.coerce.string(), import_zod.z.string())],
-  ["number", (f) => buildCoercible(f.params, import_zod.z.coerce.number(), import_zod.z.number())],
-  ["boolean", (f) => buildCoercible(f.params, import_zod.z.coerce.boolean(), import_zod.z.boolean())],
-  ["date", (f) => buildCoercible(f.params, import_zod.z.coerce.date(), import_zod.z.date())],
-  ["bigint", (f) => buildCoercible(f.params, import_zod.z.coerce.bigint(), import_zod.z.bigint())],
-  ["null", () => import_zod.z.null()],
-  ["undefined", () => import_zod.z.undefined()],
-  ["void", () => import_zod.z.void()],
-  ["any", () => import_zod.z.any()],
-  ["unknown", () => import_zod.z.unknown()],
-  ["never", () => import_zod.z.never()],
-  ["nan", () => import_zod.z.nan()],
-  ["symbol", () => import_zod.z.symbol()],
-  [
-    "enum",
-    (f) => {
-      const values = f.params.enumValues ?? [];
-      return import_zod.z.enum(values);
-    }
-  ],
-  [
-    "literal",
-    (f) => {
-      const value = f.params.enumValues?.[0] ?? "";
-      return import_zod.z.literal(value);
-    }
-  ],
-  [
-    "array",
-    (f) => {
-      if (f.params.isTuple && f.params.tupleTypes) {
-        const types = f.params.tupleTypes.map(resolveTypeString);
-        return import_zod.z.tuple(types);
-      }
-      const elementSchema = f.params.elementType ? resolveTypeString(f.params.elementType) : import_zod.z.unknown();
-      return import_zod.z.array(elementSchema);
-    }
-  ],
-  [
-    "object",
-    (f) => {
-      const schema = import_zod.z.object({});
-      if (f.params.isStrict) {
-        return schema.strict();
-      }
-      if (f.params.isPassthrough) {
-        return schema.passthrough();
-      }
-      return schema;
-    }
-  ],
-  [
-    "record",
-    (f) => {
-      const keySchema = f.params.keyType ? resolveTypeString(f.params.keyType) : import_zod.z.string();
-      const valueSchema = f.params.valueType ? resolveTypeString(f.params.valueType) : import_zod.z.unknown();
-      return import_zod.z.record(keySchema, valueSchema);
-    }
-  ],
-  [
-    "map",
-    (f) => {
-      const keySchema = f.params.keyType ? resolveTypeString(f.params.keyType) : import_zod.z.string();
-      const valueSchema = f.params.valueType ? resolveTypeString(f.params.valueType) : import_zod.z.unknown();
-      return import_zod.z.map(keySchema, valueSchema);
-    }
-  ],
-  [
-    "set",
-    (f) => {
-      const elementSchema = f.params.elementType ? resolveTypeString(f.params.elementType) : import_zod.z.unknown();
-      return import_zod.z.set(elementSchema);
-    }
-  ],
-  [
-    "union",
-    (f) => {
-      if (f.params.isDiscriminatedUnion && f.params.discriminatedUnion) {
-        const { discriminator, cases } = f.params.discriminatedUnion;
-        const schemas = Object.values(cases).map(
-          (c) => import_zod.z.object({
-            [discriminator]: import_zod.z.literal(c.value),
-            ...Object.fromEntries(
-              c.fields.map((field) => [field.name, buildFieldSchema(field)])
-            )
-          })
-        );
-        return import_zod.z.discriminatedUnion(
-          discriminator,
-          schemas
-        );
-      }
-      const types = (f.params.unionTypes ?? []).map(resolveTypeString);
-      return import_zod.z.union(types);
-    }
-  ],
-  [
-    "intersection",
-    (f) => {
-      const types = (f.params.unionTypes ?? []).map(resolveTypeString);
-      return import_zod.z.intersection(types[0] ?? import_zod.z.unknown(), types[1] ?? import_zod.z.unknown());
-    }
-  ]
-]);
-var coerceDefaultValue = (value, fieldType) => {
-  const coercers = /* @__PURE__ */ new Map([
-    ["number", (v) => Number(v)],
-    ["boolean", (v) => v === "true"],
-    ["bigint", (v) => BigInt(v)]
-  ]);
-  const coercer = coercers.get(fieldType);
-  if (coercer) {
-    return coercer(value);
-  }
-  return value;
-};
-var applySizeValidation = (schema, type, value, message) => {
-  const num = Number(value);
-  if (schema instanceof import_zod.z.ZodString) {
-    const methods = {
-      min: (n, m) => schema.min(n, m),
-      max: (n, m) => schema.max(n, m),
-      length: (n, m) => schema.length(n, m)
-    };
-    return methods[type]?.(num, message) ?? schema;
-  }
-  if (schema instanceof import_zod.z.ZodNumber) {
-    const methods = {
-      min: (n, m) => schema.min(n, m),
-      max: (n, m) => schema.max(n, m)
-    };
-    return methods[type]?.(num, message) ?? schema;
-  }
-  if (schema instanceof import_zod.z.ZodArray) {
-    const methods = {
-      min: (n) => schema.min(n),
-      max: (n) => schema.max(n),
-      length: (n) => schema.length(n)
-    };
-    return methods[type]?.(num) ?? schema;
-  }
-  return schema;
-};
-var VALIDATION_APPLICATORS = /* @__PURE__ */ new Map([
-  // Size validations
-  ["min", (s, r) => applySizeValidation(s, "min", r.value, r.message)],
-  ["max", (s, r) => applySizeValidation(s, "max", r.value, r.message)],
-  ["length", (s, r) => applySizeValidation(s, "length", r.value, r.message)],
-  // String validations
-  ["email", (s, r) => s instanceof import_zod.z.ZodString ? s.email(r.message) : s],
-  ["url", (s, r) => s instanceof import_zod.z.ZodString ? s.url(r.message) : s],
-  ["uuid", (s, r) => s instanceof import_zod.z.ZodString ? s.uuid(r.message) : s],
-  ["cuid", (s, r) => s instanceof import_zod.z.ZodString ? s.cuid(r.message) : s],
-  ["cuid2", (s, r) => s instanceof import_zod.z.ZodString ? s.cuid2(r.message) : s],
-  ["ulid", (s, r) => s instanceof import_zod.z.ZodString ? s.ulid(r.message) : s],
-  [
-    "regex",
-    (s, r) => s instanceof import_zod.z.ZodString ? s.regex(new RegExp(r.value), r.message) : s
-  ],
-  [
-    "startsWith",
-    (s, r) => s instanceof import_zod.z.ZodString ? s.startsWith(r.value, r.message) : s
-  ],
-  [
-    "endsWith",
-    (s, r) => s instanceof import_zod.z.ZodString ? s.endsWith(r.value, r.message) : s
-  ],
-  [
-    "datetime",
-    (s, _r, f) => {
-      if (!(s instanceof import_zod.z.ZodString)) {
-        return s;
-      }
-      const opts = f.params.stringOptions?.datetime;
-      return s.datetime(opts);
-    }
-  ],
-  [
-    "ip",
-    (s, _r, f) => {
-      if (!(s instanceof import_zod.z.ZodString)) {
-        return s;
-      }
-      const version = f.params.stringOptions?.ip?.version;
-      if (version === "v6") {
-        return s.ipv6();
-      }
-      return s.ipv4();
-    }
-  ],
-  // String transforms
-  ["trim", (s) => s instanceof import_zod.z.ZodString ? s.trim() : s],
-  ["toLowerCase", (s) => s instanceof import_zod.z.ZodString ? s.toLowerCase() : s],
-  ["toUpperCase", (s) => s instanceof import_zod.z.ZodString ? s.toUpperCase() : s],
-  // Number validations
-  ["int", (s, r) => s instanceof import_zod.z.ZodNumber ? s.int(r.message) : s],
-  [
-    "positive",
-    (s, r) => s instanceof import_zod.z.ZodNumber ? s.positive(r.message) : s
-  ],
-  [
-    "negative",
-    (s, r) => s instanceof import_zod.z.ZodNumber ? s.negative(r.message) : s
-  ],
-  [
-    "multipleOf",
-    (s, r) => s instanceof import_zod.z.ZodNumber ? s.multipleOf(Number(r.value), r.message) : s
-  ],
-  ["finite", (s, r) => s instanceof import_zod.z.ZodNumber ? s.finite(r.message) : s],
-  ["safe", (s, r) => s instanceof import_zod.z.ZodNumber ? s.safe(r.message) : s],
-  // Collection
-  [
-    "nonempty",
-    (s) => {
-      if (s instanceof import_zod.z.ZodString) {
-        return s.min(1);
-      }
-      if (s instanceof import_zod.z.ZodArray) {
-        return s.nonempty();
-      }
-      return s;
-    }
-  ],
-  // Wrapping modifiers
-  ["optional", (s) => s.optional()],
-  ["nullable", (s) => s.nullable()],
-  ["nullish", (s) => s.nullish()],
-  // Default & catch
-  ["default", (s, r, f) => s.default(coerceDefaultValue(r.value, f.type))],
-  ["catch", (s, r, f) => s.catch(coerceDefaultValue(r.value, f.type))],
-  // Readonly
-  ["readonly", (s) => s.readonly()]
-]);
-var buildFieldSchema = (field) => {
-  const builder = TYPE_BUILDERS.get(field.type);
-  if (!builder) {
-    return import_zod.z.unknown();
-  }
-  let schema = builder(field);
-  for (const rule of field.validations) {
-    const applicator = VALIDATION_APPLICATORS.get(rule.type);
-    if (applicator) {
-      schema = applicator(schema, rule, field);
-    }
-  }
-  if (field.params.description) {
-    schema = schema.describe(field.params.description);
-  }
-  return schema;
-};
-var buildZodSchema = (fields) => {
-  const shape = {};
-  for (const field of fields) {
-    shape[field.name] = buildFieldSchema(field);
-  }
-  return import_zod.z.object(shape);
-};
-
 // src/client.ts
 var DEFAULT_BASE_URL = "https://api.promptlycms.com";
 var MODEL_ID_MAP = {
@@ -503,26 +223,7 @@ var createPromptlyClient = (config) => {
     );
     return results;
   };
-  const aiParams = async (promptId, options) => {
-    const prompt = await fetchPrompt(promptId, {
-      version: options?.version
-    });
-    const userMessage = options?.variables ? interpolate(prompt.userMessage, options.variables) : prompt.userMessage;
-    const model = await modelResolver(prompt.config.model);
-    const result = {
-      system: prompt.systemMessage,
-      prompt: userMessage,
-      temperature: prompt.config.temperature,
-      model
-    };
-    if (prompt.config.schema && prompt.config.schema.length > 0) {
-      const schema = buildZodSchema(prompt.config.schema);
-      const { Output } = await import("ai");
-      result.output = Output.object({ schema });
-    }
-    return result;
-  };
-  return { getPrompt, getPrompts, aiParams };
+  return { getPrompt, getPrompts };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { P as PromptlyClientConfig, a as PromptlyClient, E as ErrorCode } from './types-W-omtl43.cjs';
-export { A as AiParams, b as AiParamsOptions, c as ErrorResponse, G as GetOptions, d as PromptConfig, e as PromptId, f as PromptMessage, g as PromptRequest, h as PromptResponse, i as PromptResult, j as PromptVariableMap, k as PromptVersion, l as PublishedVersion, S as SchemaField, m as SchemaFieldParams, V as ValidationRule } from './types-W-omtl43.cjs';
+import { P as PromptlyClientConfig, a as PromptlyClient, E as ErrorCode } from './types-BbNpKJej.cjs';
+export { b as ErrorResponse, G as GetOptions, c as PromptConfig, d as PromptId, e as PromptMessage, f as PromptRequest, g as PromptResponse, h as PromptResult, i as PromptVariableMap, j as PromptVersion, k as PublishedVersion, S as SchemaField, l as SchemaFieldParams, V as ValidationRule } from './types-BbNpKJej.cjs';
 import 'ai';
 
 declare const getSdkModelId: (modelId: string) => string;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { P as PromptlyClientConfig, a as PromptlyClient, E as ErrorCode } from './types-W-omtl43.js';
-export { A as AiParams, b as AiParamsOptions, c as ErrorResponse, G as GetOptions, d as PromptConfig, e as PromptId, f as PromptMessage, g as PromptRequest, h as PromptResponse, i as PromptResult, j as PromptVariableMap, k as PromptVersion, l as PublishedVersion, S as SchemaField, m as SchemaFieldParams, V as ValidationRule } from './types-W-omtl43.js';
+import { P as PromptlyClientConfig, a as PromptlyClient, E as ErrorCode } from './types-BbNpKJej.js';
+export { b as ErrorResponse, G as GetOptions, c as PromptConfig, d as PromptId, e as PromptMessage, f as PromptRequest, g as PromptResponse, h as PromptResult, i as PromptVariableMap, j as PromptVersion, k as PublishedVersion, S as SchemaField, l as SchemaFieldParams, V as ValidationRule } from './types-BbNpKJej.js';
 import 'ai';
 
 declare const getSdkModelId: (modelId: string) => string;

package/dist/index.js

@@ -1,7 +1,3 @@
-import {
-  buildZodSchema
-} from "./chunk-GZIUWN6H.js";
-
 // src/errors.ts
 var PromptlyError = class extends Error {
   code;
@@ -188,26 +184,7 @@ var createPromptlyClient = (config) => {
     );
     return results;
   };
-  const aiParams = async (promptId, options) => {
-    const prompt = await fetchPrompt(promptId, {
-      version: options?.version
-    });
-    const userMessage = options?.variables ? interpolate(prompt.userMessage, options.variables) : prompt.userMessage;
-    const model = await modelResolver(prompt.config.model);
-    const result = {
-      system: prompt.systemMessage,
-      prompt: userMessage,
-      temperature: prompt.config.temperature,
-      model
-    };
-    if (prompt.config.schema && prompt.config.schema.length > 0) {
-      const schema = buildZodSchema(prompt.config.schema);
-      const { Output } = await import("ai");
-      result.output = Output.object({ schema });
-    }
-    return result;
-  };
-  return { getPrompt, getPrompts, aiParams };
+  return { getPrompt, getPrompts };
 };
 export {
   PromptlyError,

package/dist/schema.d.cts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { S as SchemaField } from './types-W-omtl43.cjs';
+import { S as SchemaField } from './types-BbNpKJej.cjs';
 import 'ai';
 
 declare const buildFieldSchema: (field: SchemaField) => z.ZodTypeAny;

package/dist/schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { S as SchemaField } from './types-W-omtl43.js';
+import { S as SchemaField } from './types-BbNpKJej.js';
 import 'ai';
 
 declare const buildFieldSchema: (field: SchemaField) => z.ZodTypeAny;

package/dist/schema.js

@@ -1,7 +1,282 @@
-import {
-  buildFieldSchema,
-  buildZodSchema
-} from "./chunk-GZIUWN6H.js";
+// src/schema/builder.ts
+import { z } from "zod";
+var resolveTypeString = (typeStr) => {
+  const builder = TYPE_BUILDERS.get(typeStr);
+  if (builder) {
+    return builder({
+      id: "",
+      name: "",
+      type: typeStr,
+      validations: [],
+      params: {}
+    });
+  }
+  return z.string();
+};
+var buildCoercible = (params, coerced, standard) => {
+  if (params.coerce) {
+    return coerced;
+  }
+  return standard;
+};
+var TYPE_BUILDERS = /* @__PURE__ */ new Map([
+  ["string", (f) => buildCoercible(f.params, z.coerce.string(), z.string())],
+  ["number", (f) => buildCoercible(f.params, z.coerce.number(), z.number())],
+  ["boolean", (f) => buildCoercible(f.params, z.coerce.boolean(), z.boolean())],
+  ["date", (f) => buildCoercible(f.params, z.coerce.date(), z.date())],
+  ["bigint", (f) => buildCoercible(f.params, z.coerce.bigint(), z.bigint())],
+  ["null", () => z.null()],
+  ["undefined", () => z.undefined()],
+  ["void", () => z.void()],
+  ["any", () => z.any()],
+  ["unknown", () => z.unknown()],
+  ["never", () => z.never()],
+  ["nan", () => z.nan()],
+  ["symbol", () => z.symbol()],
+  [
+    "enum",
+    (f) => {
+      const values = f.params.enumValues ?? [];
+      return z.enum(values);
+    }
+  ],
+  [
+    "literal",
+    (f) => {
+      const value = f.params.enumValues?.[0] ?? "";
+      return z.literal(value);
+    }
+  ],
+  [
+    "array",
+    (f) => {
+      if (f.params.isTuple && f.params.tupleTypes) {
+        const types = f.params.tupleTypes.map(resolveTypeString);
+        return z.tuple(types);
+      }
+      const elementSchema = f.params.elementType ? resolveTypeString(f.params.elementType) : z.unknown();
+      return z.array(elementSchema);
+    }
+  ],
+  [
+    "object",
+    (f) => {
+      const schema = z.object({});
+      if (f.params.isStrict) {
+        return schema.strict();
+      }
+      if (f.params.isPassthrough) {
+        return schema.passthrough();
+      }
+      return schema;
+    }
+  ],
+  [
+    "record",
+    (f) => {
+      const keySchema = f.params.keyType ? resolveTypeString(f.params.keyType) : z.string();
+      const valueSchema = f.params.valueType ? resolveTypeString(f.params.valueType) : z.unknown();
+      return z.record(keySchema, valueSchema);
+    }
+  ],
+  [
+    "map",
+    (f) => {
+      const keySchema = f.params.keyType ? resolveTypeString(f.params.keyType) : z.string();
+      const valueSchema = f.params.valueType ? resolveTypeString(f.params.valueType) : z.unknown();
+      return z.map(keySchema, valueSchema);
+    }
+  ],
+  [
+    "set",
+    (f) => {
+      const elementSchema = f.params.elementType ? resolveTypeString(f.params.elementType) : z.unknown();
+      return z.set(elementSchema);
+    }
+  ],
+  [
+    "union",
+    (f) => {
+      if (f.params.isDiscriminatedUnion && f.params.discriminatedUnion) {
+        const { discriminator, cases } = f.params.discriminatedUnion;
+        const schemas = Object.values(cases).map(
+          (c) => z.object({
+            [discriminator]: z.literal(c.value),
+            ...Object.fromEntries(
+              c.fields.map((field) => [field.name, buildFieldSchema(field)])
+            )
+          })
+        );
+        return z.discriminatedUnion(
+          discriminator,
+          schemas
+        );
+      }
+      const types = (f.params.unionTypes ?? []).map(resolveTypeString);
+      return z.union(types);
+    }
+  ],
+  [
+    "intersection",
+    (f) => {
+      const types = (f.params.unionTypes ?? []).map(resolveTypeString);
+      return z.intersection(types[0] ?? z.unknown(), types[1] ?? z.unknown());
+    }
+  ]
+]);
+var coerceDefaultValue = (value, fieldType) => {
+  const coercers = /* @__PURE__ */ new Map([
+    ["number", (v) => Number(v)],
+    ["boolean", (v) => v === "true"],
+    ["bigint", (v) => BigInt(v)]
+  ]);
+  const coercer = coercers.get(fieldType);
+  if (coercer) {
+    return coercer(value);
+  }
+  return value;
+};
+var applySizeValidation = (schema, type, value, message) => {
+  const num = Number(value);
+  if (schema instanceof z.ZodString) {
+    const methods = {
+      min: (n, m) => schema.min(n, m),
+      max: (n, m) => schema.max(n, m),
+      length: (n, m) => schema.length(n, m)
+    };
+    return methods[type]?.(num, message) ?? schema;
+  }
+  if (schema instanceof z.ZodNumber) {
+    const methods = {
+      min: (n, m) => schema.min(n, m),
+      max: (n, m) => schema.max(n, m)
+    };
+    return methods[type]?.(num, message) ?? schema;
+  }
+  if (schema instanceof z.ZodArray) {
+    const methods = {
+      min: (n) => schema.min(n),
+      max: (n) => schema.max(n),
+      length: (n) => schema.length(n)
+    };
+    return methods[type]?.(num) ?? schema;
+  }
+  return schema;
+};
+var VALIDATION_APPLICATORS = /* @__PURE__ */ new Map([
+  // Size validations
+  ["min", (s, r) => applySizeValidation(s, "min", r.value, r.message)],
+  ["max", (s, r) => applySizeValidation(s, "max", r.value, r.message)],
+  ["length", (s, r) => applySizeValidation(s, "length", r.value, r.message)],
+  // String validations
+  ["email", (s, r) => s instanceof z.ZodString ? s.email(r.message) : s],
+  ["url", (s, r) => s instanceof z.ZodString ? s.url(r.message) : s],
+  ["uuid", (s, r) => s instanceof z.ZodString ? s.uuid(r.message) : s],
+  ["cuid", (s, r) => s instanceof z.ZodString ? s.cuid(r.message) : s],
+  ["cuid2", (s, r) => s instanceof z.ZodString ? s.cuid2(r.message) : s],
+  ["ulid", (s, r) => s instanceof z.ZodString ? s.ulid(r.message) : s],
+  [
+    "regex",
+    (s, r) => s instanceof z.ZodString ? s.regex(new RegExp(r.value), r.message) : s
+  ],
+  [
+    "startsWith",
+    (s, r) => s instanceof z.ZodString ? s.startsWith(r.value, r.message) : s
+  ],
+  [
+    "endsWith",
+    (s, r) => s instanceof z.ZodString ? s.endsWith(r.value, r.message) : s
+  ],
+  [
+    "datetime",
+    (s, _r, f) => {
+      if (!(s instanceof z.ZodString)) {
+        return s;
+      }
+      const opts = f.params.stringOptions?.datetime;
+      return s.datetime(opts);
+    }
+  ],
+  [
+    "ip",
+    (s, _r, f) => {
+      if (!(s instanceof z.ZodString)) {
+        return s;
+      }
+      const version = f.params.stringOptions?.ip?.version;
+      if (version === "v6") {
+        return s.ipv6();
+      }
+      return s.ipv4();
+    }
+  ],
+  // String transforms
+  ["trim", (s) => s instanceof z.ZodString ? s.trim() : s],
+  ["toLowerCase", (s) => s instanceof z.ZodString ? s.toLowerCase() : s],
+  ["toUpperCase", (s) => s instanceof z.ZodString ? s.toUpperCase() : s],
+  // Number validations
+  ["int", (s, r) => s instanceof z.ZodNumber ? s.int(r.message) : s],
+  [
+    "positive",
+    (s, r) => s instanceof z.ZodNumber ? s.positive(r.message) : s
+  ],
+  [
+    "negative",
+    (s, r) => s instanceof z.ZodNumber ? s.negative(r.message) : s
+  ],
+  [
+    "multipleOf",
+    (s, r) => s instanceof z.ZodNumber ? s.multipleOf(Number(r.value), r.message) : s
+  ],
+  ["finite", (s, r) => s instanceof z.ZodNumber ? s.finite(r.message) : s],
+  ["safe", (s, r) => s instanceof z.ZodNumber ? s.safe(r.message) : s],
+  // Collection
+  [
+    "nonempty",
+    (s) => {
+      if (s instanceof z.ZodString) {
+        return s.min(1);
+      }
+      if (s instanceof z.ZodArray) {
+        return s.nonempty();
+      }
+      return s;
+    }
+  ],
+  // Wrapping modifiers
+  ["optional", (s) => s.optional()],
+  ["nullable", (s) => s.nullable()],
+  ["nullish", (s) => s.nullish()],
+  // Default & catch
+  ["default", (s, r, f) => s.default(coerceDefaultValue(r.value, f.type))],
+  ["catch", (s, r, f) => s.catch(coerceDefaultValue(r.value, f.type))],
+  // Readonly
+  ["readonly", (s) => s.readonly()]
+]);
+var buildFieldSchema = (field) => {
+  const builder = TYPE_BUILDERS.get(field.type);
+  if (!builder) {
+    return z.unknown();
+  }
+  let schema = builder(field);
+  for (const rule of field.validations) {
+    const applicator = VALIDATION_APPLICATORS.get(rule.type);
+    if (applicator) {
+      schema = applicator(schema, rule, field);
+    }
+  }
+  if (field.params.description) {
+    schema = schema.describe(field.params.description);
+  }
+  return schema;
+};
+var buildZodSchema = (fields) => {
+  const shape = {};
+  for (const field of fields) {
+    shape[field.name] = buildFieldSchema(field);
+  }
+  return z.object(shape);
+};
 
 // src/schema/codegen.ts
 var escapeString = (str) => str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n");

package/dist/{types-W-omtl43.d.cts → types-BbNpKJej.d.cts}

@@ -110,24 +110,9 @@ type PromptlyClientConfig = {
 type GetOptions<V extends string = string> = {
     version?: V;
 };
-type AiParamsOptions = {
-    version?: string;
-    variables?: Record<string, string>;
-};
-type AiParams = {
-    system: string;
-    prompt: string;
-    temperature: number;
-    model: ai.LanguageModel;
-    output?: ReturnType<typeof ai.Output.object>;
-};
 type PromptlyClient = {
     getPrompt: <T extends string, V extends PromptVersion<T> | 'latest' = 'latest'>(promptId: T, options?: GetOptions<V>) => Promise<PromptResult<VariablesFor<T, V>>>;
     getPrompts: <const T extends readonly PromptRequest[]>(entries: T) => Promise<GetPromptsResults<T>>;
-    aiParams: <T extends string, V extends PromptVersion<T> | 'latest' = 'latest'>(promptId: T, options?: {
-        version?: V;
-        variables?: VariablesFor<T, V>;
-    }) => Promise<AiParams>;
 };
 
-export type { AiParams as A, ErrorCode as E, GetOptions as G, PromptlyClientConfig as P, SchemaField as S, ValidationRule as V, PromptlyClient as a, AiParamsOptions as b, ErrorResponse as c, PromptConfig as d, PromptId as e, PromptMessage as f, PromptRequest as g, PromptResponse as h, PromptResult as i, PromptVariableMap as j, PromptVersion as k, PublishedVersion as l, SchemaFieldParams as m };
+export type { ErrorCode as E, GetOptions as G, PromptlyClientConfig as P, SchemaField as S, ValidationRule as V, PromptlyClient as a, ErrorResponse as b, PromptConfig as c, PromptId as d, PromptMessage as e, PromptRequest as f, PromptResponse as g, PromptResult as h, PromptVariableMap as i, PromptVersion as j, PublishedVersion as k, SchemaFieldParams as l };

package/dist/{types-W-omtl43.d.ts → types-BbNpKJej.d.ts}

@@ -110,24 +110,9 @@ type PromptlyClientConfig = {
 type GetOptions<V extends string = string> = {
     version?: V;
 };
-type AiParamsOptions = {
-    version?: string;
-    variables?: Record<string, string>;
-};
-type AiParams = {
-    system: string;
-    prompt: string;
-    temperature: number;
-    model: ai.LanguageModel;
-    output?: ReturnType<typeof ai.Output.object>;
-};
 type PromptlyClient = {
     getPrompt: <T extends string, V extends PromptVersion<T> | 'latest' = 'latest'>(promptId: T, options?: GetOptions<V>) => Promise<PromptResult<VariablesFor<T, V>>>;
     getPrompts: <const T extends readonly PromptRequest[]>(entries: T) => Promise<GetPromptsResults<T>>;
-    aiParams: <T extends string, V extends PromptVersion<T> | 'latest' = 'latest'>(promptId: T, options?: {
-        version?: V;
-        variables?: VariablesFor<T, V>;
-    }) => Promise<AiParams>;
 };
 
-export type { AiParams as A, ErrorCode as E, GetOptions as G, PromptlyClientConfig as P, SchemaField as S, ValidationRule as V, PromptlyClient as a, AiParamsOptions as b, ErrorResponse as c, PromptConfig as d, PromptId as e, PromptMessage as f, PromptRequest as g, PromptResponse as h, PromptResult as i, PromptVariableMap as j, PromptVersion as k, PublishedVersion as l, SchemaFieldParams as m };
+export type { ErrorCode as E, GetOptions as G, PromptlyClientConfig as P, SchemaField as S, ValidationRule as V, PromptlyClient as a, ErrorResponse as b, PromptConfig as c, PromptId as d, PromptMessage as e, PromptRequest as f, PromptResponse as g, PromptResult as h, PromptVariableMap as i, PromptVersion as j, PublishedVersion as k, SchemaFieldParams as l };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptlycms/prompts",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "TypeScript SDK for Promptly CMS — fetch prompts, build Zod schemas, generate typed code",
   "type": "module",
   "exports": {

package/dist/chunk-GZIUWN6H.js

@@ -1,284 +0,0 @@
-// src/schema/builder.ts
-import { z } from "zod";
-var resolveTypeString = (typeStr) => {
-  const builder = TYPE_BUILDERS.get(typeStr);
-  if (builder) {
-    return builder({
-      id: "",
-      name: "",
-      type: typeStr,
-      validations: [],
-      params: {}
-    });
-  }
-  return z.string();
-};
-var buildCoercible = (params, coerced, standard) => {
-  if (params.coerce) {
-    return coerced;
-  }
-  return standard;
-};
-var TYPE_BUILDERS = /* @__PURE__ */ new Map([
-  ["string", (f) => buildCoercible(f.params, z.coerce.string(), z.string())],
-  ["number", (f) => buildCoercible(f.params, z.coerce.number(), z.number())],
-  ["boolean", (f) => buildCoercible(f.params, z.coerce.boolean(), z.boolean())],
-  ["date", (f) => buildCoercible(f.params, z.coerce.date(), z.date())],
-  ["bigint", (f) => buildCoercible(f.params, z.coerce.bigint(), z.bigint())],
-  ["null", () => z.null()],
-  ["undefined", () => z.undefined()],
-  ["void", () => z.void()],
-  ["any", () => z.any()],
-  ["unknown", () => z.unknown()],
-  ["never", () => z.never()],
-  ["nan", () => z.nan()],
-  ["symbol", () => z.symbol()],
-  [
-    "enum",
-    (f) => {
-      const values = f.params.enumValues ?? [];
-      return z.enum(values);
-    }
-  ],
-  [
-    "literal",
-    (f) => {
-      const value = f.params.enumValues?.[0] ?? "";
-      return z.literal(value);
-    }
-  ],
-  [
-    "array",
-    (f) => {
-      if (f.params.isTuple && f.params.tupleTypes) {
-        const types = f.params.tupleTypes.map(resolveTypeString);
-        return z.tuple(types);
-      }
-      const elementSchema = f.params.elementType ? resolveTypeString(f.params.elementType) : z.unknown();
-      return z.array(elementSchema);
-    }
-  ],
-  [
-    "object",
-    (f) => {
-      const schema = z.object({});
-      if (f.params.isStrict) {
-        return schema.strict();
-      }
-      if (f.params.isPassthrough) {
-        return schema.passthrough();
-      }
-      return schema;
-    }
-  ],
-  [
-    "record",
-    (f) => {
-      const keySchema = f.params.keyType ? resolveTypeString(f.params.keyType) : z.string();
-      const valueSchema = f.params.valueType ? resolveTypeString(f.params.valueType) : z.unknown();
-      return z.record(keySchema, valueSchema);
-    }
-  ],
-  [
-    "map",
-    (f) => {
-      const keySchema = f.params.keyType ? resolveTypeString(f.params.keyType) : z.string();
-      const valueSchema = f.params.valueType ? resolveTypeString(f.params.valueType) : z.unknown();
-      return z.map(keySchema, valueSchema);
-    }
-  ],
-  [
-    "set",
-    (f) => {
-      const elementSchema = f.params.elementType ? resolveTypeString(f.params.elementType) : z.unknown();
-      return z.set(elementSchema);
-    }
-  ],
-  [
-    "union",
-    (f) => {
-      if (f.params.isDiscriminatedUnion && f.params.discriminatedUnion) {
-        const { discriminator, cases } = f.params.discriminatedUnion;
-        const schemas = Object.values(cases).map(
-          (c) => z.object({
-            [discriminator]: z.literal(c.value),
-            ...Object.fromEntries(
-              c.fields.map((field) => [field.name, buildFieldSchema(field)])
-            )
-          })
-        );
-        return z.discriminatedUnion(
-          discriminator,
-          schemas
-        );
-      }
-      const types = (f.params.unionTypes ?? []).map(resolveTypeString);
-      return z.union(types);
-    }
-  ],
-  [
-    "intersection",
-    (f) => {
-      const types = (f.params.unionTypes ?? []).map(resolveTypeString);
-      return z.intersection(types[0] ?? z.unknown(), types[1] ?? z.unknown());
-    }
-  ]
-]);
-var coerceDefaultValue = (value, fieldType) => {
-  const coercers = /* @__PURE__ */ new Map([
-    ["number", (v) => Number(v)],
-    ["boolean", (v) => v === "true"],
-    ["bigint", (v) => BigInt(v)]
-  ]);
-  const coercer = coercers.get(fieldType);
-  if (coercer) {
-    return coercer(value);
-  }
-  return value;
-};
-var applySizeValidation = (schema, type, value, message) => {
-  const num = Number(value);
-  if (schema instanceof z.ZodString) {
-    const methods = {
-      min: (n, m) => schema.min(n, m),
-      max: (n, m) => schema.max(n, m),
-      length: (n, m) => schema.length(n, m)
-    };
-    return methods[type]?.(num, message) ?? schema;
-  }
-  if (schema instanceof z.ZodNumber) {
-    const methods = {
-      min: (n, m) => schema.min(n, m),
-      max: (n, m) => schema.max(n, m)
-    };
-    return methods[type]?.(num, message) ?? schema;
-  }
-  if (schema instanceof z.ZodArray) {
-    const methods = {
-      min: (n) => schema.min(n),
-      max: (n) => schema.max(n),
-      length: (n) => schema.length(n)
-    };
-    return methods[type]?.(num) ?? schema;
-  }
-  return schema;
-};
-var VALIDATION_APPLICATORS = /* @__PURE__ */ new Map([
-  // Size validations
-  ["min", (s, r) => applySizeValidation(s, "min", r.value, r.message)],
-  ["max", (s, r) => applySizeValidation(s, "max", r.value, r.message)],
-  ["length", (s, r) => applySizeValidation(s, "length", r.value, r.message)],
-  // String validations
-  ["email", (s, r) => s instanceof z.ZodString ? s.email(r.message) : s],
-  ["url", (s, r) => s instanceof z.ZodString ? s.url(r.message) : s],
-  ["uuid", (s, r) => s instanceof z.ZodString ? s.uuid(r.message) : s],
-  ["cuid", (s, r) => s instanceof z.ZodString ? s.cuid(r.message) : s],
-  ["cuid2", (s, r) => s instanceof z.ZodString ? s.cuid2(r.message) : s],
-  ["ulid", (s, r) => s instanceof z.ZodString ? s.ulid(r.message) : s],
-  [
-    "regex",
-    (s, r) => s instanceof z.ZodString ? s.regex(new RegExp(r.value), r.message) : s
-  ],
-  [
-    "startsWith",
-    (s, r) => s instanceof z.ZodString ? s.startsWith(r.value, r.message) : s
-  ],
-  [
-    "endsWith",
-    (s, r) => s instanceof z.ZodString ? s.endsWith(r.value, r.message) : s
-  ],
-  [
-    "datetime",
-    (s, _r, f) => {
-      if (!(s instanceof z.ZodString)) {
-        return s;
-      }
-      const opts = f.params.stringOptions?.datetime;
-      return s.datetime(opts);
-    }
-  ],
-  [
-    "ip",
-    (s, _r, f) => {
-      if (!(s instanceof z.ZodString)) {
-        return s;
-      }
-      const version = f.params.stringOptions?.ip?.version;
-      if (version === "v6") {
-        return s.ipv6();
-      }
-      return s.ipv4();
-    }
-  ],
-  // String transforms
-  ["trim", (s) => s instanceof z.ZodString ? s.trim() : s],
-  ["toLowerCase", (s) => s instanceof z.ZodString ? s.toLowerCase() : s],
-  ["toUpperCase", (s) => s instanceof z.ZodString ? s.toUpperCase() : s],
-  // Number validations
-  ["int", (s, r) => s instanceof z.ZodNumber ? s.int(r.message) : s],
-  [
-    "positive",
-    (s, r) => s instanceof z.ZodNumber ? s.positive(r.message) : s
-  ],
-  [
-    "negative",
-    (s, r) => s instanceof z.ZodNumber ? s.negative(r.message) : s
-  ],
-  [
-    "multipleOf",
-    (s, r) => s instanceof z.ZodNumber ? s.multipleOf(Number(r.value), r.message) : s
-  ],
-  ["finite", (s, r) => s instanceof z.ZodNumber ? s.finite(r.message) : s],
-  ["safe", (s, r) => s instanceof z.ZodNumber ? s.safe(r.message) : s],
-  // Collection
-  [
-    "nonempty",
-    (s) => {
-      if (s instanceof z.ZodString) {
-        return s.min(1);
-      }
-      if (s instanceof z.ZodArray) {
-        return s.nonempty();
-      }
-      return s;
-    }
-  ],
-  // Wrapping modifiers
-  ["optional", (s) => s.optional()],
-  ["nullable", (s) => s.nullable()],
-  ["nullish", (s) => s.nullish()],
-  // Default & catch
-  ["default", (s, r, f) => s.default(coerceDefaultValue(r.value, f.type))],
-  ["catch", (s, r, f) => s.catch(coerceDefaultValue(r.value, f.type))],
-  // Readonly
-  ["readonly", (s) => s.readonly()]
-]);
-var buildFieldSchema = (field) => {
-  const builder = TYPE_BUILDERS.get(field.type);
-  if (!builder) {
-    return z.unknown();
-  }
-  let schema = builder(field);
-  for (const rule of field.validations) {
-    const applicator = VALIDATION_APPLICATORS.get(rule.type);
-    if (applicator) {
-      schema = applicator(schema, rule, field);
-    }
-  }
-  if (field.params.description) {
-    schema = schema.describe(field.params.description);
-  }
-  return schema;
-};
-var buildZodSchema = (fields) => {
-  const shape = {};
-  for (const field of fields) {
-    shape[field.name] = buildFieldSchema(field);
-  }
-  return z.object(shape);
-};
-
-export {
-  buildFieldSchema,
-  buildZodSchema
-};