@mate-academy/prompt-client 1.0.0

package/README.md

@@ -0,0 +1,251 @@
+# @mate-academy/prompt-client
+
+Provider-agnostic LLM prompt management and tracing client. Consumers code
+against two stable interfaces — `LLMPromptClient` (fetch + compile prompts,
+caching, fallbacks) and `LLMTracer` (traces + generations with usage/cost
+details) — and pick a provider from `PromptManagementProviders`. The provider
+can be swapped without touching call sites.
+
+Providers:
+
+- **`Langfuse`** — the real provider. One shared Langfuse SDK client backs both
+  the prompt client and the tracer.
+- **`InMemory`** — a deterministic test double: seedable prompts and a
+  recording tracer for assertions. Use it in unit/integration tests instead of
+  hand-rolled mocks.
+
+## Install
+
+```bash
+npm install @mate-academy/prompt-client
+```
+
+## Quick start
+
+```typescript
+import {
+  createPromptManagement,
+  PromptManagementProviders,
+} from '@mate-academy/prompt-client';
+
+const promptManagement = createPromptManagement({
+  provider: PromptManagementProviders.Langfuse,
+  options: {
+    credentials: {
+      publicKey: process.env.LANGFUSE_PUBLIC_KEY ?? '',
+      secretKey: process.env.LANGFUSE_SECRET_KEY ?? '',
+      baseUrl: process.env.LANGFUSE_BASE_URL ?? '',
+    },
+  },
+  logger,
+});
+
+const prompt = await promptManagement.promptClient.getPrompt('my-prompt');
+const instructions = prompt.compile({ leadName: 'Maria' });
+```
+
+`createPromptManagement` returns a `PromptManagementBundle`:
+
+| Member | Purpose |
+|---|---|
+| `promptClient` | `LLMPromptClient` — `getPrompt(name, options?)`, `shutdown()` |
+| `tracer` | `LLMTracer` — `createTrace`, `createGeneration`, `flush`, `shutdown` |
+| `flush()` | Flush pending trace/generation events without shutting down |
+| `shutdown()` | Flush and stop the underlying client (whole bundle) |
+
+`promptClient.shutdown()` and `tracer.shutdown()` stop the same shared client;
+prefer `bundle.shutdown()`.
+
+## Prompts
+
+```typescript
+const prompt = await promptClient.getPrompt('chatAgent.instructions', {
+  label: 'production',      // default; mutually exclusive with version
+  version: 4,               // pin an exact version (label is then omitted)
+  cacheTtlSeconds: 60,      // default 60s, SDK-side cache + background refresh
+  fallback: FALLBACK_TEXT,  // never throw: return this text on any failure
+});
+
+prompt.name;        // 'chatAgent.instructions'
+prompt.version;     // Langfuse version, or 0 when the fallback was used
+prompt.isFallback;  // true when the fallback was served
+prompt.config;      // the config object stored on the Langfuse prompt
+prompt.compile({ leadName: 'Maria' }); // mustache-style {{var}} substitution
+```
+
+Error model (only when NO `fallback` is provided):
+
+- `LLMPromptNotFoundError` — the prompt does not exist (safe to use as an
+  existence probe).
+- `LLMPromptFetchError` — infrastructure failure (network/HTTP) or a non-text
+  prompt. Both extend `LLMPromptError` and carry `promptName` + `cause`.
+
+With `fallback` set, `getPrompt` never rejects: on any failure it resolves to
+the fallback text with `version: 0` and `isFallback: true`, and the logger
+receives a warning.
+
+## Tracing
+
+```typescript
+const trace = tracer.createTrace({
+  name: 'conversation-turn',
+  sessionId: chatId,      // groups turns of one conversation in Langfuse
+  userId,
+  tags: ['sdr'],
+  input: inboundMessage,
+});
+
+const generation = tracer.createGeneration(trace, {
+  name: 'chat-completion',
+  model: modelName,
+  input: messages,
+  prompt,                 // links the generation to the Langfuse prompt version
+});
+
+generation.end({
+  output: completion,
+  usageDetails: usageToUsageDetails(response.usage),
+  costDetails: costToCostDetails(response.cost),
+});
+
+trace.update({ output: decision });
+```
+
+`usageToUsageDetails` / `costToCostDetails` convert
+`@mate-academy/llm-gateway` usage/cost results into the shape Langfuse expects;
+their input types are structural, so no llm-gateway dependency is required.
+
+## Usage in a long-lived server (api)
+
+A process can talk to several Langfuse projects. A project is a **runtime
+argument, never baked into the client**: build one bundle per project (one
+shared client each), memoize them behind a registry keyed by your own project
+enum, and pass the project at the call site. Flush + stop every live bundle on
+SIGTERM.
+
+```typescript
+const bundles = new Map<LangfuseProject, PromptManagementBundle>();
+
+const getPromptManagement = (
+  project: LangfuseProject,
+): PromptManagementBundle => {
+  const existing = bundles.get(project);
+
+  if (existing) {
+    return existing;
+  }
+
+  const bundle = createPromptManagement({
+    provider: PromptManagementProviders.Langfuse,
+    options: { credentials: appConfig.langfuse.projects[project] },
+    logger: rootLogger.child(`PromptManagement:${project}`),
+  });
+
+  bundles.set(project, bundle);
+
+  return bundle;
+};
+
+// at a call site — pick the project you need:
+const { promptClient, tracer } = getPromptManagement(LangfuseProject.SalesQA);
+
+// in graceful shutdown:
+await Promise.all([...bundles.values()].map((bundle) => bundle.shutdown()));
+```
+
+Memoizing per project is correctness, not caching: each bundle owns a live SDK
+client with a background flush timer and buffered events, so the registry's
+`Map` is the client's lifetime — one client per project per process.
+
+Typed error handling keeps existing semantics: catch
+`LLMPromptNotFoundError` for "is this conversation scorable?" probes and treat
+`LLMPromptFetchError` as an infrastructure alert.
+
+## Usage in a Lambda
+
+Create the bundle at module scope so it stays warm across invocations, use
+per-prompt fallbacks so a Langfuse outage can never break a turn, and **flush
+at the end of every invocation** — buffered trace events are lost when the
+sandbox freezes:
+
+```typescript
+const promptManagement = createPromptManagement({
+  provider: PromptManagementProviders.Langfuse,
+  options: {
+    credentials: {
+      publicKey: appConfig.langfusePublicKey,
+      secretKey: appConfig.langfuseSecretKey,
+      baseUrl: appConfig.langfuseBaseUrl,
+    },
+    flushAt: 1, // send events immediately; Lambdas have no idle time to batch
+  },
+  logger,
+});
+
+export const handler = async (event: SQSEvent): Promise<void> => {
+  try {
+    const prompt = await promptManagement.promptClient.getPrompt(
+      PromptKey.ChatAgentInstructions,
+      { fallback: FALLBACKS[PromptKey.ChatAgentInstructions] },
+    );
+    // ... run the turn, create trace/generations with sessionId: chatId
+  } finally {
+    await promptManagement.flush();
+  }
+};
+```
+
+## Testing consumers with the InMemory provider
+
+```typescript
+const promptManagement = createPromptManagement({
+  provider: PromptManagementProviders.InMemory,
+  options: {
+    prompts: {
+      'chatAgent.instructions': { prompt: 'Reply to {{leadName}}', version: 3 },
+    },
+    // GenerateStub: unknown names resolve to `Mock prompt for <name>`
+    missingPromptBehavior: InMemoryMissingPromptBehaviors.GenerateStub,
+  },
+});
+
+// The InMemory bundle is typed with the concrete classes:
+promptManagement.promptClient.setPrompt('closing', { prompt: 'Bye!' });
+promptManagement.tracer.traces;          // recorded traces + their updates
+promptManagement.tracer.generations;     // recorded generations + end payloads
+promptManagement.tracer.flushCallCount;  // flush()/shutdown() call counters
+promptManagement.tracer.reset();
+```
+
+## Provider notes (Langfuse)
+
+- `label` and `version` are mutually exclusive; when `version` is set the
+  label (including the `production` default) is omitted automatically.
+- Fallback prompts have `version: 0` and `isFallback: true` (SDK semantics).
+- Only `text` prompts are supported; a `chat` prompt is rejected with
+  `LLMPromptFetchError`. Chat support would arrive as an additive
+  `getChatPrompt` method.
+- Pinned to the `langfuse` v3 SDK. Its only dynamic imports target Node
+  built-ins (`fs`, `crypto`) and are marked `webpackIgnore`, so the package is
+  safe to bundle with webpack/serverless-bundle for Lambdas.
+- No SDK types leak through the public API; a future SDK swap stays inside
+  this package.
+
+## Development
+
+```bash
+npm run lint
+npm run type-check
+npm test                  # unit tests, no network
+npm run test:integration  # requires .env.test (see .env.test.example)
+npm run build
+```
+
+## Publishing
+
+```bash
+npm run patch   # or minor / major / canary
+```
+
+First-ever publish of this scoped package must pass `--access public`:
+`npm publish --access public`.

