@happyvertical/smrt-prompts 0.30.0

package/dist/index.js

@@ -0,0 +1,784 @@
+import { ObjectRegistry, field, smrt, SmrtObject, SmrtCollection } from "@happyvertical/smrt-core";
+import { getPackageConfig } from "@happyvertical/smrt-config";
+import { getTenantId } from "@happyvertical/smrt-tenancy";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+const PROMPT_CACHE_TTL_MS = 3e4;
+const promptCache = /* @__PURE__ */ new Map();
+const dbInstanceIds = /* @__PURE__ */ new WeakMap();
+let nextDbId = 1;
+function getDbNamespace(db) {
+  if (!db) {
+    return "no-db";
+  }
+  if (typeof db === "string") {
+    return `db:${db}`;
+  }
+  if (typeof db === "object") {
+    const dbObject = db;
+    if (typeof dbObject.query === "function") {
+      if (!dbInstanceIds.has(dbObject)) {
+        dbInstanceIds.set(dbObject, `db-instance:${nextDbId++}`);
+      }
+      const namespace = dbInstanceIds.get(dbObject);
+      if (namespace) {
+        return namespace;
+      }
+      return "db-instance:unknown";
+    }
+    try {
+      return `db-config:${JSON.stringify(dbObject)}`;
+    } catch {
+      return "db-config:opaque";
+    }
+  }
+  return "db:unknown";
+}
+function buildCacheKey(key, tenantId, db) {
+  return `${getDbNamespace(db)}::${key}::${tenantId ?? "app"}`;
+}
+function getPromptCacheTtlMs() {
+  return PROMPT_CACHE_TTL_MS;
+}
+function getCachedPromptBase(key, tenantId, db) {
+  const cacheKey = buildCacheKey(key, tenantId, db);
+  const cached = promptCache.get(cacheKey);
+  if (!cached) {
+    return null;
+  }
+  if (cached.expiresAt <= Date.now()) {
+    promptCache.delete(cacheKey);
+    return null;
+  }
+  return cached.value;
+}
+function setCachedPromptBase(key, tenantId, db, value) {
+  promptCache.set(buildCacheKey(key, tenantId, db), {
+    expiresAt: Date.now() + PROMPT_CACHE_TTL_MS,
+    value
+  });
+}
+function invalidatePromptCache(key, tenantId, db) {
+  const dbNamespace = getDbNamespace(db);
+  if (tenantId !== null && tenantId !== void 0) {
+    promptCache.delete(buildCacheKey(key, tenantId, db));
+    return;
+  }
+  const keyPrefix = `${dbNamespace}::${key}::`;
+  for (const cacheKey of promptCache.keys()) {
+    if (cacheKey.startsWith(keyPrefix)) {
+      promptCache.delete(cacheKey);
+    }
+  }
+}
+function clearPromptCache() {
+  promptCache.clear();
+}
+const DEFAULT_EDITABLE = {
+  template: false,
+  profile: false,
+  model: false,
+  params: false
+};
+const TOP_LEVEL_RESERVED_KEYS = /* @__PURE__ */ new Set([
+  "key",
+  "editable",
+  "template",
+  "ai",
+  "profile",
+  "provider",
+  "model",
+  "params",
+  "temperature",
+  "maxTokens"
+]);
+const AI_RESERVED_KEYS = /* @__PURE__ */ new Set([
+  "profile",
+  "provider",
+  "model",
+  "params",
+  "temperature",
+  "maxTokens"
+]);
+const AI_ROUTING_PARAM_KEYS = /* @__PURE__ */ new Set([
+  "profile",
+  "provider",
+  "type",
+  "model",
+  "defaultModel"
+]);
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeEditableConfig(editable) {
+  return {
+    template: editable?.template ?? DEFAULT_EDITABLE.template,
+    profile: editable?.profile ?? DEFAULT_EDITABLE.profile,
+    model: editable?.model ?? DEFAULT_EDITABLE.model,
+    params: editable?.params ?? DEFAULT_EDITABLE.params
+  };
+}
+function extractPromptParams(source, reservedKeys) {
+  const params = {};
+  if (isPlainObject(source.params)) {
+    Object.assign(params, sanitizePromptParams(source.params));
+  }
+  if ("temperature" in source && source.temperature !== void 0) {
+    params.temperature = source.temperature;
+  }
+  if ("maxTokens" in source && source.maxTokens !== void 0) {
+    params.maxTokens = source.maxTokens;
+  }
+  for (const [key, value] of Object.entries(source)) {
+    if (reservedKeys.has(key) || value === void 0) {
+      continue;
+    }
+    assignPromptParam(params, key, value);
+  }
+  return params;
+}
+function assignPromptParam(params, key, value) {
+  if (AI_ROUTING_PARAM_KEYS.has(key) || value === void 0) {
+    return;
+  }
+  params[key] = value;
+}
+function sanitizePromptParams(params) {
+  const sanitized = {};
+  if (!params) {
+    return sanitized;
+  }
+  for (const [key, value] of Object.entries(params)) {
+    assignPromptParam(sanitized, key, value);
+  }
+  return sanitized;
+}
+function mergePromptParams(...paramLayers) {
+  const merged = {};
+  for (const layer of paramLayers) {
+    if (!layer) {
+      continue;
+    }
+    for (const [key, value] of Object.entries(layer)) {
+      assignPromptParam(merged, key, value);
+    }
+  }
+  return merged;
+}
+function normalizeAIInput(ai) {
+  if (!isPlainObject(ai)) {
+    return { params: {} };
+  }
+  const profile = typeof ai.profile === "string" || ai.profile === null ? ai.profile : void 0;
+  const model = typeof ai.model === "string" || ai.model === null ? ai.model : void 0;
+  return {
+    profile: profile ?? void 0,
+    model: model ?? void 0,
+    params: extractPromptParams(ai, AI_RESERVED_KEYS)
+  };
+}
+function normalizePromptDefinitionInput(input) {
+  return {
+    key: input.key,
+    template: input.template,
+    ai: normalizeAIInput(input.ai),
+    editable: normalizeEditableConfig(input.editable)
+  };
+}
+function normalizePromptLayer(input) {
+  if (!isPlainObject(input)) {
+    return {};
+  }
+  const nestedAi = isPlainObject(input.ai) ? normalizeAIInput(input.ai) : { params: {} };
+  const topLevelParams = extractPromptParams(input, TOP_LEVEL_RESERVED_KEYS);
+  return {
+    template: input.template === void 0 ? void 0 : input.template === null ? null : String(input.template),
+    profile: input.profile === void 0 ? nestedAi.profile : input.profile === null ? null : String(input.profile),
+    model: input.model === void 0 ? nestedAi.model : input.model === null ? null : String(input.model),
+    params: mergePromptParams(topLevelParams, nestedAi.params)
+  };
+}
+function mergePromptLayers(...layers) {
+  let template = "";
+  let profile;
+  let model;
+  let params = {};
+  for (const layer of layers) {
+    if (!layer) {
+      continue;
+    }
+    if (layer.template !== void 0 && layer.template !== null) {
+      template = layer.template;
+    }
+    if (layer.profile !== void 0 && layer.profile !== null) {
+      profile = layer.profile;
+    }
+    if (layer.model !== void 0 && layer.model !== null) {
+      model = layer.model;
+    }
+    if (layer.params !== void 0 && layer.params !== null) {
+      params = mergePromptParams(params, layer.params);
+    }
+  }
+  return {
+    template,
+    ai: {
+      profile,
+      model,
+      params
+    }
+  };
+}
+function normalizeProfileConfig(profile) {
+  const source = isPlainObject(profile) ? profile : {};
+  const params = extractPromptParams(source, /* @__PURE__ */ new Set(["provider", "model"]));
+  return {
+    provider: String(profile.provider),
+    model: String(profile.model),
+    params
+  };
+}
+function validateProfileName(profileName, config) {
+  if (profileName.trim() === "") {
+    throw new Error("Prompt profile names cannot be empty");
+  }
+  const allowedProfileNames = config.allowedProfileNames;
+  if (Array.isArray(allowedProfileNames) && !allowedProfileNames.includes(profileName)) {
+    throw new Error(
+      `Prompt profile "${profileName}" is not in the allowed profile list`
+    );
+  }
+  if (!config.profiles?.[profileName]) {
+    throw new Error(`Prompt profile "${profileName}" is not configured`);
+  }
+}
+function validateModelName(modelName, config) {
+  if (modelName.trim() === "") {
+    throw new Error("Prompt model overrides cannot be empty");
+  }
+  const allowedModels = config.allowedModels;
+  if (Array.isArray(allowedModels) && !allowedModels.includes(modelName)) {
+    throw new Error(
+      `Prompt model "${modelName}" is not in the allowed model list`
+    );
+  }
+}
+function buildResolvedAI(ai, config) {
+  let provider;
+  let model = ai.model;
+  let params = ai.params;
+  if (ai.profile) {
+    validateProfileName(ai.profile, config);
+    const configuredProfile = config.profiles?.[ai.profile];
+    if (!configuredProfile) {
+      throw new Error(`Prompt profile "${ai.profile}" is not configured`);
+    }
+    const profileConfig = normalizeProfileConfig(configuredProfile);
+    provider = profileConfig.provider;
+    model = model ?? profileConfig.model;
+    params = mergePromptParams(profileConfig.params, params);
+  }
+  if (ai.model) {
+    validateModelName(ai.model, config);
+  }
+  if (ai.model && !ai.profile) {
+    throw new Error(
+      "Direct prompt model overrides require an effective prompt profile"
+    );
+  }
+  if (model && !ai.model && config.allowedModels) {
+    validateModelName(model, config);
+  }
+  const resolved = {
+    ...params,
+    profile: ai.profile,
+    provider,
+    model,
+    ...config.allowedModels ? { allowedModels: [...config.allowedModels] } : {},
+    params
+  };
+  if (typeof params.temperature === "number") {
+    resolved.temperature = params.temperature;
+  }
+  if (typeof params.maxTokens === "number") {
+    resolved.maxTokens = params.maxTokens;
+  }
+  return resolved;
+}
+function renderPromptTemplate(template, variables) {
+  if (!variables || Object.keys(variables).length === 0) {
+    return template;
+  }
+  return template.replace(/\{([^{}]+)\}/g, (_match, rawKey) => {
+    const key = rawKey.trim();
+    const value = variables[key];
+    if (value === void 0 || value === null) {
+      return "";
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (Array.isArray(value) || isPlainObject(value)) {
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return "";
+      }
+    }
+    return String(value);
+  });
+}
+function parsePromptParams(raw) {
+  if (!raw) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return isPlainObject(parsed) ? sanitizePromptParams(parsed) : {};
+  } catch {
+    return {};
+  }
+}
+function serializePromptParams(params) {
+  if (params === null || params === void 0) {
+    return null;
+  }
+  return JSON.stringify(sanitizePromptParams(params));
+}
+function getRegistry() {
+  if (!globalThis.__smrtPromptRegistry) {
+    globalThis.__smrtPromptRegistry = /* @__PURE__ */ new Map();
+  }
+  return globalThis.__smrtPromptRegistry;
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).sort(
+      ([left], [right]) => left.localeCompare(right)
+    );
+    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+const PromptRegistry = {
+  register(input) {
+    if (!input.key || input.key.trim() === "") {
+      throw new Error("Prompt definitions require a non-empty key");
+    }
+    const definition = normalizePromptDefinitionInput(input);
+    const registry = getRegistry();
+    const existing = registry.get(definition.key);
+    if (existing) {
+      const existingSignature = stableStringify(existing);
+      const incomingSignature = stableStringify(definition);
+      if (existingSignature !== incomingSignature) {
+        throw new Error(
+          `Prompt "${definition.key}" is already registered with a different definition`
+        );
+      }
+      return existing;
+    }
+    registry.set(definition.key, definition);
+    return definition;
+  },
+  get(key) {
+    return getRegistry().get(key);
+  },
+  has(key) {
+    return getRegistry().has(key);
+  },
+  getAll() {
+    return Array.from(getRegistry().values());
+  },
+  clear() {
+    getRegistry().clear();
+  }
+};
+function definePrompt(input) {
+  return PromptRegistry.register(input);
+}
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+function getPromptConfig$1() {
+  return getPackageConfig("prompts", {
+    profiles: {},
+    prompts: {}
+  });
+}
+let PromptOverride = class extends SmrtObject {
+  key = "";
+  tenantId = null;
+  template = null;
+  profile = null;
+  model = null;
+  params = null;
+  constructor(options = {}) {
+    super(options);
+    if (options.key !== void 0) this.key = options.key;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.template !== void 0) this.template = options.template;
+    if (options.profile !== void 0) this.profile = options.profile;
+    if (options.model !== void 0) this.model = options.model;
+    if (options.params !== void 0) {
+      if (typeof options.params === "string" || options.params === null) {
+        this.params = options.params;
+      } else {
+        this.params = serializePromptParams(options.params);
+      }
+    }
+  }
+  getParams() {
+    return parsePromptParams(this.params);
+  }
+  setParams(params) {
+    this.params = serializePromptParams(params);
+  }
+  toPromptLayer() {
+    return {
+      template: this.template,
+      profile: this.profile,
+      model: this.model,
+      params: this.params === null ? null : this.getParams()
+    };
+  }
+  async save() {
+    const previousIdentity = await this.getPersistedIdentity();
+    this.normalizeParamsForPersistence();
+    await this.validatePromptOverride();
+    this.context = this.tenantId ?? "__app__";
+    const identityChanged = previousIdentity && (previousIdentity.key !== this.key || previousIdentity.tenantId !== this.tenantId);
+    const result = identityChanged && previousIdentity ? await this.saveAfterIdentityChange() : await super.save();
+    if (identityChanged && previousIdentity) {
+      invalidatePromptCache(
+        previousIdentity.key,
+        previousIdentity.tenantId,
+        this.db
+      );
+    }
+    invalidatePromptCache(this.key, this.tenantId, this.db);
+    return result;
+  }
+  async saveAfterIdentityChange() {
+    if (typeof this.db.beginTransaction === "function") {
+      return this.saveAfterIdentityChangeInTransaction();
+    }
+    return this.saveAfterIdentityChangeWithDeferredDelete();
+  }
+  async saveAfterIdentityChangeInTransaction() {
+    const originalDb = this._db;
+    const originalOptionsDb = this.options.db;
+    const tx = await this.db.beginTransaction?.();
+    if (!tx) {
+      return this.saveAfterIdentityChangeWithDeferredDelete();
+    }
+    try {
+      this._db = tx;
+      this.options.db = tx;
+      await super.delete();
+      const result = await super.save();
+      await tx.commit();
+      return result;
+    } catch (error) {
+      try {
+        await tx.rollback();
+      } catch {
+      }
+      throw error;
+    } finally {
+      this._db = originalDb;
+      this.options.db = originalOptionsDb;
+    }
+  }
+  async saveAfterIdentityChangeWithDeferredDelete() {
+    const previousId = this.id;
+    if (!previousId) {
+      return super.save();
+    }
+    const replacementId = crypto.randomUUID();
+    let replacementSaved = false;
+    this.id = replacementId;
+    try {
+      const result = await super.save();
+      replacementSaved = true;
+      await this.db.delete(this.tableName, { id: previousId });
+      return result;
+    } catch (error) {
+      if (replacementSaved) {
+        try {
+          await this.db.delete(this.tableName, { id: replacementId });
+        } catch {
+        }
+      }
+      this.id = previousId;
+      throw error;
+    }
+  }
+  async delete() {
+    const key = this.key;
+    const tenantId = this.tenantId;
+    await super.delete();
+    invalidatePromptCache(key, tenantId, this.db);
+  }
+  async validatePromptOverride() {
+    if (!this.key || this.key.trim() === "") {
+      throw new Error("PromptOverride.key is required");
+    }
+    const definition = PromptRegistry.get(this.key);
+    if (!definition) {
+      throw new Error(`Unknown prompt key "${this.key}"`);
+    }
+    const config = getPromptConfig$1();
+    const editable = definition.editable;
+    if (this.template !== null && !editable.template) {
+      throw new Error(`Prompt "${this.key}" does not allow template overrides`);
+    }
+    if (this.profile !== null && !editable.profile) {
+      throw new Error(`Prompt "${this.key}" does not allow profile overrides`);
+    }
+    if (this.model !== null && !editable.model) {
+      throw new Error(`Prompt "${this.key}" does not allow model overrides`);
+    }
+    if (this.params !== null && !editable.params) {
+      throw new Error(`Prompt "${this.key}" does not allow params overrides`);
+    }
+    if (this.params !== null) {
+      try {
+        const parsed = JSON.parse(this.params);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+          throw new Error("Prompt params must be a JSON object");
+        }
+      } catch (error) {
+        throw new Error(
+          `Prompt "${this.key}" has invalid params JSON: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (this.profile !== null) {
+      validateProfileName(this.profile, config);
+    }
+    if (this.model !== null) {
+      validateModelName(this.model, config);
+    }
+    const lowerLayers = await this.getLowerPrecedenceLayers();
+    const currentLayer = this.toPromptLayer();
+    const merged = mergePromptLayers(...lowerLayers, currentLayer);
+    if (currentLayer.model && !merged.ai.profile) {
+      throw new Error(
+        `Prompt "${this.key}" model overrides require an effective prompt profile`
+      );
+    }
+  }
+  async getLowerPrecedenceLayers() {
+    const definition = PromptRegistry.get(this.key);
+    const config = getPromptConfig$1();
+    const layers = [];
+    if (definition) {
+      layers.push({
+        template: definition.template,
+        profile: definition.ai.profile ?? null,
+        model: definition.ai.model ?? null,
+        params: definition.ai.params
+      });
+    }
+    layers.push(normalizePromptLayer(config.prompts?.[this.key]));
+    const { PromptOverrideCollection: PromptOverrideCollection2 } = await Promise.resolve().then(() => PromptOverrideCollection$1);
+    const collection = await PromptOverrideCollection2.create({
+      db: this.options.db ?? this.options.persistence
+    });
+    if (this.tenantId) {
+      const appOverride = await collection.getAppOverride(this.key, {
+        excludeId: this.id
+      });
+      if (appOverride) {
+        layers.push(appOverride.toPromptLayer());
+      }
+    }
+    return layers;
+  }
+  normalizeParamsForPersistence() {
+    const rawParams = this.params;
+    if (rawParams === null || rawParams === void 0) {
+      this.params = null;
+      return;
+    }
+    if (typeof rawParams === "string") {
+      this.params = rawParams;
+      return;
+    }
+    if (typeof rawParams === "object" && !Array.isArray(rawParams)) {
+      this.params = serializePromptParams(rawParams);
+      return;
+    }
+    throw new Error(
+      `Prompt "${this.key}" params must be a JSON object or JSON string`
+    );
+  }
+  async getPersistedIdentity() {
+    if (!this.id) {
+      return null;
+    }
+    const existing = await this.db.get(this.tableName, { id: this.id });
+    if (!existing) {
+      return null;
+    }
+    return {
+      key: String(existing.key ?? this.key),
+      tenantId: existing.tenantId !== void 0 ? existing.tenantId : existing.tenant_id ?? null
+    };
+  }
+};
+__decorateClass([
+  field({ required: true })
+], PromptOverride.prototype, "key", 2);
+__decorateClass([
+  field({ type: "text", nullable: true })
+], PromptOverride.prototype, "tenantId", 2);
+__decorateClass([
+  field({ type: "text", nullable: true })
+], PromptOverride.prototype, "template", 2);
+__decorateClass([
+  field({ type: "text", nullable: true })
+], PromptOverride.prototype, "profile", 2);
+__decorateClass([
+  field({ type: "text", nullable: true })
+], PromptOverride.prototype, "model", 2);
+__decorateClass([
+  field({ type: "text", nullable: true })
+], PromptOverride.prototype, "params", 2);
+PromptOverride = __decorateClass([
+  smrt({
+    tableName: "_smrt_prompt_overrides",
+    conflictColumns: ["key", "context"],
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    cli: {
+      include: ["list", "get", "create", "update", "delete"],
+      exclude: ["getParams", "setParams", "toPromptLayer"]
+    },
+    mcp: { include: [] }
+  })
+], PromptOverride);
+class PromptOverrideCollection extends SmrtCollection {
+  static _itemClass = PromptOverride;
+  excludeOverrideId(items, excludeId) {
+    return items.filter((item) => excludeId ? item.id !== excludeId : true);
+  }
+  async getAppOverride(key, options = {}) {
+    const items = await this.list({ where: { key, tenantId: null } });
+    return this.excludeOverrideId(items, options.excludeId)[0] ?? null;
+  }
+  async getTenantOverride(key, tenantId, options = {}) {
+    const items = await this.list({ where: { key, tenantId } });
+    return this.excludeOverrideId(items, options.excludeId)[0] ?? null;
+  }
+  async getResolutionLayers(key, tenantId, options = {}) {
+    const [app, tenant] = await Promise.all([
+      this.getAppOverride(key, options),
+      tenantId != null ? this.getTenantOverride(key, tenantId, options) : Promise.resolve(null)
+    ]);
+    return {
+      app,
+      tenant
+    };
+  }
+}
+const PromptOverrideCollection$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  PromptOverrideCollection
+}, Symbol.toStringTag, { value: "Module" }));
+function getPromptConfig() {
+  return getPackageConfig("prompts", {
+    profiles: {},
+    prompts: {}
+  });
+}
+async function loadPromptBase(key, options) {
+  const definition = PromptRegistry.get(key);
+  if (!definition) {
+    throw new Error(`Unknown prompt key "${key}"`);
+  }
+  const tenantId = options.tenantId !== void 0 ? options.tenantId : getTenantId() ?? null;
+  let collection = null;
+  let cacheDb = options.db;
+  if (options.db) {
+    const initializedCollection = await PromptOverrideCollection.create({
+      db: options.db
+    });
+    collection = initializedCollection;
+    cacheDb = initializedCollection.db;
+  }
+  const cached = getCachedPromptBase(key, tenantId, cacheDb);
+  if (cached) {
+    return cached;
+  }
+  const config = getPromptConfig();
+  const layers = [
+    {
+      template: definition.template,
+      profile: definition.ai.profile ?? null,
+      model: definition.ai.model ?? null,
+      params: definition.ai.params
+    },
+    normalizePromptLayer(config.prompts?.[key])
+  ];
+  if (collection) {
+    const stored = await collection.getResolutionLayers(key, tenantId);
+    if (stored.app) {
+      layers.push(stored.app.toPromptLayer());
+    }
+    if (stored.tenant) {
+      layers.push(stored.tenant.toPromptLayer());
+    }
+  }
+  const merged = mergePromptLayers(...layers);
+  const value = {
+    key,
+    template: merged.template,
+    ai: merged.ai
+  };
+  setCachedPromptBase(key, tenantId, cacheDb, value);
+  return value;
+}
+async function resolvePrompt(key, options = {}) {
+  const config = getPromptConfig();
+  const base = await loadPromptBase(key, options);
+  const runtimeOverride = normalizePromptLayer(options.override);
+  const merged = mergePromptLayers(
+    {
+      template: base.template,
+      profile: base.ai.profile ?? null,
+      model: base.ai.model ?? null,
+      params: base.ai.params
+    },
+    runtimeOverride
+  );
+  return {
+    key,
+    template: merged.template,
+    text: renderPromptTemplate(merged.template, options.variables),
+    ai: buildResolvedAI(merged.ai, config)
+  };
+}
+const PACKAGE_VERSION_INITIALIZED = true;
+export {
+  PACKAGE_VERSION_INITIALIZED,
+  PromptOverride,
+  PromptOverrideCollection,
+  PromptRegistry,
+  clearPromptCache,
+  definePrompt,
+  getPromptCacheTtlMs,
+  resolvePrompt
+};
+//# sourceMappingURL=index.js.map