langwatch 0.30.0 → 0.31.0

package/dist/chunk-DAMGOHJV.mjs

@@ -0,0 +1,888 @@
+import {
+  createTracingProxy
+} from "./chunk-FG3JQBJB.mjs";
+import {
+  createLangWatchApiClient
+} from "./chunk-NCK4JOHC.mjs";
+import {
+  getLangWatchTracer
+} from "./chunk-SDUILEFR.mjs";
+import {
+  LANGWATCH_SDK_NAME_CLIENT,
+  LANGWATCH_SDK_VERSION
+} from "./chunk-B4QCZKFV.mjs";
+import {
+  shouldCaptureInput,
+  shouldCaptureOutput
+} from "./chunk-JOLGDU7Q.mjs";
+import {
+  NoOpLogger
+} from "./chunk-GVFRS2UN.mjs";
+import {
+  FileManager,
+  PromptConverter,
+  PromptFileNotFoundError
+} from "./chunk-YKGQVSLF.mjs";
+import {
+  extractStatusFromResponse,
+  formatApiErrorForOperation,
+  formatApiErrorMessage
+} from "./chunk-J3KM7ZO7.mjs";
+import {
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-BAX4W3AY.mjs";
+
+// src/client-sdk/services/prompts/errors/prompts.error.ts
+var PromptsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PromptsError";
+  }
+};
+
+// src/client-sdk/services/prompts/errors/prompt-compilation.error.ts
+var PromptCompilationError = class extends Error {
+  constructor(message, template, originalError) {
+    super(message);
+    this.template = template;
+    this.originalError = originalError;
+    this.name = "PromptCompilationError";
+  }
+};
+
+// src/client-sdk/services/prompts/errors/prompt-validation.error.ts
+var PromptValidationError = class extends Error {
+  constructor(message, validationErrors) {
+    super(message);
+    this.validationErrors = validationErrors;
+    this.name = "PromptValidationError";
+  }
+};
+
+// src/client-sdk/services/prompts/errors/prompts-api.error.ts
+var PromptsApiError = class extends PromptsError {
+  constructor(message, operation, originalError) {
+    super(message);
+    this.operation = operation;
+    this.originalError = originalError;
+    this.name = "PromptsApiError";
+  }
+};
+
+// src/client-sdk/services/prompts/prompts-api.service.ts
+import { z } from "zod";
+
+// src/client-sdk/services/prompts/tracing/prompt-tracing.decorator.ts
+var PromptTracingDecorator = class {
+  constructor(target) {
+    this.target = target;
+  }
+  traceCompilation(span, variables, compileFn) {
+    span.setType("prompt");
+    if (shouldCaptureInput()) {
+      span.setInput(this.target);
+      if (variables) {
+        span.setAttribute(
+          "langwatch.prompt.variables",
+          JSON.stringify({
+            type: "json",
+            value: variables
+          })
+        );
+      }
+    }
+    const result = compileFn();
+    if (result.handle != null && result.version != null) {
+      span.setAttribute(
+        "langwatch.prompt.id",
+        `${result.handle}:${result.version}`
+      );
+    }
+    if (shouldCaptureOutput()) {
+      span.setOutput(__spreadProps(__spreadValues({}, result), {
+        raw: void 0
+        // TODO(afr): Figure out a better way to do this.
+      }));
+    }
+    return result;
+  }
+  compile(span, variables = {}) {
+    return this.traceCompilation(
+      span,
+      variables,
+      () => this.target.compile(variables)
+    );
+  }
+  compileStrict(span, variables) {
+    return this.traceCompilation(
+      span,
+      variables,
+      () => this.target.compileStrict(variables)
+    );
+  }
+};
+
+// src/client-sdk/services/prompts/tracing/prompt-service-tracing.decorator.ts
+var PromptServiceTracingDecorator = class {
+  constructor(target) {
+    this.target = target;
+  }
+  async get(span, id, options) {
+    span.setType("prompt");
+    const result = await this.target.get(id, options);
+    if (result) {
+      if (result.handle != null && result.version != null) {
+        span.setAttribute(
+          "langwatch.prompt.id",
+          `${result.handle}:${result.version}`
+        );
+      }
+    }
+    if (result && shouldCaptureOutput()) {
+      span.setOutput("json", result);
+    }
+    return result;
+  }
+  async create(span, params) {
+    var _a;
+    span.setType("prompt");
+    if (shouldCaptureInput()) {
+      span.setInput(params);
+    }
+    const result = await this.target.create(params);
+    span.setAttributes({
+      "langwatch.prompt.id": result.id,
+      "langwatch.prompt.handle": (_a = result.handle) != null ? _a : void 0,
+      "langwatch.prompt.scope": result.scope,
+      "langwatch.prompt.version.id": result.versionId,
+      "langwatch.prompt.version.number": result.version
+    });
+    return result;
+  }
+  async update(span, id, params) {
+    var _a;
+    if (shouldCaptureInput()) {
+      span.setInput(params);
+    }
+    const result = await this.target.update(id, params);
+    span.setType("prompt");
+    span.setAttributes({
+      "langwatch.prompt.id": id,
+      "langwatch.prompt.handle": (_a = result.handle) != null ? _a : void 0,
+      "langwatch.prompt.scope": result.scope,
+      "langwatch.prompt.version.id": result.versionId,
+      "langwatch.prompt.version.number": result.version
+    });
+    return result;
+  }
+  async delete(span, id) {
+    const result = await this.target.delete(id);
+    span.setType("prompt");
+    span.setAttribute("langwatch.prompt.id", id);
+    span.setAttribute("langwatch.prompt.deleted", "true");
+    return result;
+  }
+  async upsert(span, handle, config) {
+    if (shouldCaptureInput()) {
+      span.setInput(config);
+    }
+    const result = await this.target.upsert(handle, config);
+    span.setType("prompt");
+    span.setAttributes({
+      "langwatch.prompt.handle": handle,
+      "langwatch.prompt.created": result.created.toString(),
+      "langwatch.prompt.id": result.prompt.id,
+      "langwatch.prompt.version.id": result.prompt.versionId,
+      "langwatch.prompt.version.number": result.prompt.version
+    });
+    return result;
+  }
+  async sync(span, params) {
+    if (shouldCaptureInput()) {
+      span.setInput(params);
+    }
+    const result = await this.target.sync(params);
+    span.setType("prompt");
+    span.setAttribute("langwatch.prompt.name", params.name);
+    span.setAttribute("langwatch.prompt.sync.action", result.action);
+    if (result.conflictInfo) {
+      span.setAttributes({
+        "langwatch.prompt.sync.has_conflict": "true",
+        "langwatch.prompt.sync.local_version": result.conflictInfo.localVersion.toString(),
+        "langwatch.prompt.sync.remote_version": result.conflictInfo.remoteVersion.toString()
+      });
+    }
+    return result;
+  }
+};
+
+// src/client-sdk/services/prompts/tracing/tracer.ts
+var tracer = getLangWatchTracer(`${LANGWATCH_SDK_NAME_CLIENT}.prompts`, LANGWATCH_SDK_VERSION);
+
+// src/client-sdk/services/prompts/prompts-api.service.ts
+var syncActionSchema = z.enum([
+  "created",
+  "updated",
+  "conflict",
+  "up_to_date"
+]);
+var syncResultSchema = z.object({
+  action: syncActionSchema,
+  // `prompt` and `conflictInfo` are passed through untyped — they come from
+  // the OpenAPI-derived shape which is already validated on the server side.
+  prompt: z.unknown().optional(),
+  conflictInfo: z.object({
+    localVersion: z.number(),
+    remoteVersion: z.number(),
+    differences: z.array(z.string()),
+    remoteConfigData: z.unknown()
+  }).passthrough().optional()
+});
+var PromptsApiService = class {
+  constructor(config) {
+    /**
+     * Fetches a single prompt by its ID.
+     * @param id The prompt's unique identifier.
+     * @param options Optional parameters for the request.
+     * @param options.version Specific version to fetch (numeric string or "latest").
+     * @param options.tag Tag to fetch (e.g., "production", "staging", or a custom tag).
+     * @returns Raw PromptResponse data.
+     * @throws {PromptsApiError} If the API call fails.
+     */
+    this.get = async (id, options) => {
+      const versionNumber = (options == null ? void 0 : options.version) && options.version !== "latest" ? parseInt(options.version, 10) : void 0;
+      const { data, error } = await this.apiClient.GET(
+        "/api/prompts/{id}",
+        {
+          params: {
+            path: { id },
+            query: {
+              version: Number.isNaN(versionNumber) ? void 0 : versionNumber,
+              tag: options == null ? void 0 : options.tag
+            }
+          }
+        }
+      );
+      if (error) {
+        this.handleApiError(`fetch prompt with ID "${id}"`, error);
+      }
+      return data;
+    };
+    var _a;
+    this.apiClient = (_a = config == null ? void 0 : config.langwatchApiClient) != null ? _a : createLangWatchApiClient();
+    return createTracingProxy(
+      this,
+      tracer,
+      PromptServiceTracingDecorator
+    );
+  }
+  /**
+   * Handles API errors by throwing a PromptsApiError with operation context.
+   * @param operation Description of the operation being performed.
+   * @param error The error object returned from the API client.
+   * @throws {PromptsApiError}
+   */
+  handleApiError(operation, error, status) {
+    const message = formatApiErrorForOperation({ operation, error, options: {
+      status: status != null ? status : extractStatusFromResponse(error)
+    } });
+    throw new PromptsApiError(message, operation, error);
+  }
+  /**
+   * Fetches all prompts from the API.
+   * @returns Array of raw PromptResponse data.
+   * @throws {PromptsApiError} If the API call fails.
+   */
+  async getAll() {
+    const { data, error } = await this.apiClient.GET("/api/prompts");
+    if (error) this.handleApiError("fetch all prompts", error);
+    return data;
+  }
+  /**
+   * Validates if a prompt exists.
+   * @param id The prompt's unique identifier.
+   * @returns True if prompt exists, false otherwise.
+   * @throws {PromptsApiError} If the API call fails (not 404).
+   */
+  async exists(id) {
+    try {
+      await this.get(id);
+      return true;
+    } catch (error) {
+      const originalError = error instanceof PromptsApiError ? error.originalError : null;
+      const statusCode = originalError != null && typeof originalError === "object" && "statusCode" in originalError ? originalError.statusCode : null;
+      if (statusCode === 404) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Creates a new prompt.
+   * @param params The prompt creation payload, matching the OpenAPI schema.
+   * @returns Raw PromptResponse data of the created prompt.
+   * @throws {PromptsApiError} If the API call fails.
+   */
+  async create(params) {
+    const { data, error } = await this.apiClient.POST(
+      "/api/prompts",
+      {
+        body: params
+      }
+    );
+    if (error) this.handleApiError("create prompt", error);
+    return data;
+  }
+  /**
+   * Updates an existing prompt.
+   * @param id The prompt's unique identifier.
+   * @param params The update payload, matching the OpenAPI schema.
+   * @returns Raw PromptResponse data of the updated prompt.
+   * @throws {PromptsApiError} If the API call fails.
+   */
+  async update(id, params) {
+    const { error, data: updatedPrompt } = await this.apiClient.PUT("/api/prompts/{id}", {
+      params: { path: { id } },
+      body: params
+    });
+    if (error) this.handleApiError(`update prompt with ID "${id}"`, error);
+    return updatedPrompt;
+  }
+  /**
+   * Lists all prompt tags (built-in and custom) for the organization.
+   * @returns Array of tag definitions.
+   * @throws {PromptsApiError} If the API call fails.
+   */
+  async listTags() {
+    const { data, error } = await this.apiClient.GET("/api/prompts/tags");
+    if (error) this.handleApiError("list tags", error);
+    return data;
+  }
+  /**
+   * Creates a custom prompt tag for the organization.
+   * @param params.name The tag name (must match /^[a-z][a-z0-9_-]*$/).
+   * @returns The created tag.
+   * @throws {PromptsApiError} If the API call fails.
+   */
+  async createTag({ name }) {
+    const { data, error } = await this.apiClient.POST("/api/prompts/tags", {
+      body: { name }
+    });
+    if (error) this.handleApiError("create tag", error);
+    return data;
+  }
+  /**
+   * Deletes a custom prompt tag by name.
+   * @param tagName The tag name to delete.
+   * @throws {PromptsApiError} If the API call fails.
+   */
+  async deleteTag(tagName) {
+    const { error } = await this.apiClient.DELETE(
+      "/api/prompts/tags/{tag}",
+      { params: { path: { tag: tagName } } }
+    );
+    if (error) this.handleApiError(`delete tag "${tagName}"`, error);
+  }
+  /**
+   * Renames an existing prompt tag.
+   * @param tag The current tag name.
+   * @param name The new tag name.
+   * @throws {PromptsApiError} If the API call fails.
+   */
+  async renameTag({ tag, name }) {
+    const { error } = await this.apiClient.PUT(
+      "/api/prompts/tags/{tag}",
+      { params: { path: { tag } }, body: { name } }
+    );
+    if (error) this.handleApiError(`rename tag "${tag}"`, error);
+  }
+  async assignTag({
+    id,
+    tag,
+    versionId
+  }) {
+    const { data, error } = await this.apiClient.PUT(
+      "/api/prompts/{id}/tags/{tag}",
+      {
+        params: { path: { id, tag } },
+        body: { versionId }
+      }
+    );
+    if (error) this.handleApiError(`assign tag "${tag}" to prompt "${id}"`, error);
+    return data;
+  }
+  /**
+   * Deletes a prompt by its ID.
+   * @param id The prompt's unique identifier.
+   * @throws {PromptsApiError} If the API call fails.
+   */
+  async delete(id) {
+    const { data, error } = await this.apiClient.DELETE(
+      "/api/prompts/{id}",
+      {
+        params: { path: { id } }
+      }
+    );
+    if (error) this.handleApiError(`delete prompt with ID "${id}"`, error);
+    return data;
+  }
+  /**
+   * Fetches all versions for a given prompt.
+   * @param id The prompt's unique identifier.
+   * @returns Array of raw PromptResponse data for each version.
+   * @throws {PromptsApiError} If the API call fails.
+   */
+  async getVersions(id) {
+    const { data, error } = await this.apiClient.GET(
+      "/api/prompts/{id}/versions",
+      {
+        params: { path: { id } }
+      }
+    );
+    if (error)
+      this.handleApiError(`fetch versions for prompt with ID "${id}"`, error);
+    return data;
+  }
+  /**
+   * Upserts a prompt with local configuration - creates if doesn't exist, updates version if exists.
+   * @param handle The prompt's handle/identifier.
+   * @param config Local prompt configuration.
+   * @returns Object with created flag and raw PromptResponse data.
+   * @throws {PromptsApiError} If the API call fails.
+   */
+  async upsert(handle, config) {
+    var _a, _b;
+    const payload = {
+      handle,
+      model: config.model,
+      prompt: PromptConverter.extractSystemPrompt(config.messages),
+      messages: PromptConverter.filterNonSystemMessages(config.messages),
+      temperature: (_a = config.modelParameters) == null ? void 0 : _a.temperature,
+      maxTokens: (_b = config.modelParameters) == null ? void 0 : _b.max_tokens,
+      inputs: [{ identifier: "input", type: "str" }],
+      outputs: [{ identifier: "output", type: "str" }],
+      commitMessage: `Updated via CLI sync`,
+      schemaVersion: "1.0"
+    };
+    try {
+      const prompt = await this.create(payload);
+      return {
+        created: true,
+        prompt
+      };
+    } catch (e) {
+      const prompt = await this.update(handle, payload);
+      return {
+        created: false,
+        prompt
+      };
+    }
+  }
+  /**
+   * Sync a prompt with local content, handling conflicts and version management
+   * You probably don't need to use this method directly.
+   */
+  async sync(params) {
+    var _a, _b, _c;
+    let response;
+    try {
+      response = await this.apiClient.POST(
+        "/api/prompts/{id}/sync",
+        {
+          params: { path: { id: params.name } },
+          body: {
+            configData: params.configData,
+            localVersion: params.localVersion,
+            commitMessage: params.commitMessage
+          }
+        }
+      );
+    } catch (error) {
+      const message = formatApiErrorForOperation({ operation: "sync prompt", error });
+      throw new PromptsApiError(message, "sync", error);
+    }
+    if (response == null ? void 0 : response.error) {
+      const err = response.error;
+      const status = (_b = (_a = response.response) == null ? void 0 : _a.status) != null ? _b : extractStatusFromResponse(err);
+      const message = formatApiErrorMessage({ error: err, options: { status } });
+      throw new PromptsApiError(
+        `Failed to sync prompt: ${message}`,
+        "sync",
+        err
+      );
+    }
+    const parsed = syncResultSchema.safeParse(response == null ? void 0 : response.data);
+    if (!parsed.success) {
+      throw new PromptsApiError(
+        "Failed to sync prompt: server returned an invalid response body",
+        "sync",
+        (_c = response == null ? void 0 : response.data) != null ? _c : response
+      );
+    }
+    return {
+      action: parsed.data.action,
+      prompt: parsed.data.prompt,
+      conflictInfo: parsed.data.conflictInfo
+    };
+  }
+};
+
+// src/client-sdk/services/prompts/types.ts
+var FetchPolicy = /* @__PURE__ */ ((FetchPolicy2) => {
+  FetchPolicy2["MATERIALIZED_FIRST"] = "MATERIALIZED_FIRST";
+  FetchPolicy2["ALWAYS_FETCH"] = "ALWAYS_FETCH";
+  FetchPolicy2["CACHE_TTL"] = "CACHE_TTL";
+  FetchPolicy2["MATERIALIZED_ONLY"] = "MATERIALIZED_ONLY";
+  return FetchPolicy2;
+})(FetchPolicy || {});
+
+// src/client-sdk/services/prompts/prompt.ts
+import { Liquid } from "liquidjs";
+
+// src/client-sdk/services/prompts/schema/prompt.schema.ts
+import { z as z2 } from "zod";
+
+// src/client-sdk/services/prompts/constants.ts
+var PromptScope = {
+  ORGANIZATION: "ORGANIZATION",
+  PROJECT: "PROJECT"
+};
+
+// src/client-sdk/services/prompts/schema/prompt.schema.ts
+var messageSchema = z2.object({
+  role: z2.enum(["user", "assistant", "system"]),
+  content: z2.string()
+});
+var responseFormatSchema = z2.object({
+  type: z2.literal("json_schema"),
+  json_schema: z2.object({
+    name: z2.string(),
+    schema: z2.record(z2.string(), z2.unknown())
+  }).nullable()
+}).optional();
+var corePromptDataSchema = z2.object({
+  model: z2.string().min(1, "Model cannot be empty"),
+  messages: z2.array(messageSchema).min(1, "At least one message is required"),
+  prompt: z2.string().optional(),
+  temperature: z2.number().min(0).max(2).optional(),
+  maxTokens: z2.number().positive().optional(),
+  responseFormat: responseFormatSchema
+});
+var promptMetadataSchema = z2.object({
+  id: z2.string().optional(),
+  handle: z2.string().nullable().optional(),
+  version: z2.number().min(0).optional(),
+  versionId: z2.string().optional(),
+  scope: z2.enum(PromptScope).optional()
+});
+var promptDataSchema = z2.object(__spreadValues(__spreadValues({}, corePromptDataSchema.shape), promptMetadataSchema.shape));
+
+// src/client-sdk/services/prompts/prompt.ts
+var liquid = new Liquid({
+  strictFilters: true
+});
+var Prompt = class {
+  constructor(data) {
+    var _a;
+    const validationResult = promptDataSchema.strip().safeParse(data);
+    if (!validationResult.success) {
+      throw new PromptValidationError(
+        "Invalid prompt data provided",
+        validationResult.error
+      );
+    }
+    Object.assign(this, validationResult.data);
+    (_a = this.prompt) != null ? _a : this.prompt = this.extractSystemPrompt();
+    return createTracingProxy(this, tracer, PromptTracingDecorator);
+  }
+  extractSystemPrompt() {
+    var _a, _b;
+    return (_b = (_a = this.messages.find((m) => m.role === "system")) == null ? void 0 : _a.content) != null ? _b : "";
+  }
+  /**
+   * Compile the prompt template with provided variables (lenient - missing variables become empty)
+   * @param variables - Object containing variable values for template compilation
+   * @returns CompiledPrompt instance with compiled content
+   */
+  _compile(variables, strict) {
+    var _a;
+    try {
+      const compiledPrompt = this.prompt ? liquid.parseAndRenderSync(this.prompt, variables, {
+        strictVariables: strict
+      }) : "";
+      const compiledMessages = (this.messages || []).map((message) => __spreadProps(__spreadValues({}, message), {
+        content: message.content ? liquid.parseAndRenderSync(message.content, variables, {
+          strictVariables: strict
+        }) : message.content
+      }));
+      const compiledData = __spreadProps(__spreadValues({}, this), {
+        prompt: compiledPrompt,
+        messages: compiledMessages
+      });
+      return new CompiledPrompt(compiledData, this);
+    } catch (error) {
+      const templateStr = (_a = this.prompt) != null ? _a : JSON.stringify(this.messages);
+      throw new PromptCompilationError(
+        `Failed to compile prompt template: ${error instanceof Error ? error.message : "Unknown error"}`,
+        templateStr,
+        error
+      );
+    }
+  }
+  compile(variables = {}) {
+    return this._compile(variables, false);
+  }
+  /**
+   * Compile with validation - throws error if required variables are missing
+   * @param variables - Template variables
+   * @returns CompiledPrompt instance with compiled content
+   */
+  compileStrict(variables) {
+    return this._compile(variables, true);
+  }
+};
+var CompiledPrompt = class extends Prompt {
+  constructor(compiledData, original) {
+    super(compiledData);
+    this.original = original;
+  }
+};
+
+// src/client-sdk/services/prompts/local-prompts.service.ts
+var LocalPromptsService = class {
+  constructor(config) {
+    var _a, _b;
+    this.fileManager = (_a = config == null ? void 0 : config.fileManager) != null ? _a : FileManager;
+    this.logger = (_b = config == null ? void 0 : config.logger) != null ? _b : new NoOpLogger();
+  }
+  /**
+   * Retrieves a prompt using the configured search strategy.
+   * Tries each source in priority order until found or all sources exhausted.
+   */
+  async get(handleOrId) {
+    var _a, _b;
+    try {
+      const dependency = await this.getDependencyFromConfig(handleOrId);
+      if (!dependency) {
+        return null;
+      }
+      const localPromptConfig = (_b = (_a = await this.getFromConfig(dependency).catch((e) => {
+        if (e instanceof PromptFileNotFoundError) return null;
+        throw e;
+      })) != null ? _a : await this.getFromLockFile(handleOrId).catch((e) => {
+        if (e instanceof PromptFileNotFoundError) return null;
+        throw e;
+      })) != null ? _b : await this.getFromLocalFiles(handleOrId).catch((e) => {
+        if (e instanceof PromptFileNotFoundError) return null;
+        throw e;
+      });
+      return localPromptConfig ? this.convertToPromptData(__spreadProps(__spreadValues({}, localPromptConfig), {
+        handle: handleOrId
+      })) : null;
+    } catch (error) {
+      this.logger.warn(`Failed to get prompt "${handleOrId}": ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }
+  }
+  /**
+   * Searches for prompt using explicit file mapping in prompts.json.
+   * Looks for dependencies with a 'file' property pointing to a specific path.
+   */
+  async getFromConfig(dependency) {
+    if (typeof dependency === "string" && dependency.startsWith("file:")) {
+      return this.fileManager.loadLocalPrompt(dependency.slice(5));
+    }
+    return null;
+  }
+  /**
+   * Searches for prompt using materialized path from lock file.
+   * Lock file contains resolved paths for prompts that have been synced/materialized.
+   */
+  async getFromLockFile(handleOrId) {
+    const lock = this.fileManager.loadPromptsLock();
+    const lockEntry = lock.prompts[handleOrId];
+    if (lockEntry == null ? void 0 : lockEntry.materialized) {
+      return this.fileManager.loadLocalPrompt(lockEntry.materialized);
+    }
+    return null;
+  }
+  /**
+   * Searches for prompt by scanning all .prompt.yaml files in prompts directory.
+   * Extracts prompt name from file path and matches against the requested handle.
+   * This is the fallback method when explicit mappings don't exist.
+   */
+  async getFromLocalFiles(handleOrId) {
+    const localFiles = this.fileManager.getLocalPromptFiles();
+    for (const filePath of localFiles) {
+      const promptName = this.fileManager.promptNameFromPath(filePath);
+      if (promptName === handleOrId) {
+        return this.fileManager.loadLocalPrompt(filePath);
+      }
+    }
+    return null;
+  }
+  /**
+   * Get dependency from config
+   */
+  async getDependencyFromConfig(handleOrId) {
+    const config = this.fileManager.loadPromptsConfig();
+    const dependency = config.prompts[handleOrId];
+    return dependency != null ? dependency : null;
+  }
+  /**
+   * Converts LocalPromptConfig to PromptData format
+   */
+  convertToPromptData(config) {
+    const _a = config, { modelParameters } = _a, rest = __objRest(_a, ["modelParameters"]);
+    return __spreadValues({
+      maxTokens: modelParameters == null ? void 0 : modelParameters.max_tokens,
+      temperature: modelParameters == null ? void 0 : modelParameters.temperature
+    }, rest);
+  }
+};
+
+// src/client-sdk/services/prompts/prompts.facade.ts
+var PromptsFacade = class {
+  constructor(config) {
+    this.cache = /* @__PURE__ */ new Map();
+    var _a, _b;
+    this.promptsApiService = (_a = config.promptsApiService) != null ? _a : new PromptsApiService(config);
+    this.localPromptsService = (_b = config.localPromptsService) != null ? _b : new LocalPromptsService();
+    this.tags = {
+      assign: (id, { tag, versionId }) => this.promptsApiService.assignTag({ id, tag, versionId }),
+      list: () => this.promptsApiService.listTags(),
+      create: ({ name }) => this.promptsApiService.createTag({ name }),
+      delete: (tagName) => this.promptsApiService.deleteTag(tagName),
+      rename: (oldName, newName) => this.promptsApiService.renameTag({ tag: oldName, name: newName })
+    };
+  }
+  /**
+   * Creates a new prompt.
+   * @param data The prompt creation payload.
+   * @returns The created Prompt instance.
+   * @throws {PromptsError} If the API call fails.
+   */
+  async create(data) {
+    const serverPrompt = await this.promptsApiService.create(data);
+    return new Prompt(serverPrompt);
+  }
+  /**
+   * Retrieves a prompt by handle or ID.
+   *
+   * Supports shorthand `handle:tag` syntax — e.g. `get("pizza-prompt:production")`.
+   * Shorthand is parsed server-side; the SDK passes the string through as-is.
+   *
+   * @param handleOrId The prompt's handle, unique identifier, or `handle:tag` shorthand.
+   * @param options Optional parameters for the request.
+   * @returns The Prompt instance.
+   * @throws {PromptsError} If the prompt is not found or the API call fails.
+   */
+  async get(handleOrId, options) {
+    var _a;
+    const fetchPolicy = (_a = options == null ? void 0 : options.fetchPolicy) != null ? _a : "MATERIALIZED_FIRST" /* MATERIALIZED_FIRST */;
+    switch (fetchPolicy) {
+      case "MATERIALIZED_ONLY" /* MATERIALIZED_ONLY */:
+        return this.getMaterializedOnly(handleOrId);
+      case "ALWAYS_FETCH" /* ALWAYS_FETCH */:
+        return this.getAlwaysFetch(handleOrId, options);
+      case "CACHE_TTL" /* CACHE_TTL */:
+        return this.getCacheTtl(handleOrId, options);
+      case "MATERIALIZED_FIRST" /* MATERIALIZED_FIRST */:
+      default:
+        return this.getMaterializedFirst(handleOrId, options);
+    }
+  }
+  async getMaterializedFirst(handleOrId, options) {
+    const localPrompt = await this.localPromptsService.get(handleOrId);
+    if (localPrompt) {
+      return new Prompt(localPrompt);
+    }
+    const serverPrompt = await this.promptsApiService.get(handleOrId, options);
+    return new Prompt(serverPrompt);
+  }
+  async getAlwaysFetch(handleOrId, options) {
+    try {
+      const serverPrompt = await this.promptsApiService.get(handleOrId, options);
+      return new Prompt(serverPrompt);
+    } catch (e) {
+      const localPrompt = await this.localPromptsService.get(handleOrId);
+      if (localPrompt) {
+        return new Prompt(localPrompt);
+      }
+      throw new PromptsError(`Prompt "${handleOrId}" not found locally or on server`);
+    }
+  }
+  async getMaterializedOnly(handleOrId) {
+    const localPrompt = await this.localPromptsService.get(handleOrId);
+    if (localPrompt) {
+      return new Prompt(localPrompt);
+    }
+    throw new PromptsError(`Prompt "${handleOrId}" not found in materialized files`);
+  }
+  buildCacheKey(handleOrId, options) {
+    var _a;
+    const tagSegment = (options == null ? void 0 : options.tag) != null ? `::tag:${options.tag}` : "";
+    return `${handleOrId}::version:${(_a = options == null ? void 0 : options.version) != null ? _a : ""}${tagSegment}`;
+  }
+  async getCacheTtl(handleOrId, options) {
+    var _a;
+    const cacheKey = this.buildCacheKey(handleOrId, options);
+    const ttlMs = ((_a = options == null ? void 0 : options.cacheTtlMinutes) != null ? _a : 5) * 60 * 1e3;
+    const cached = this.cache.get(cacheKey);
+    const now = Date.now();
+    if (cached && now - cached.timestamp < ttlMs) {
+      return new Prompt(cached.data);
+    }
+    try {
+      const serverPrompt = await this.promptsApiService.get(handleOrId, options);
+      this.cache.set(cacheKey, { data: serverPrompt, timestamp: now });
+      return new Prompt(serverPrompt);
+    } catch (e) {
+      const localPrompt = await this.localPromptsService.get(handleOrId);
+      if (localPrompt) {
+        return new Prompt(localPrompt);
+      }
+      throw new PromptsError(`Prompt "${handleOrId}" not found locally or on server`);
+    }
+  }
+  /**
+   * Retrieves all prompts.
+   * @returns Array of Prompt instances.
+   * @throws {PromptsError} If the API call fails.
+   */
+  async getAll() {
+    const serverPrompts = await this.promptsApiService.getAll();
+    return serverPrompts.map((prompt) => new Prompt(prompt));
+  }
+  /**
+   * Updates an existing prompt.
+   * @param handleOrId The prompt's handle or unique identifier.
+   * @param newData The update payload.
+   * @returns The updated Prompt instance.
+   * @throws {PromptsError} If the API call fails.
+   */
+  async update(handleOrId, newData) {
+    const serverPrompt = await this.promptsApiService.update(handleOrId, newData);
+    return new Prompt(serverPrompt);
+  }
+  get delete() {
+    return this.promptsApiService.delete.bind(this.promptsApiService);
+  }
+  /**
+   * Delegated method to the prompts API service.
+   */
+  get sync() {
+    return this.promptsApiService.sync.bind(this.promptsApiService);
+  }
+};
+
+export {
+  PromptsError,
+  PromptsApiService,
+  FetchPolicy,
+  LocalPromptsService,
+  PromptsFacade
+};
+//# sourceMappingURL=chunk-DAMGOHJV.mjs.map