package/dist/LLMPromptClient.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_PROMPT_LABEL = "production";
+export declare const DEFAULT_PROMPT_CACHE_TTL_SECONDS = 60;

package/dist/LLMPromptClient.constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROMPT_CACHE_TTL_SECONDS = exports.DEFAULT_PROMPT_LABEL = void 0;
+exports.DEFAULT_PROMPT_LABEL = 'production';
+exports.DEFAULT_PROMPT_CACHE_TTL_SECONDS = 60;

package/dist/LLMPromptClient.errors.d.ts

@@ -0,0 +1,11 @@
+export declare class LLMPromptError extends Error {
+    readonly promptName: string;
+    readonly cause?: unknown | undefined;
+    constructor(message: string, promptName: string, cause?: unknown | undefined);
+}
+export declare class LLMPromptNotFoundError extends LLMPromptError {
+    constructor(promptName: string, cause?: unknown);
+}
+export declare class LLMPromptFetchError extends LLMPromptError {
+    constructor(promptName: string, cause?: unknown);
+}

package/dist/LLMPromptClient.errors.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMPromptFetchError = exports.LLMPromptNotFoundError = exports.LLMPromptError = void 0;
+class LLMPromptError extends Error {
+    constructor(message, promptName, cause) {
+        super(message);
+        this.promptName = promptName;
+        this.cause = cause;
+        this.name = 'LLMPromptError';
+    }
+}
+exports.LLMPromptError = LLMPromptError;
+class LLMPromptNotFoundError extends LLMPromptError {
+    constructor(promptName, cause) {
+        super(`LLM prompt not found: ${promptName}`, promptName, cause);
+        this.name = 'LLMPromptNotFoundError';
+    }
+}
+exports.LLMPromptNotFoundError = LLMPromptNotFoundError;
+class LLMPromptFetchError extends LLMPromptError {
+    constructor(promptName, cause) {
+        super(`Failed to fetch LLM prompt: ${promptName}`, promptName, cause);
+        this.name = 'LLMPromptFetchError';
+    }
+}
+exports.LLMPromptFetchError = LLMPromptFetchError;

