promptopskit 0.4.2 → 0.5.0

package/dist/providers/llmasaservice.cjs

@@ -0,0 +1,1467 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/providers/llmasaservice.ts
+var llmasaservice_exports = {};
+__export(llmasaservice_exports, {
+  LLMASASERVICE_BASE_URL: () => LLMASASERVICE_BASE_URL,
+  LLMASASERVICE_DEFAULT_MODEL: () => LLMASASERVICE_DEFAULT_MODEL,
+  LLMASASERVICE_RESPONSE_HEADER_NAMES: () => LLMASASERVICE_RESPONSE_HEADER_NAMES,
+  LLMASASERVICE_SDK_PLACEHOLDER_API_KEY: () => LLMASASERVICE_SDK_PLACEHOLDER_API_KEY,
+  createLLMAsAServiceOpenAIConfig: () => createLLMAsAServiceOpenAIConfig,
+  llmasaserviceAdapter: () => llmasaserviceAdapter
+});
+module.exports = __toCommonJS(llmasaservice_exports);
+
+// src/renderer/interpolate.ts
+var VARIABLE_RE = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g;
+var ESCAPED_OPEN = /\\\{\\\{/g;
+var ESCAPE_PLACEHOLDER = "\0ESCAPED_OPEN\0";
+function interpolate(template, variables, options = {}) {
+  const { strict = false } = options;
+  let result = template.replace(ESCAPED_OPEN, ESCAPE_PLACEHOLDER);
+  result = result.replace(VARIABLE_RE, (match, name) => {
+    if (name in variables) {
+      return variables[name];
+    }
+    if (strict) {
+      throw new Error(`Missing required variable: "${name}"`);
+    }
+    return match;
+  });
+  result = result.replaceAll(ESCAPE_PLACEHOLDER, "{{");
+  return result;
+}
+
+// src/renderer/renderer.ts
+function renderSections(asset, options = {}) {
+  const { variables = {}, strict = false } = options;
+  const result = {};
+  if (asset.sections.system_instructions) {
+    result.system_instructions = interpolate(
+      asset.sections.system_instructions,
+      variables,
+      { strict }
+    );
+  }
+  if (asset.sections.prompt_template) {
+    result.prompt_template = interpolate(
+      asset.sections.prompt_template,
+      variables,
+      { strict }
+    );
+  }
+  return result;
+}
+
+// src/overrides/apply-overrides.ts
+function applyOverrides(asset, options = {}) {
+  let result = { ...asset };
+  if (options.environment && result.environments?.[options.environment]) {
+    result = mergeOverride(result, result.environments[options.environment]);
+  }
+  if (options.tier && result.tiers?.[options.tier]) {
+    result = mergeOverride(result, result.tiers[options.tier]);
+  }
+  if (options.runtime) {
+    result = mergeOverride(result, options.runtime);
+  }
+  return result;
+}
+function mergeOverride(base, override) {
+  const result = { ...base };
+  if (override.model !== void 0) result.model = override.model;
+  if (override.fallback_models !== void 0) result.fallback_models = override.fallback_models;
+  if (override.tools !== void 0) result.tools = override.tools;
+  if (override.reasoning !== void 0) {
+    result.reasoning = { ...result.reasoning, ...override.reasoning };
+  }
+  if (override.sampling !== void 0) {
+    result.sampling = { ...result.sampling, ...override.sampling };
+  }
+  if (override.response !== void 0) {
+    result.response = { ...result.response, ...override.response };
+  }
+  if (override.cache !== void 0) {
+    result.cache = {
+      ...result.cache,
+      ...override.cache,
+      openai: mergeRecordBlock(result.cache?.openai, override.cache.openai),
+      anthropic: mergeRecordBlock(result.cache?.anthropic, override.cache.anthropic),
+      gemini: mergeRecordBlock(result.cache?.gemini, override.cache.gemini),
+      google: mergeRecordBlock(result.cache?.google, override.cache.google)
+    };
+  }
+  if (override.raw !== void 0) {
+    result.raw = {
+      ...result.raw,
+      ...override.raw,
+      openai: mergeRecordBlock(result.raw?.openai, override.raw.openai),
+      "openai-responses": mergeRecordBlock(result.raw?.["openai-responses"], override.raw["openai-responses"]),
+      openai_responses: mergeRecordBlock(result.raw?.openai_responses, override.raw.openai_responses),
+      anthropic: mergeRecordBlock(result.raw?.anthropic, override.raw.anthropic),
+      gemini: mergeRecordBlock(result.raw?.gemini, override.raw.gemini),
+      google: mergeRecordBlock(result.raw?.google, override.raw.google),
+      openrouter: mergeRecordBlock(result.raw?.openrouter, override.raw.openrouter),
+      llmasaservice: mergeRecordBlock(result.raw?.llmasaservice, override.raw.llmasaservice)
+    };
+  }
+  if (override.provider_options !== void 0) {
+    result.provider_options = {
+      ...result.provider_options,
+      ...override.provider_options,
+      anthropic: {
+        ...result.provider_options?.anthropic,
+        ...override.provider_options.anthropic
+      },
+      gemini: {
+        ...result.provider_options?.gemini,
+        ...override.provider_options.gemini
+      },
+      openrouter: {
+        ...result.provider_options?.openrouter,
+        ...override.provider_options.openrouter
+      },
+      llmasaservice: {
+        ...result.provider_options?.llmasaservice,
+        ...override.provider_options.llmasaservice
+      }
+    };
+  }
+  return result;
+}
+function mergeRecordBlock(base, override) {
+  if (override === void 0) return base;
+  return { ...base, ...override };
+}
+
+// src/providers/resolve-asset.ts
+function resolveAssetForProvider(asset, runtime = {}) {
+  if (!runtime.environment && !runtime.tier && !runtime.runtime) {
+    return asset;
+  }
+  return applyOverrides(asset, {
+    environment: runtime.environment,
+    tier: runtime.tier,
+    runtime: runtime.runtime
+  });
+}
+
+// src/prompt-resolution.ts
+var import_promises3 = require("fs/promises");
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+
+// src/cache.ts
+var import_node_fs = require("fs");
+var PromptCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize = 100) {
+    this.maxSize = maxSize;
+  }
+  get(filePath) {
+    const entry = this.cache.get(filePath);
+    if (!entry) return void 0;
+    try {
+      const stat = (0, import_node_fs.statSync)(filePath);
+      if (stat.mtimeMs !== entry.mtime) {
+        this.cache.delete(filePath);
+        return void 0;
+      }
+    } catch {
+      this.cache.delete(filePath);
+      return void 0;
+    }
+    this.cache.delete(filePath);
+    this.cache.set(filePath, entry);
+    return entry.value;
+  }
+  set(filePath, value) {
+    try {
+      const stat = (0, import_node_fs.statSync)(filePath);
+      if (this.cache.has(filePath)) {
+        this.cache.delete(filePath);
+      } else if (this.cache.size >= this.maxSize) {
+        const oldest = this.cache.keys().next().value;
+        if (oldest) this.cache.delete(oldest);
+      }
+      this.cache.set(filePath, { value, mtime: stat.mtimeMs });
+    } catch {
+    }
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+
+// src/composition/resolve-includes.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+
+// src/parser/parser.ts
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+
+// src/schema/schema.ts
+var import_zod = require("zod");
+var InlineToolDefSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  input_schema: import_zod.z.record(import_zod.z.unknown()).optional()
+});
+var ToolRefSchema = import_zod.z.union([import_zod.z.string(), InlineToolDefSchema]);
+var MCPServerRefSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.object({
+    name: import_zod.z.string(),
+    config: import_zod.z.record(import_zod.z.unknown()).optional()
+  })
+]);
+var ReasoningSchema = import_zod.z.object({
+  effort: import_zod.z.enum(["low", "medium", "high"]).optional(),
+  budget_tokens: import_zod.z.number().int().positive().optional()
+});
+var SamplingSchema = import_zod.z.object({
+  temperature: import_zod.z.number().min(0).max(2).optional(),
+  top_p: import_zod.z.number().min(0).max(1).optional(),
+  frequency_penalty: import_zod.z.number().optional(),
+  presence_penalty: import_zod.z.number().optional(),
+  stop: import_zod.z.array(import_zod.z.string()).optional(),
+  max_output_tokens: import_zod.z.number().int().positive().optional()
+});
+var ResponseSchema = import_zod.z.object({
+  format: import_zod.z.enum(["text", "json", "markdown"]).optional(),
+  stream: import_zod.z.boolean().optional(),
+  schema: import_zod.z.record(import_zod.z.unknown()).optional(),
+  schema_name: import_zod.z.string().optional(),
+  schema_description: import_zod.z.string().optional(),
+  schema_strict: import_zod.z.boolean().optional()
+});
+var AnthropicProviderOptionsSchema = import_zod.z.object({
+  top_k: import_zod.z.number().int().min(0).optional(),
+  tool_choice: import_zod.z.record(import_zod.z.unknown()).optional(),
+  output_config: import_zod.z.record(import_zod.z.unknown()).optional()
+});
+var GeminiProviderOptionsSchema = import_zod.z.object({
+  candidate_count: import_zod.z.number().int().positive().optional(),
+  top_k: import_zod.z.number().int().min(0).optional(),
+  seed: import_zod.z.number().int().optional(),
+  response_schema: import_zod.z.record(import_zod.z.unknown()).optional(),
+  response_json_schema: import_zod.z.record(import_zod.z.unknown()).optional(),
+  response_modalities: import_zod.z.array(import_zod.z.string()).optional(),
+  thinking_budget_tokens: import_zod.z.number().int().positive().optional()
+});
+var OpenRouterProviderOptionsSchema = import_zod.z.object({
+  provider: import_zod.z.record(import_zod.z.unknown()).optional(),
+  transforms: import_zod.z.array(import_zod.z.string()).optional(),
+  plugins: import_zod.z.array(import_zod.z.record(import_zod.z.unknown())).optional(),
+  models: import_zod.z.array(import_zod.z.string()).optional()
+});
+var LLMAsAServiceCustomerSchema = import_zod.z.object({
+  customer_id: import_zod.z.string(),
+  customer_name: import_zod.z.string().optional(),
+  customer_user_id: import_zod.z.string().optional(),
+  customer_user_name: import_zod.z.string().optional(),
+  customer_user_email: import_zod.z.string().optional()
+});
+var LLMAsAServiceProviderOptionsSchema = import_zod.z.object({
+  base_url: import_zod.z.string().url().optional(),
+  project_id: import_zod.z.string().optional(),
+  customer: LLMAsAServiceCustomerSchema.optional(),
+  conversationId: import_zod.z.string().optional(),
+  conversationTitle: import_zod.z.string().optional(),
+  projectId: import_zod.z.string().optional()
+});
+var ProviderOptionsSchema = import_zod.z.object({
+  anthropic: AnthropicProviderOptionsSchema.optional(),
+  gemini: GeminiProviderOptionsSchema.optional(),
+  openrouter: OpenRouterProviderOptionsSchema.optional(),
+  llmasaservice: LLMAsAServiceProviderOptionsSchema.optional()
+});
+var RawProviderBodySchema = import_zod.z.object({
+  openai: import_zod.z.record(import_zod.z.unknown()).optional(),
+  "openai-responses": import_zod.z.record(import_zod.z.unknown()).optional(),
+  openai_responses: import_zod.z.record(import_zod.z.unknown()).optional(),
+  anthropic: import_zod.z.record(import_zod.z.unknown()).optional(),
+  gemini: import_zod.z.record(import_zod.z.unknown()).optional(),
+  google: import_zod.z.record(import_zod.z.unknown()).optional(),
+  openrouter: import_zod.z.record(import_zod.z.unknown()).optional(),
+  llmasaservice: import_zod.z.record(import_zod.z.unknown()).optional()
+});
+var OpenAICacheSchema = import_zod.z.object({
+  prompt_cache_key: import_zod.z.string().min(1).optional(),
+  retention: import_zod.z.enum(["in_memory", "24h"]).optional()
+});
+var AnthropicCacheSchema = import_zod.z.object({
+  mode: import_zod.z.enum(["automatic", "explicit"]).optional(),
+  type: import_zod.z.literal("ephemeral").optional(),
+  ttl: import_zod.z.enum(["5m", "1h"]).optional(),
+  cache_system_instructions: import_zod.z.boolean().optional(),
+  cache_tools: import_zod.z.boolean().optional(),
+  cache_prompt_template: import_zod.z.boolean().optional()
+});
+var GeminiCacheSchema = import_zod.z.object({
+  cached_content: import_zod.z.string().min(1).optional()
+});
+var CacheSchema = import_zod.z.object({
+  openai: OpenAICacheSchema.optional(),
+  anthropic: AnthropicCacheSchema.optional(),
+  gemini: GeminiCacheSchema.optional(),
+  google: GeminiCacheSchema.optional()
+});
+var HistorySchema = import_zod.z.object({
+  max_items: import_zod.z.number().int().positive().optional()
+});
+var ContextRegexSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.object({
+    pattern: import_zod.z.string(),
+    flags: import_zod.z.string().optional(),
+    return_message: import_zod.z.string().optional()
+  })
+]);
+var ContextBuiltInValidatorSchema = import_zod.z.union([
+  import_zod.z.boolean(),
+  import_zod.z.object({
+    return_message: import_zod.z.string().optional()
+  })
+]);
+var ContextInputDefinitionObjectSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  max_size: import_zod.z.number().int().positive().optional(),
+  trim: import_zod.z.union([import_zod.z.boolean(), import_zod.z.enum(["start", "end", "both"])]).optional(),
+  allow_regex: ContextRegexSchema.optional(),
+  deny_regex: ContextRegexSchema.optional(),
+  non_empty: ContextBuiltInValidatorSchema.optional(),
+  reject_secrets: ContextBuiltInValidatorSchema.optional()
+});
+var ContextInputDefinitionSchema = import_zod.z.union([
+  import_zod.z.string(),
+  ContextInputDefinitionObjectSchema
+]);
+var ContextSchema = import_zod.z.object({
+  inputs: import_zod.z.array(ContextInputDefinitionSchema).optional(),
+  history: HistorySchema.optional()
+});
+var MetadataSchema = import_zod.z.object({
+  owner: import_zod.z.string().optional(),
+  tags: import_zod.z.array(import_zod.z.string()).optional(),
+  review_required: import_zod.z.boolean().optional(),
+  stable: import_zod.z.boolean().optional()
+});
+var MCPSchema = import_zod.z.object({
+  servers: import_zod.z.array(MCPServerRefSchema).optional()
+});
+var PromptAssetOverridesSchema = import_zod.z.object({
+  model: import_zod.z.string().optional(),
+  fallback_models: import_zod.z.array(import_zod.z.string()).optional(),
+  reasoning: ReasoningSchema.optional(),
+  sampling: SamplingSchema.optional(),
+  response: ResponseSchema.optional(),
+  cache: CacheSchema.optional(),
+  raw: RawProviderBodySchema.optional(),
+  tools: import_zod.z.array(ToolRefSchema).optional(),
+  provider_options: ProviderOptionsSchema.optional()
+});
+var SourceSchema = import_zod.z.object({
+  file_path: import_zod.z.string().optional(),
+  checksum: import_zod.z.string().optional()
+});
+var SectionsSchema = import_zod.z.object({
+  system_instructions: import_zod.z.string().optional(),
+  prompt_template: import_zod.z.string().optional(),
+  notes: import_zod.z.string().optional()
+});
+var PromptDefaultsSchema = import_zod.z.object({
+  provider: import_zod.z.enum(["openai", "openai-responses", "anthropic", "google", "gemini", "openrouter", "llmasaservice", "any"]).optional(),
+  model: import_zod.z.string().optional(),
+  cache: CacheSchema.optional(),
+  metadata: MetadataSchema.optional(),
+  sections: import_zod.z.object({
+    system_instructions: import_zod.z.string().optional()
+  }).optional()
+});
+var PromptAssetSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  schema_version: import_zod.z.number().int().positive().default(1),
+  description: import_zod.z.string().optional(),
+  provider: import_zod.z.enum(["openai", "openai-responses", "anthropic", "google", "gemini", "openrouter", "llmasaservice", "any"]).optional(),
+  model: import_zod.z.string().optional(),
+  fallback_models: import_zod.z.array(import_zod.z.string()).optional(),
+  reasoning: ReasoningSchema.optional(),
+  sampling: SamplingSchema.optional(),
+  response: ResponseSchema.optional(),
+  cache: CacheSchema.optional(),
+  raw: RawProviderBodySchema.optional(),
+  tools: import_zod.z.array(ToolRefSchema).optional(),
+  provider_options: ProviderOptionsSchema.optional(),
+  mcp: MCPSchema.optional(),
+  context: ContextSchema.optional(),
+  includes: import_zod.z.array(import_zod.z.string()).optional(),
+  environments: import_zod.z.record(PromptAssetOverridesSchema).optional(),
+  tiers: import_zod.z.record(PromptAssetOverridesSchema).optional(),
+  metadata: MetadataSchema.optional(),
+  // Populated by parser, not authored in YAML
+  sections: SectionsSchema.optional(),
+  source: SourceSchema.optional()
+});
+
+// src/parser/frontmatter-guard.ts
+var FRONT_MATTER_DELIMITER = /^---[ \t]*$/;
+var REGEX_FIELD = /^(?<indent>\s*)(?<field>allow_regex|deny_regex)\s*:\s*(?<value>.*)$/;
+var PATTERN_FIELD = /^(?<indent>\s*)pattern\s*:\s*(?<value>.*)$/;
+var INLINE_PATTERN_FIELD = /(?:^|[{,]\s*)pattern\s*:\s*(?<value>"(?:\\.|[^"\\])*")/;
+function assertRegexFrontMatterQuoting(content, filePath) {
+  const frontMatter = extractFrontMatter(content);
+  if (!frontMatter) {
+    return;
+  }
+  let pendingRegex;
+  for (const [index, line] of frontMatter.lines.entries()) {
+    const lineNumber = frontMatter.startLine + index;
+    const regexMatch = line.match(REGEX_FIELD);
+    if (regexMatch?.groups) {
+      const field = regexMatch.groups.field;
+      const indent2 = regexMatch.groups.indent.length;
+      const value = regexMatch.groups.value.trim();
+      pendingRegex = value === "" ? { field, indent: indent2 } : void 0;
+      assertNoUnescapedBackslashInDoubleQuotedRegex(value, field, filePath, lineNumber);
+      assertNoUnescapedBackslashInInlinePattern(value, field, filePath, lineNumber);
+      continue;
+    }
+    if (!pendingRegex) {
+      continue;
+    }
+    if (line.trim() === "" || line.trimStart().startsWith("#")) {
+      continue;
+    }
+    const indent = line.match(/^\s*/)?.[0].length ?? 0;
+    if (indent <= pendingRegex.indent) {
+      pendingRegex = void 0;
+      continue;
+    }
+    const patternMatch = line.match(PATTERN_FIELD);
+    if (!patternMatch?.groups) {
+      continue;
+    }
+    assertNoUnescapedBackslashInDoubleQuotedRegex(
+      patternMatch.groups.value.trim(),
+      `${pendingRegex.field}.pattern`,
+      filePath,
+      lineNumber
+    );
+  }
+}
+function assertNoUnescapedBackslashInInlinePattern(value, field, filePath, lineNumber) {
+  const match = value.match(INLINE_PATTERN_FIELD);
+  const pattern = match?.groups?.value;
+  if (!pattern) {
+    return;
+  }
+  assertNoUnescapedBackslashInDoubleQuotedRegex(pattern, `${field}.pattern`, filePath, lineNumber);
+}
+function extractFrontMatter(content) {
+  const lines = content.split(/\r?\n/);
+  if (!FRONT_MATTER_DELIMITER.test(lines[0] ?? "")) {
+    return void 0;
+  }
+  for (let index = 1; index < lines.length; index += 1) {
+    if (FRONT_MATTER_DELIMITER.test(lines[index] ?? "")) {
+      return {
+        lines: lines.slice(1, index),
+        startLine: 2
+      };
+    }
+  }
+  return void 0;
+}
+function assertNoUnescapedBackslashInDoubleQuotedRegex(value, field, filePath, lineNumber) {
+  if (!value.startsWith('"')) {
+    return;
+  }
+  const quoted = readDoubleQuotedScalar(value);
+  if (!quoted) {
+    return;
+  }
+  if (!hasUnescapedBackslash(quoted)) {
+    return;
+  }
+  const location = filePath ? `${filePath}:${lineNumber}` : `line ${lineNumber}`;
+  throw new Error(
+    `POK013: Invalid context regex YAML at ${location}, field "${field}": double-quoted regex strings treat backslashes as YAML escapes. Use unquoted /pattern/i literal form, single quotes, or double each backslash.`
+  );
+}
+function readDoubleQuotedScalar(value) {
+  let result = "";
+  for (let index = 1; index < value.length; index += 1) {
+    const char = value[index];
+    if (char === '"') {
+      return result;
+    }
+    result += char;
+    if (char === "\\" && index + 1 < value.length) {
+      index += 1;
+      result += value[index];
+    }
+  }
+  return void 0;
+}
+function hasUnescapedBackslash(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] !== "\\") {
+      continue;
+    }
+    let count = 1;
+    while (value[index + count] === "\\") {
+      count += 1;
+    }
+    if (count % 2 === 1) {
+      return true;
+    }
+    index += count - 1;
+  }
+  return false;
+}
+
+// src/parser/sections.ts
+var SECTION_MAP = {
+  "system instructions": "system_instructions",
+  "prompt template": "prompt_template",
+  "notes": "notes"
+};
+function extractSections(body) {
+  const lines = body.split(/\r?\n/);
+  const sections = {};
+  let currentKey = null;
+  let currentLines = [];
+  let foundAnyH1 = false;
+  for (const line of lines) {
+    const h1Match = line.match(/^#\s+(.+)$/);
+    if (h1Match) {
+      if (currentKey) {
+        sections[currentKey] = currentLines.join("\n").trim();
+      }
+      foundAnyH1 = true;
+      const heading = h1Match[1].trim().toLowerCase();
+      currentKey = SECTION_MAP[heading] ?? null;
+      currentLines = [];
+    } else {
+      currentLines.push(line);
+    }
+  }
+  if (currentKey) {
+    sections[currentKey] = currentLines.join("\n").trim();
+  }
+  if (!foundAnyH1) {
+    const trimmed = body.trim();
+    if (trimmed) {
+      sections.prompt_template = trimmed;
+    }
+  }
+  return sections;
+}
+
+// src/parser/parser.ts
+function parsePrompt(content, filePath) {
+  assertRegexFrontMatterQuoting(content, filePath);
+  const { data: frontMatter, content: body } = (0, import_gray_matter.default)(content);
+  const sections = extractSections(body);
+  const raw = {
+    ...frontMatter,
+    sections,
+    source: filePath ? { file_path: filePath } : void 0
+  };
+  const asset = PromptAssetSchema.parse(raw);
+  return {
+    asset,
+    raw: {
+      frontMatter,
+      body
+    }
+  };
+}
+
+// src/parser/loader.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_gray_matter2 = __toESM(require("gray-matter"), 1);
+var DEFAULTS_FILE_NAME = "defaults.md";
+async function loadPromptFile(filePath, options = {}) {
+  const content = await (0, import_promises.readFile)(filePath, "utf-8");
+  const parsed = parsePrompt(content, filePath);
+  const root = options.defaultsRoot ?? (0, import_node_path.dirname)(filePath);
+  const defaults = await loadDefaultsForPath(filePath, root);
+  const asset = applyDefaults(parsed.asset, defaults);
+  return {
+    ...parsed,
+    asset
+  };
+}
+async function loadDefaultsForPath(filePath, defaultsRoot) {
+  const directories = getDirectoriesToCheck(filePath, defaultsRoot);
+  let merged = {};
+  for (const dir of directories) {
+    const defaultsPath = (0, import_node_path.join)(dir, DEFAULTS_FILE_NAME);
+    try {
+      const defaultsContent = await (0, import_promises.readFile)(defaultsPath, "utf-8");
+      const defaults = parseDefaults(defaultsContent);
+      merged = mergeDefaults(merged, defaults);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  return merged;
+}
+function getDirectoriesToCheck(filePath, defaultsRoot) {
+  const dirs = [];
+  let current = (0, import_node_path.resolve)((0, import_node_path.dirname)(filePath));
+  const boundary = defaultsRoot ? (0, import_node_path.resolve)(defaultsRoot) : void 0;
+  while (true) {
+    dirs.unshift(current);
+    if (boundary && current === boundary || current === (0, import_node_path.dirname)(current)) {
+      break;
+    }
+    current = (0, import_node_path.dirname)(current);
+  }
+  return dirs;
+}
+function parseDefaults(content) {
+  const { data: frontMatter, content: body } = (0, import_gray_matter2.default)(content);
+  const sections = extractSections(body);
+  return PromptDefaultsSchema.parse({
+    ...frontMatter,
+    sections: {
+      system_instructions: sections.system_instructions
+    }
+  });
+}
+function mergeDefaults(base, local) {
+  return {
+    provider: local.provider ?? base.provider,
+    model: local.model ?? base.model,
+    cache: mergeCache(base.cache, local.cache),
+    metadata: {
+      ...base.metadata ?? {},
+      ...local.metadata ?? {}
+    },
+    sections: {
+      ...base.sections ?? {},
+      ...local.sections ?? {}
+    }
+  };
+}
+function applyDefaults(asset, defaults) {
+  const cache = mergeCache(defaults.cache, asset.cache);
+  const hasDefaultMetadata = defaults.metadata && Object.keys(defaults.metadata).length > 0;
+  const hasDefaultSystem = !!defaults.sections?.system_instructions;
+  const hasDefaultScalars = defaults.provider !== void 0 || defaults.model !== void 0;
+  const hasDefaultCache = cache !== void 0;
+  if (!hasDefaultMetadata && !hasDefaultSystem && !hasDefaultScalars && !hasDefaultCache) {
+    return asset;
+  }
+  const mergedMetadata = {
+    ...defaults.metadata ?? {},
+    ...asset.metadata ?? {}
+  };
+  const metadata = Object.keys(mergedMetadata).length > 0 ? mergedMetadata : void 0;
+  const systemInstructions = asset.sections?.system_instructions ?? defaults.sections?.system_instructions;
+  const sections = asset.sections ? { ...asset.sections, system_instructions: systemInstructions } : systemInstructions ? { system_instructions: systemInstructions } : void 0;
+  return {
+    ...asset,
+    provider: asset.provider ?? defaults.provider,
+    model: asset.model ?? defaults.model,
+    cache,
+    metadata,
+    sections
+  };
+}
+function mergeCache(base, local) {
+  const merged = {
+    ...base ?? {},
+    ...local ?? {},
+    openai: {
+      ...base?.openai ?? {},
+      ...local?.openai ?? {}
+    },
+    anthropic: {
+      ...base?.anthropic ?? {},
+      ...local?.anthropic ?? {}
+    },
+    gemini: {
+      ...base?.gemini ?? {},
+      ...local?.gemini ?? {}
+    },
+    google: {
+      ...base?.google ?? {},
+      ...local?.google ?? {}
+    }
+  };
+  if (merged.openai && Object.keys(merged.openai).length === 0) delete merged.openai;
+  if (merged.anthropic && Object.keys(merged.anthropic).length === 0) delete merged.anthropic;
+  if (merged.gemini && Object.keys(merged.gemini).length === 0) delete merged.gemini;
+  if (merged.google && Object.keys(merged.google).length === 0) delete merged.google;
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+
+// src/composition/resolve-includes.ts
+async function resolveIncludes(asset, basePath, visited = /* @__PURE__ */ new Set()) {
+  if (!asset.includes || asset.includes.length === 0) {
+    return asset;
+  }
+  const baseDir = (0, import_node_path2.dirname)(basePath);
+  const resolvedPath = (0, import_node_path2.resolve)(basePath);
+  if (visited.has(resolvedPath)) {
+    throw new Error(`Circular include detected: ${resolvedPath}`);
+  }
+  visited.add(resolvedPath);
+  let mergedSystemInstructions = "";
+  for (const includePath of asset.includes) {
+    const fullPath = (0, import_node_path2.resolve)(baseDir, includePath);
+    if (visited.has(fullPath)) {
+      throw new Error(`Circular include detected: ${fullPath} (included from ${basePath})`);
+    }
+    const content = await (0, import_promises2.readFile)(fullPath, "utf-8");
+    const { asset: includedAsset } = parsePrompt(content, fullPath);
+    const resolved = await resolveIncludes(includedAsset, fullPath, new Set(visited));
+    if (resolved.sections?.system_instructions) {
+      mergedSystemInstructions += resolved.sections.system_instructions + "\n\n";
+    }
+  }
+  const localSystem = asset.sections?.system_instructions ?? "";
+  const combinedSystem = (mergedSystemInstructions + localSystem).trim() || void 0;
+  return {
+    ...asset,
+    sections: {
+      ...asset.sections,
+      system_instructions: combinedSystem
+    },
+    // Drop includes from the resolved asset — they've been inlined
+    includes: void 0
+  };
+}
+
+// src/prompt-resolution.ts
+var DEFAULT_PROMPTS_DIR = "./prompts";
+var DEFAULT_COMPILED_JSON_DIR = "./.generated-prompts/json";
+function withPromptResolutionDefaults(config) {
+  return {
+    ...config,
+    sourceDir: config.sourceDir ?? DEFAULT_PROMPTS_DIR,
+    compiledDir: config.compiledDir ?? DEFAULT_COMPILED_JSON_DIR
+  };
+}
+var sharedPromptCache = new PromptCache();
+async function loadPromptAsset(promptPath, config, promptCache = sharedPromptCache) {
+  const resolvedConfig = withPromptResolutionDefaults(config);
+  const mode = resolvedConfig.mode ?? "auto";
+  if (mode !== "source-only" && resolvedConfig.compiledDir) {
+    const compiledFile = (0, import_node_path3.resolve)(resolvedConfig.compiledDir, promptPath + ".json");
+    if ((0, import_node_fs2.existsSync)(compiledFile)) {
+      if (mode === "auto") {
+        const sourceFile = (0, import_node_path3.resolve)(resolvedConfig.sourceDir, promptPath + ".md");
+        if ((0, import_node_fs2.existsSync)(sourceFile)) {
+          const compiledMtime = (0, import_node_fs2.statSync)(compiledFile).mtimeMs;
+          const sourceMtime = (0, import_node_fs2.statSync)(sourceFile).mtimeMs;
+          if (sourceMtime > compiledMtime) {
+            console.warn(
+              `[promptopskit] Warning: compiled artifact for "${promptPath}" is older than source .md file.
+               Run "promptopskit compile" or switch to source-only mode.`
+            );
+          }
+        }
+      }
+      const content = await (0, import_promises3.readFile)(compiledFile, "utf-8");
+      return JSON.parse(content);
+    }
+    if (mode === "compiled-only") {
+      throw new Error(
+        `Compiled artifact not found: ${compiledFile}
+Run "promptopskit compile" to generate it.`
+      );
+    }
+  }
+  if (mode !== "compiled-only") {
+    const sourceFile = (0, import_node_path3.resolve)(resolvedConfig.sourceDir, promptPath + ".md");
+    if (resolvedConfig.cache !== false) {
+      const cached = promptCache.get(sourceFile);
+      if (cached) {
+        return cached;
+      }
+    }
+    if (!(0, import_node_fs2.existsSync)(sourceFile)) {
+      const paths = [sourceFile];
+      if (resolvedConfig.compiledDir) {
+        paths.unshift((0, import_node_path3.resolve)(resolvedConfig.compiledDir, promptPath + ".json"));
+      }
+      throw new Error(
+        `Prompt not found: "${promptPath}"
+Searched:
+${paths.map((candidate) => `  - ${candidate}`).join("\n")}`
+      );
+    }
+    const { asset } = await loadPromptFile(sourceFile, { defaultsRoot: resolvedConfig.sourceDir });
+    if (resolvedConfig.cache !== false) {
+      promptCache.set(sourceFile, asset);
+    }
+    return asset;
+  }
+  throw new Error(`Prompt not found: "${promptPath}"`);
+}
+async function resolvePromptAsset(promptPath, config, options = {}, promptCache = sharedPromptCache) {
+  const resolvedConfig = withPromptResolutionDefaults(config);
+  let asset = await loadPromptAsset(promptPath, resolvedConfig, promptCache);
+  const sourceFile = (0, import_node_path3.resolve)(resolvedConfig.sourceDir, promptPath + ".md");
+  if (asset.includes && asset.includes.length > 0 && (0, import_node_fs2.existsSync)(sourceFile)) {
+    asset = await resolveIncludes(asset, sourceFile);
+  }
+  asset = applyOverrides(asset, {
+    environment: options.environment,
+    tier: options.tier,
+    runtime: options.runtime
+  });
+  return asset;
+}
+function resolveInlinePromptSource(source, options = {}) {
+  const { asset } = parsePrompt(source);
+  return applyOverrides(asset, {
+    environment: options.environment,
+    tier: options.tier,
+    runtime: options.runtime
+  });
+}
+
+// src/context.ts
+var textEncoder = new TextEncoder();
+var REJECT_SECRETS_PATTERN = "(secret|api[_-]?key|password)";
+var REJECT_SECRETS_FLAGS = "i";
+function getContextInputs(asset) {
+  return (asset.context?.inputs ?? []).map(normalizeContextInput);
+}
+function normalizeContextInput(input) {
+  if (typeof input === "string") {
+    return { name: input };
+  }
+  return {
+    name: input.name,
+    max_size: input.max_size,
+    trim: input.trim,
+    allow_regex: normalizeContextRegex(input.allow_regex),
+    deny_regex: normalizeContextRegex(input.deny_regex),
+    non_empty: normalizeBuiltInValidator(input.non_empty),
+    reject_secrets: normalizeBuiltInValidator(input.reject_secrets)
+  };
+}
+function normalizeContextRegex(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const literal = parseRegexLiteral(value);
+    if (value.startsWith("/") && !literal) {
+      return {
+        pattern: value,
+        flags: "",
+        raw: value,
+        invalidLiteral: true
+      };
+    }
+    return {
+      pattern: literal?.pattern ?? value,
+      flags: literal?.flags ?? "",
+      raw: value
+    };
+  }
+  return {
+    pattern: value.pattern,
+    flags: value.flags ?? "",
+    raw: JSON.stringify(value),
+    returnMessage: value.return_message
+  };
+}
+function normalizeBuiltInValidator(value) {
+  if (value === void 0 || value === false) {
+    return void 0;
+  }
+  if (value === true) {
+    return {};
+  }
+  return {
+    returnMessage: value.return_message
+  };
+}
+function parseRegexLiteral(value) {
+  if (!value.startsWith("/")) {
+    return void 0;
+  }
+  for (let index = value.length - 1; index > 0; index -= 1) {
+    if (value[index] !== "/") {
+      continue;
+    }
+    let backslashCount = 0;
+    for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor -= 1) {
+      backslashCount += 1;
+    }
+    if (backslashCount % 2 === 1) {
+      continue;
+    }
+    return {
+      pattern: value.slice(1, index),
+      flags: value.slice(index + 1)
+    };
+  }
+  return void 0;
+}
+function formatInvalidContextRegexMessage(details) {
+  return [
+    `Invalid context regex for prompt "${details.promptId}"`,
+    `variable "${details.variable}"`,
+    `field "${details.field}"`,
+    `value ${JSON.stringify(details.raw)}: ${details.reason}`
+  ].join(", ");
+}
+function compileContextRegex(regex, details) {
+  if (regex.invalidLiteral) {
+    throw new Error(
+      `POK013: ${formatInvalidContextRegexMessage({
+        ...details,
+        raw: regex.raw,
+        reason: "Malformed regex literal. Use /pattern/flags or { pattern, flags }."
+      })}`
+    );
+  }
+  try {
+    return new RegExp(regex.pattern, regex.flags);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`POK013: ${formatInvalidContextRegexMessage({ ...details, raw: regex.raw, reason })}`);
+  }
+}
+function getRejectSecretsRegex() {
+  return {
+    pattern: REJECT_SECRETS_PATTERN,
+    flags: REJECT_SECRETS_FLAGS,
+    raw: JSON.stringify({ pattern: REJECT_SECRETS_PATTERN, flags: REJECT_SECRETS_FLAGS })
+  };
+}
+function isTrimEnabled(mode) {
+  return mode === true || mode === "start" || mode === "end" || mode === "both";
+}
+function normalizeTrimMode(mode) {
+  if (mode === "start") {
+    return "start";
+  }
+  return "end";
+}
+function trimToMaxSize(value, maxSize, mode) {
+  const measured = measureContextValueSize(value);
+  if (measured <= maxSize) {
+    return value;
+  }
+  const characters = Array.from(value);
+  const normalizedMode = normalizeTrimMode(mode);
+  if (normalizedMode === "start") {
+    let collected2 = "";
+    let size2 = 0;
+    for (let i = characters.length - 1; i >= 0; i -= 1) {
+      const next = characters[i];
+      const charSize = measureContextValueSize(next);
+      if (size2 + charSize > maxSize) {
+        break;
+      }
+      collected2 = next + collected2;
+      size2 += charSize;
+    }
+    return collected2;
+  }
+  let collected = "";
+  let size = 0;
+  for (const char of characters) {
+    const charSize = measureContextValueSize(char);
+    if (size + charSize > maxSize) {
+      break;
+    }
+    collected += char;
+    size += charSize;
+  }
+  return collected;
+}
+function sanitizeContextVariables(asset, variables = {}, options = {}) {
+  const { onContextOverflow } = options;
+  const sanitized = { ...variables };
+  for (const input of getContextInputs(asset)) {
+    const value = sanitized[input.name];
+    if (value === void 0) {
+      continue;
+    }
+    let candidate = value;
+    if (input.max_size !== void 0) {
+      const actualSize = measureContextValueSize(candidate);
+      if (actualSize > input.max_size && onContextOverflow) {
+        candidate = onContextOverflow({
+          promptId: asset.id,
+          variable: input.name,
+          value: candidate,
+          maxSize: input.max_size,
+          actualSize
+        });
+      }
+    }
+    if (isTrimEnabled(input.trim) && input.max_size !== void 0) {
+      candidate = trimToMaxSize(candidate, input.max_size, input.trim);
+    }
+    sanitized[input.name] = candidate;
+    if (input.allow_regex) {
+      const candidate2 = sanitized[input.name];
+      const matcher = compileContextRegex(input.allow_regex, {
+        promptId: asset.id,
+        variable: input.name,
+        field: "allow_regex"
+      });
+      if (!matcher.test(candidate2)) {
+        if (input.allow_regex.returnMessage) {
+          return {
+            variables: sanitized,
+            shortCircuit: {
+              returnMessage: input.allow_regex.returnMessage,
+              code: "POK031",
+              variable: input.name,
+              field: "allow_regex"
+            }
+          };
+        }
+        throw new Error(
+          `POK031: Context variable "${input.name}" failed allow_regex validation for prompt "${asset.id}".`
+        );
+      }
+    }
+    if (input.deny_regex) {
+      const candidate2 = sanitized[input.name];
+      const matcher = compileContextRegex(input.deny_regex, {
+        promptId: asset.id,
+        variable: input.name,
+        field: "deny_regex"
+      });
+      if (matcher.test(candidate2)) {
+        if (input.deny_regex.returnMessage) {
+          return {
+            variables: sanitized,
+            shortCircuit: {
+              returnMessage: input.deny_regex.returnMessage,
+              code: "POK032",
+              variable: input.name,
+              field: "deny_regex"
+            }
+          };
+        }
+        throw new Error(
+          `POK032: Context variable "${input.name}" matched deny_regex for prompt "${asset.id}".`
+        );
+      }
+    }
+    if (input.non_empty && candidate.trim().length === 0) {
+      if (input.non_empty.returnMessage) {
+        return {
+          variables: sanitized,
+          shortCircuit: {
+            returnMessage: input.non_empty.returnMessage,
+            code: "POK033",
+            variable: input.name,
+            field: "non_empty"
+          }
+        };
+      }
+      throw new Error(
+        `POK033: Context variable "${input.name}" failed non_empty validation for prompt "${asset.id}".`
+      );
+    }
+    if (input.reject_secrets) {
+      const matcher = compileContextRegex(getRejectSecretsRegex(), {
+        promptId: asset.id,
+        variable: input.name,
+        field: "reject_secrets"
+      });
+      if (matcher.test(candidate)) {
+        if (input.reject_secrets.returnMessage) {
+          return {
+            variables: sanitized,
+            shortCircuit: {
+              returnMessage: input.reject_secrets.returnMessage,
+              code: "POK034",
+              variable: input.name,
+              field: "reject_secrets"
+            }
+          };
+        }
+        throw new Error(
+          `POK034: Context variable "${input.name}" matched reject_secrets validation for prompt "${asset.id}".`
+        );
+      }
+    }
+  }
+  return { variables: sanitized };
+}
+function measureContextValueSize(value) {
+  return textEncoder.encode(value).length;
+}
+
+// src/history.ts
+function defaultCompactHistory(info) {
+  const content = info.overflow.map((message) => `${message.role}: ${message.content}`).join("\n\n");
+  return {
+    role: "user",
+    content: `Earlier conversation compacted to preserve history:
+
+${content}`
+  };
+}
+function normalizeCompactionResult(result) {
+  if (typeof result === "string") {
+    return {
+      role: "user",
+      content: result
+    };
+  }
+  return result;
+}
+function compactHistoryForPrompt(asset, runtime) {
+  const history = runtime.history;
+  const maxItems = asset.context?.history?.max_items;
+  if (!history || maxItems === void 0 || history.length <= maxItems) {
+    return history;
+  }
+  if (maxItems === 1) {
+    const info2 = {
+      promptId: asset.id,
+      maxItems,
+      overflow: history,
+      preserved: [],
+      history
+    };
+    const compacted2 = runtime.onHistoryCompaction ? normalizeCompactionResult(runtime.onHistoryCompaction(info2)) : defaultCompactHistory(info2);
+    return [compacted2];
+  }
+  const preservedCount = maxItems - 1;
+  const overflow = history.slice(0, history.length - preservedCount);
+  const preserved = history.slice(-preservedCount);
+  const info = {
+    promptId: asset.id,
+    maxItems,
+    overflow,
+    preserved,
+    history
+  };
+  const compacted = runtime.onHistoryCompaction ? normalizeCompactionResult(runtime.onHistoryCompaction(info)) : defaultCompactHistory(info);
+  return [compacted, ...preserved];
+}
+
+// src/providers/prompt-input.ts
+function isPromptLookup(input) {
+  return "path" in input && typeof input.path === "string";
+}
+function isInlinePromptSource(input) {
+  return "source" in input && typeof input.source === "string";
+}
+async function resolveProviderPromptInput(input, runtime) {
+  if (isPromptLookup(input)) {
+    return resolvePromptAsset(input.path, input, runtime);
+  }
+  if (isInlinePromptSource(input)) {
+    return resolveInlinePromptSource(input.source, runtime);
+  }
+  return input;
+}
+function withPromptInputSupport(adapter) {
+  const validatePrompt = async (input, runtime) => {
+    const resolved = await resolveProviderPromptInput(input, runtime);
+    return adapter.validate(resolved, runtime);
+  };
+  const renderPrompt = async (input, runtime) => {
+    const resolved = await resolveProviderPromptInput(input, runtime);
+    const sanitization = sanitizeContextVariables(resolved, runtime.variables, {
+      onContextOverflow: runtime.onContextOverflow
+    });
+    if (sanitization.shortCircuit) {
+      return {
+        provider: adapter.name,
+        model: resolved.model ?? "",
+        returnMessage: sanitization.shortCircuit.returnMessage
+      };
+    }
+    return adapter.render(resolved, {
+      ...runtime,
+      variables: sanitization.variables,
+      history: compactHistoryForPrompt(resolved, runtime)
+    });
+  };
+  return {
+    ...adapter,
+    validatePrompt,
+    renderPrompt
+  };
+}
+
+// src/providers/raw.ts
+function applyRawProviderBody(body, asset, provider) {
+  const raw = getRawProviderBody(asset, provider);
+  return raw ? { ...body, ...raw } : body;
+}
+function getRawProviderBody(asset, provider) {
+  if (provider === "openai-responses") {
+    return asset.raw?.["openai-responses"] ?? asset.raw?.openai_responses;
+  }
+  if (provider === "gemini") {
+    return asset.raw?.gemini ?? asset.raw?.google;
+  }
+  return asset.raw?.[provider];
+}
+
+// src/providers/openai.ts
+var openaiAdapter = withPromptInputSupport({
+  name: "openai",
+  validate(asset, runtime) {
+    const resolvedAsset = resolveAssetForProvider(asset, runtime);
+    const errors = [];
+    const warnings = [];
+    if (!resolvedAsset.model) {
+      errors.push("OpenAI adapter requires a model to be specified.");
+    }
+    if (resolvedAsset.reasoning?.budget_tokens !== void 0) {
+      warnings.push("OpenAI uses reasoning_effort, not budget_tokens. budget_tokens will be ignored.");
+    }
+    if (resolvedAsset.response?.schema !== void 0 && resolvedAsset.response?.format !== "json") {
+      warnings.push("OpenAI response.schema requires response.format: json. schema will still be applied as JSON schema output.");
+    }
+    return { valid: errors.length === 0, errors, warnings };
+  },
+  render(asset, runtime) {
+    const resolvedAsset = resolveAssetForProvider(asset, runtime);
+    const sections = renderSections(resolvedAsset, {
+      variables: runtime.variables,
+      strict: runtime.strict
+    });
+    const messages = [];
+    if (sections.system_instructions) {
+      messages.push({ role: "system", content: sections.system_instructions });
+    }
+    const history = compactHistoryForPrompt(resolvedAsset, runtime);
+    if (history) {
+      for (const msg of history) {
+        messages.push({ role: msg.role, content: msg.content });
+      }
+    }
+    if (sections.prompt_template) {
+      messages.push({ role: "user", content: sections.prompt_template });
+    }
+    const body = {
+      model: resolvedAsset.model,
+      messages
+    };
+    const openaiCacheConfig = resolvedAsset.cache?.openai;
+    if (resolvedAsset.sampling?.temperature !== void 0) body.temperature = resolvedAsset.sampling.temperature;
+    if (resolvedAsset.sampling?.top_p !== void 0) body.top_p = resolvedAsset.sampling.top_p;
+    if (resolvedAsset.sampling?.frequency_penalty !== void 0) body.frequency_penalty = resolvedAsset.sampling.frequency_penalty;
+    if (resolvedAsset.sampling?.presence_penalty !== void 0) body.presence_penalty = resolvedAsset.sampling.presence_penalty;
+    if (resolvedAsset.sampling?.stop !== void 0) body.stop = resolvedAsset.sampling.stop;
+    if (resolvedAsset.sampling?.max_output_tokens !== void 0) body.max_tokens = resolvedAsset.sampling.max_output_tokens;
+    if (resolvedAsset.reasoning?.effort) {
+      body.reasoning_effort = resolvedAsset.reasoning.effort;
+    }
+    if (resolvedAsset.response?.schema) {
+      body.response_format = {
+        type: "json_schema",
+        json_schema: {
+          name: resolvedAsset.response.schema_name ?? `${resolvedAsset.id}_response`,
+          ...resolvedAsset.response.schema_description ? { description: resolvedAsset.response.schema_description } : {},
+          schema: resolvedAsset.response.schema,
+          strict: resolvedAsset.response.schema_strict ?? true
+        }
+      };
+    } else if (resolvedAsset.response?.format === "json") {
+      body.response_format = { type: "json_object" };
+    }
+    if (resolvedAsset.response?.stream !== void 0) {
+      body.stream = resolvedAsset.response.stream;
+    }
+    if (openaiCacheConfig?.prompt_cache_key) {
+      body.prompt_cache_key = openaiCacheConfig.prompt_cache_key;
+    }
+    if (openaiCacheConfig?.retention) {
+      body.prompt_cache_retention = openaiCacheConfig.retention;
+    }
+    if (resolvedAsset.tools && resolvedAsset.tools.length > 0) {
+      body.tools = resolvedAsset.tools.map((tool) => {
+        if (typeof tool === "string") {
+          const def = runtime.toolRegistry?.[tool];
+          if (def) return def;
+          return { type: "function", function: { name: tool } };
+        }
+        return {
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.input_schema
+          }
+        };
+      });
+    }
+    return {
+      body: applyRawProviderBody(body, resolvedAsset, "openai"),
+      provider: "openai",
+      model: resolvedAsset.model ?? "unknown"
+    };
+  }
+});
+
+// src/providers/llmasaservice.ts
+var LLMASASERVICE_BASE_URL = "https://gateway.llmasaservice.io";
+var LLMASASERVICE_SDK_PLACEHOLDER_API_KEY = "not-used-by-llm-gateway";
+var LLMASASERVICE_DEFAULT_MODEL = "group:standard";
+var LLMASASERVICE_RESPONSE_HEADER_NAMES = [
+  "x-request-id",
+  "x-llm-model-id",
+  "x-llm-model-group"
+];
+function createLLMAsAServiceOpenAIConfig(options = {}) {
+  return {
+    baseURL: options.baseURL ?? LLMASASERVICE_BASE_URL,
+    apiKey: LLMASASERVICE_SDK_PLACEHOLDER_API_KEY,
+    defaultHeaders: {
+      "x-project-id": options.projectId ?? ""
+    }
+  };
+}
+function isGPT5ModelSelector(model) {
+  if (!model) return false;
+  return model.split(/[|,]/).map((candidate) => candidate.trim()).some((candidate) => candidate.startsWith("gpt-5") || candidate.startsWith("openai:gpt-5"));
+}
+function defaultModel() {
+  return LLMASASERVICE_DEFAULT_MODEL;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rawCustomerId(asset) {
+  const customer = isRecord(asset.raw?.llmasaservice?.customer) ? asset.raw.llmasaservice.customer : void 0;
+  return customer?.customer_id;
+}
+function isGatewayRenderValidation(runtime) {
+  return runtime?.runtime !== void 0;
+}
+var llmasaserviceAdapter = withPromptInputSupport({
+  name: "llmasaservice",
+  validate(asset, runtime) {
+    const resolvedAsset = resolveAssetForProvider(asset, runtime);
+    const validation = openaiAdapter.validate(
+      {
+        ...resolvedAsset,
+        model: resolvedAsset.model ?? defaultModel()
+      },
+      runtime
+    );
+    const warnings = validation.warnings.filter(
+      (warning) => warning !== "OpenAI adapter requires a model to be specified."
+    );
+    const errors = [...validation.errors];
+    const gatewayOptions = resolvedAsset.provider_options?.llmasaservice;
+    const missingProjectId = !gatewayOptions?.project_id;
+    const missingCustomerId = !gatewayOptions?.customer?.customer_id && typeof rawCustomerId(resolvedAsset) !== "string";
+    const validateRenderMetadata = isGatewayRenderValidation(runtime);
+    if (missingProjectId && validateRenderMetadata) {
+      errors.push(
+        "LLMAsAService adapter requires provider_options.llmasaservice.project_id for x-project-id routing."
+      );
+    }
+    if (missingCustomerId && validateRenderMetadata) {
+      errors.push(
+        "LLMAsAService adapter requires customer.customer_id in provider_options.llmasaservice.customer or raw.llmasaservice.customer."
+      );
+    }
+    if ((missingProjectId || missingCustomerId) && !validateRenderMetadata) {
+      warnings.push(
+        "LLMAsAService project_id and customer.customer_id must be supplied before rendering, usually through runtime provider_options."
+      );
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  },
+  render(asset, runtime) {
+    const resolvedAsset = resolveAssetForProvider(asset, runtime);
+    const options = resolvedAsset.provider_options?.llmasaservice;
+    const model = resolvedAsset.model ?? defaultModel();
+    const result = openaiAdapter.render(
+      { ...resolvedAsset, model, raw: void 0 },
+      {
+        variables: runtime.variables,
+        history: runtime.history,
+        onHistoryCompaction: runtime.onHistoryCompaction,
+        toolRegistry: runtime.toolRegistry,
+        strict: runtime.strict
+      }
+    );
+    let body = { ...result.body };
+    if (isGPT5ModelSelector(model) && body.max_tokens !== void 0 && body.max_completion_tokens === void 0) {
+      body.max_completion_tokens = body.max_tokens;
+      delete body.max_tokens;
+    }
+    if (options?.customer !== void 0) body.customer = options.customer;
+    if (options?.conversationId !== void 0) body.conversationId = options.conversationId;
+    if (options?.conversationTitle !== void 0) body.conversationTitle = options.conversationTitle;
+    if (options?.projectId !== void 0) body.projectId = options.projectId;
+    body = applyRawProviderBody(body, resolvedAsset, "llmasaservice");
+    const projectId = options?.project_id ?? "";
+    return {
+      body,
+      provider: "llmasaservice",
+      model,
+      baseURL: options?.base_url ?? LLMASASERVICE_BASE_URL,
+      headers: {
+        "x-project-id": projectId
+      }
+    };
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LLMASASERVICE_BASE_URL,
+  LLMASASERVICE_DEFAULT_MODEL,
+  LLMASASERVICE_RESPONSE_HEADER_NAMES,
+  LLMASASERVICE_SDK_PLACEHOLDER_API_KEY,
+  createLLMAsAServiceOpenAIConfig,
+  llmasaserviceAdapter
+});
+//# sourceMappingURL=llmasaservice.cjs.map