package/dist/LLMPromptClient.typedefs.d.ts

@@ -0,0 +1,22 @@
+export declare enum LLMPromptTypes {
+    Text = "text"
+}
+export interface LLMPrompt {
+    name: string;
+    version: number;
+    type: LLMPromptTypes;
+    prompt: string;
+    config: unknown;
+    isFallback: boolean;
+    compile(variables?: Record<string, string>): string;
+}
+export interface GetPromptOptions {
+    version?: number;
+    label?: string;
+    cacheTtlSeconds?: number;
+    fallback?: string;
+}
+export interface LLMPromptClient {
+    getPrompt(name: string, options?: GetPromptOptions): Promise<LLMPrompt>;
+    shutdown(): Promise<void>;
+}

package/dist/LLMPromptClient.typedefs.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMPromptTypes = void 0;
+var LLMPromptTypes;
+(function (LLMPromptTypes) {
+    LLMPromptTypes["Text"] = "text";
+})(LLMPromptTypes || (exports.LLMPromptTypes = LLMPromptTypes = {}));

package/dist/LLMTracer.errors.d.ts

@@ -0,0 +1,4 @@
+export declare class LLMTracerError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}

package/dist/LLMTracer.errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMTracerError = void 0;
+class LLMTracerError extends Error {
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'LLMTracerError';
+    }
+}
+exports.LLMTracerError = LLMTracerError;

package/dist/LLMTracer.typedefs.d.ts

@@ -0,0 +1,45 @@
+import { type LLMPrompt } from './LLMPromptClient.typedefs';
+export interface LLMTraceOptions {
+    name: string;
+    sessionId?: string;
+    userId?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    input?: unknown;
+    output?: unknown;
+}
+export interface LLMTraceUpdateOptions<Input = unknown, Output = unknown> {
+    input?: Input;
+    output?: Output;
+    metadata?: Record<string, unknown>;
+}
+export interface LLMTrace {
+    id: string;
+    getTraceUrl(): string;
+    update<Input = unknown, Output = unknown>(options: LLMTraceUpdateOptions<Input, Output>): void;
+}
+export interface LLMGenerationOptions {
+    name: string;
+    model?: string;
+    modelParameters?: Record<string, string | number | boolean | null>;
+    metadata?: Record<string, unknown>;
+    input?: unknown;
+    output?: unknown;
+    prompt?: LLMPrompt;
+}
+export interface LLMGenerationEndOptions {
+    output?: unknown;
+    metadata?: Record<string, unknown>;
+    usageDetails?: Record<string, number>;
+    costDetails?: Record<string, number>;
+}
+export interface LLMGeneration {
+    id: string;
+    end(options?: LLMGenerationEndOptions): void;
+}
+export interface LLMTracer {
+    createTrace(options: LLMTraceOptions): LLMTrace;
+    createGeneration(trace: LLMTrace, options: LLMGenerationOptions): LLMGeneration;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/LLMTracer.typedefs.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/PromptManagement.constants.d.ts

@@ -0,0 +1,4 @@
+export declare const PROMPT_MANAGEMENT_PROVIDER_FACTORIES: {
+    readonly Langfuse: (options: import(".").LangfuseProviderOptions, logger: import(".").PromptManagementLogger) => import("./PromptManagement.typedefs").PromptManagementBundle;
+    readonly InMemory: (options: import(".").InMemoryProviderOptions, _logger: import(".").PromptManagementLogger) => import("./PromptManagement.typedefs").InMemoryPromptManagementBundle;
+};

package/dist/PromptManagement.constants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPT_MANAGEMENT_PROVIDER_FACTORIES = void 0;
+const PromptManagement_typedefs_1 = require("./PromptManagement.typedefs");
+const InMemory_factory_1 = require("./providers/InMemory/InMemory.factory");
+const Langfuse_factory_1 = require("./providers/Langfuse/Langfuse.factory");
+exports.PROMPT_MANAGEMENT_PROVIDER_FACTORIES = {
+    [PromptManagement_typedefs_1.PromptManagementProviders.Langfuse]: Langfuse_factory_1.createLangfusePromptManagement,
+    [PromptManagement_typedefs_1.PromptManagementProviders.InMemory]: InMemory_factory_1.createInMemoryPromptManagement,
+};

package/dist/PromptManagement.factory.d.ts

@@ -0,0 +1,2 @@
+import { type PromptManagementBundles, type PromptManagementOptions, type PromptManagementProviders } from './PromptManagement.typedefs';
+export declare const createPromptManagement: <Provider extends PromptManagementProviders>(options: PromptManagementOptions<Provider>) => PromptManagementBundles[Provider];

package/dist/PromptManagement.factory.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPromptManagement = void 0;
+const PromptManagement_constants_1 = require("./PromptManagement.constants");
+const logger_1 = require("./utilities/logger");
+const createPromptManagement = (options) => {
+    const providerFactory = PromptManagement_constants_1.PROMPT_MANAGEMENT_PROVIDER_FACTORIES[options.provider];
+    return providerFactory(options.options, options.logger ?? logger_1.NOOP_PROMPT_MANAGEMENT_LOGGER);
+};
+exports.createPromptManagement = createPromptManagement;

package/dist/PromptManagement.typedefs.d.ts

@@ -0,0 +1,35 @@
+import { type LLMPromptClient } from './LLMPromptClient.typedefs';
+import { type LLMTracer } from './LLMTracer.typedefs';
+import { type InMemoryProviderOptions } from './providers/InMemory/InMemory.typedefs';
+import { type InMemoryPromptClient } from './providers/InMemory/InMemoryPrompt.client';
+import { type InMemoryTracer } from './providers/InMemory/InMemoryTracer.client';
+import { type LangfuseProviderOptions } from './providers/Langfuse/Langfuse.typedefs';
+import { type PromptManagementLogger } from './utilities/logger';
+export declare enum PromptManagementProviders {
+    Langfuse = "Langfuse",
+    InMemory = "InMemory"
+}
+export interface PromptManagementProviderOptionsMap {
+    [PromptManagementProviders.Langfuse]: LangfuseProviderOptions;
+    [PromptManagementProviders.InMemory]: InMemoryProviderOptions;
+}
+export interface PromptManagementBundle {
+    promptClient: LLMPromptClient;
+    tracer: LLMTracer;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+export interface InMemoryPromptManagementBundle extends PromptManagementBundle {
+    promptClient: InMemoryPromptClient;
+    tracer: InMemoryTracer;
+}
+export interface PromptManagementBundles {
+    [PromptManagementProviders.Langfuse]: PromptManagementBundle;
+    [PromptManagementProviders.InMemory]: InMemoryPromptManagementBundle;
+}
+export interface PromptManagementOptions<Provider extends PromptManagementProviders> {
+    provider: Provider;
+    options: PromptManagementProviderOptionsMap[Provider];
+    logger?: PromptManagementLogger;
+}
+export type PromptManagementProviderFactory<Provider extends PromptManagementProviders> = (options: PromptManagementProviderOptionsMap[Provider], logger: PromptManagementLogger) => PromptManagementBundles[Provider];

package/dist/PromptManagement.typedefs.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptManagementProviders = void 0;
+var PromptManagementProviders;
+(function (PromptManagementProviders) {
+    PromptManagementProviders["Langfuse"] = "Langfuse";
+    PromptManagementProviders["InMemory"] = "InMemory";
+})(PromptManagementProviders || (exports.PromptManagementProviders = PromptManagementProviders = {}));

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from './LLMPromptClient.typedefs';
+export * from './LLMPromptClient.constants';
+export * from './LLMPromptClient.errors';
+export * from './LLMTracer.typedefs';
+export * from './LLMTracer.errors';
+export * from './PromptManagement.typedefs';
+export * from './PromptManagement.factory';
+export * from './providers/Langfuse/Langfuse.typedefs';
+export * from './providers/InMemory/InMemory.typedefs';
+export * from './providers/InMemory/InMemoryPrompt.client';
+export * from './providers/InMemory/InMemoryTracer.client';
+export * from './utilities/logger';
+export * from './utilities/template';
+export * from './utilities/usageDetails';

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./LLMPromptClient.typedefs"), exports);
+__exportStar(require("./LLMPromptClient.constants"), exports);
+__exportStar(require("./LLMPromptClient.errors"), exports);
+__exportStar(require("./LLMTracer.typedefs"), exports);
+__exportStar(require("./LLMTracer.errors"), exports);
+__exportStar(require("./PromptManagement.typedefs"), exports);
+__exportStar(require("./PromptManagement.factory"), exports);
+__exportStar(require("./providers/Langfuse/Langfuse.typedefs"), exports);
+__exportStar(require("./providers/InMemory/InMemory.typedefs"), exports);
+__exportStar(require("./providers/InMemory/InMemoryPrompt.client"), exports);
+__exportStar(require("./providers/InMemory/InMemoryTracer.client"), exports);
+__exportStar(require("./utilities/logger"), exports);
+__exportStar(require("./utilities/template"), exports);
+__exportStar(require("./utilities/usageDetails"), exports);

package/dist/providers/InMemory/InMemory.factory.d.ts

@@ -0,0 +1,4 @@
+import { type InMemoryPromptManagementBundle } from '../../PromptManagement.typedefs';
+import { type InMemoryProviderOptions } from '../../providers/InMemory/InMemory.typedefs';
+import { type PromptManagementLogger } from '../../utilities/logger';
+export declare const createInMemoryPromptManagement: (options: InMemoryProviderOptions, _logger: PromptManagementLogger) => InMemoryPromptManagementBundle;

package/dist/providers/InMemory/InMemory.factory.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInMemoryPromptManagement = void 0;
+const InMemoryPrompt_client_1 = require("../../providers/InMemory/InMemoryPrompt.client");
+const InMemoryTracer_client_1 = require("../../providers/InMemory/InMemoryTracer.client");
+const createInMemoryPromptManagement = (options, _logger) => {
+    const promptClient = new InMemoryPrompt_client_1.InMemoryPromptClient(options);
+    const tracer = new InMemoryTracer_client_1.InMemoryTracer();
+    return {
+        promptClient,
+        tracer,
+        flush: () => tracer.flush(),
+        shutdown: async () => {
+            await promptClient.shutdown();
+            await tracer.shutdown();
+        },
+    };
+};
+exports.createInMemoryPromptManagement = createInMemoryPromptManagement;

package/dist/providers/InMemory/InMemory.typedefs.d.ts

@@ -0,0 +1,26 @@
+import { type LLMGenerationEndOptions, type LLMGenerationOptions, type LLMTraceOptions, type LLMTraceUpdateOptions } from '../../LLMTracer.typedefs';
+export declare enum InMemoryMissingPromptBehaviors {
+    Throw = "Throw",
+    GenerateStub = "GenerateStub"
+}
+export interface InMemorySeedPrompt {
+    prompt: string;
+    version?: number;
+    config?: unknown;
+}
+export interface InMemoryProviderOptions {
+    prompts?: Record<string, InMemorySeedPrompt>;
+    missingPromptBehavior?: InMemoryMissingPromptBehaviors;
+}
+export interface InMemoryRecordedTrace {
+    id: string;
+    options: LLMTraceOptions;
+    updates: LLMTraceUpdateOptions[];
+}
+export interface InMemoryRecordedGeneration {
+    id: string;
+    traceId: string;
+    options: LLMGenerationOptions;
+    endOptions: LLMGenerationEndOptions | null;
+    isEnded: boolean;
+}

package/dist/providers/InMemory/InMemory.typedefs.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryMissingPromptBehaviors = void 0;
+var InMemoryMissingPromptBehaviors;
+(function (InMemoryMissingPromptBehaviors) {
+    InMemoryMissingPromptBehaviors["Throw"] = "Throw";
+    InMemoryMissingPromptBehaviors["GenerateStub"] = "GenerateStub";
+})(InMemoryMissingPromptBehaviors || (exports.InMemoryMissingPromptBehaviors = InMemoryMissingPromptBehaviors = {}));

package/dist/providers/InMemory/InMemoryPrompt.client.d.ts

@@ -0,0 +1,13 @@
+import { type GetPromptOptions, type LLMPrompt, type LLMPromptClient } from '../../LLMPromptClient.typedefs';
+import { type InMemoryProviderOptions, type InMemorySeedPrompt } from '../../providers/InMemory/InMemory.typedefs';
+export declare class InMemoryPromptClient implements LLMPromptClient {
+    private readonly prompts;
+    private readonly missingPromptBehavior;
+    constructor(options: InMemoryProviderOptions);
+    getPrompt(name: string, options?: GetPromptOptions): Promise<LLMPrompt>;
+    shutdown(): Promise<void>;
+    setPrompt(name: string, seedPrompt: InMemorySeedPrompt): void;
+    clear(): void;
+    private buildPrompt;
+    private buildFallbackPrompt;
+}

package/dist/providers/InMemory/InMemoryPrompt.client.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryPromptClient = void 0;
+const LLMPromptClient_typedefs_1 = require("../../LLMPromptClient.typedefs");
+const LLMPromptClient_errors_1 = require("../../LLMPromptClient.errors");
+const InMemory_typedefs_1 = require("../../providers/InMemory/InMemory.typedefs");
+const template_1 = require("../../utilities/template");
+const DEFAULT_SEED_PROMPT_VERSION = 1;
+const FALLBACK_PROMPT_VERSION = 0;
+class InMemoryPromptClient {
+    constructor(options) {
+        this.prompts = new Map(Object.entries(options.prompts ?? {}));
+        this.missingPromptBehavior = options.missingPromptBehavior
+            ?? InMemory_typedefs_1.InMemoryMissingPromptBehaviors.Throw;
+    }
+    async getPrompt(name, options) {
+        const seedPrompt = this.prompts.get(name);
+        if (seedPrompt) {
+            return this.buildPrompt(name, seedPrompt);
+        }
+        if (options?.fallback !== undefined) {
+            return this.buildFallbackPrompt(name, options.fallback);
+        }
+        if (this.missingPromptBehavior === InMemory_typedefs_1.InMemoryMissingPromptBehaviors.GenerateStub) {
+            return this.buildPrompt(name, { prompt: `Mock prompt for ${name}` });
+        }
+        throw new LLMPromptClient_errors_1.LLMPromptNotFoundError(name);
+    }
+    shutdown() {
+        return Promise.resolve();
+    }
+    setPrompt(name, seedPrompt) {
+        this.prompts.set(name, seedPrompt);
+    }
+    clear() {
+        this.prompts.clear();
+    }
+    buildPrompt(name, seedPrompt) {
+        return {
+            name,
+            version: seedPrompt.version ?? DEFAULT_SEED_PROMPT_VERSION,
+            type: LLMPromptClient_typedefs_1.LLMPromptTypes.Text,
+            prompt: seedPrompt.prompt,
+            config: seedPrompt.config ?? {},
+            isFallback: false,
+            compile: (variables) => (0, template_1.compileTemplateVariables)(seedPrompt.prompt, variables),
+        };
+    }
+    buildFallbackPrompt(name, fallback) {
+        return {
+            name,
+            version: FALLBACK_PROMPT_VERSION,
+            type: LLMPromptClient_typedefs_1.LLMPromptTypes.Text,
+            prompt: fallback,
+            config: {},
+            isFallback: true,
+            compile: (variables) => (0, template_1.compileTemplateVariables)(fallback, variables),
+        };
+    }
+}
+exports.InMemoryPromptClient = InMemoryPromptClient;