@mate-academy/prompt-client 1.0.0 → 2.0.0

package/README.md

@@ -1,18 +1,20 @@
 # @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.
+Provider-agnostic LLM **prompt management** client. Consumers code against
+one stable interface — `LLMPromptClient` (fetch + compile text and chat
+prompts, caching, fallbacks, a codegen-facing prompt catalog) — 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.
+- **`Langfuse`** — the real provider, built on `@langfuse/client` v5.
+- **`InMemory`** — a deterministic test double: seedable text and chat
+  prompts. Use it in unit/integration tests instead of hand-rolled mocks.
+
+Tracing moved out of this package. `@mate-academy/llm-tracer` now hosts the
+Langfuse tracer surface (traces, generations, usage/cost details); this
+package stays prompts-only.
 
 ## Install
 
@@ -20,6 +22,28 @@ Providers:
 npm install @mate-academy/prompt-client
 ```
 
+## Migrating from 1.x
+
+2.0.0 is a breaking release: the entire tracer surface was removed from this
+package and moved to `@mate-academy/llm-tracer`. Update imports as follows:
+
+| Removed from `prompt-client` | New home |
+|---|---|
+| `LLMTracer`, `LLMTrace`, `LLMGeneration` | `@mate-academy/llm-tracer` |
+| `LLMTraceOptions`, `LLMTraceUpdateOptions` | `@mate-academy/llm-tracer` |
+| `LLMGenerationOptions`, `LLMGenerationEndOptions` | `@mate-academy/llm-tracer` |
+| `LLMTracerError` | `@mate-academy/llm-tracer` |
+| `InMemoryTracer`, `InMemoryRecordedTrace`, `InMemoryRecordedGeneration` | `@mate-academy/llm-tracer` |
+| `usageToUsageDetails`, `costToCostDetails`, `LLMUsageInput`, `LLMCostInput` | `@mate-academy/llm-tracer` |
+| `PromptManagementBundle.tracer` / `.flush()` | `@mate-academy/llm-tracer`'s own bundle |
+| `LangfuseProviderOptions.flushAt` / `.flushIntervalMs` | `@mate-academy/llm-tracer`'s own provider options |
+
+`getPrompt(name, options?)` itself is unchanged and byte-identical to 1.x —
+only the surrounding bundle shape and the SDK underneath changed. Existing
+1.x consumers (`api/src/gateways/PromptManagement/`,
+`api/src/modules/salesQa/`, `serverless/services/sdrChatbot`) are unaffected
+and keep running on the published 1.x line until they migrate.
+
 ## Quick start
 
 ```typescript
@@ -48,13 +72,12 @@ const instructions = prompt.compile({ leadName: 'Maria' });
 
 | 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` | `LLMPromptClient` — `getPrompt`, `getChatPrompt`, `listPrompts`, `getPromptRecord`, `shutdown()` |
+| `shutdown()` | Stop the underlying provider client |
 
-`promptClient.shutdown()` and `tracer.shutdown()` stop the same shared client;
-prefer `bundle.shutdown()`.
+There is no `flush()` on this bundle — a prompts-only client buffers
+nothing. `promptClient.shutdown()` and `bundle.shutdown()` stop the same
+shared client; prefer `bundle.shutdown()`.
 
 ## Prompts
 
@@ -77,50 +100,67 @@ 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`.
+- `LLMPromptFetchError` — infrastructure failure (network/HTTP) or a
+  wrong-shape prompt (a chat prompt fetched via `getPrompt`, or vice versa).
+  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
+### Chat prompts
+
+`getChatPrompt` is the additive counterpart of `getPrompt` for role-tagged
+message prompts:
 
 ```typescript
-const trace = tracer.createTrace({
-  name: 'conversation-turn',
-  sessionId: chatId,      // groups turns of one conversation in Langfuse
-  userId,
-  tags: ['sdr'],
-  input: inboundMessage,
+const prompt = await promptClient.getChatPrompt('chatAgent.conversation', {
+  label: 'production',
+  fallback: [
+    { role: LLMPromptMessageRoles.System, content: 'You are a helpful agent.' },
+  ],
 });
 
-const generation = tracer.createGeneration(trace, {
-  name: 'chat-completion',
-  model: modelName,
-  input: messages,
-  prompt,                 // links the generation to the Langfuse prompt version
-});
+prompt.messages;    // LLMPromptMessage[] — { role, content }
+prompt.compile({ leadName: 'Maria' }); // substitutes {{var}} in each message's content
+```
+
+Fallback is an `LLMPromptMessage[]` instead of a string, with the same
+never-throw / `version: 0` / `isFallback: true` semantics as `getPrompt`.
+Langfuse placeholder entries and messages with an unrecognized role are
+silently skipped from `messages`/`compile()`, with a warning logged so the
+gap is visible without breaking the call.
 
-generation.end({
-  output: completion,
-  usageDetails: usageToUsageDetails(response.usage),
-  costDetails: costToCostDetails(response.cost),
+### Catalog (for codegen)
+
+`listPrompts` and `getPromptRecord` expose the raw prompt catalog for
+Langfuse-prompt codegen (the gateway's `generateSnapshot`):
+
+```typescript
+const { promptNames, page, totalPages } = await promptClient.listPrompts({
+  label: 'production',
+  page: 1,      // default 1
+  pageSize: 100, // default 100
 });
 
-trace.update({ output: decision });
+const record = await promptClient.getPromptRecord('chatAgent.instructions', {
+  label: 'production',
+});
+// record.type === LLMPromptTypes.Text | LLMPromptTypes.Chat
 ```
 
-`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.
+Both methods are uncached and never fall back — they **throw** on failure
+(`LLMPromptListError` for `listPrompts`, `LLMPromptNotFoundError` /
+`LLMPromptFetchError` for `getPromptRecord`) so a codegen run can fail loudly
+in CI and fall back to the last-committed snapshot artifact instead of
+silently baking in stale or partial data.
 
 ## 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
+enum, and pass the project at the call site. Stop every live bundle on
 SIGTERM.
 
 ```typescript
@@ -147,15 +187,15 @@ const getPromptManagement = (
 };
 
 // at a call site — pick the project you need:
-const { promptClient, tracer } = getPromptManagement(LangfuseProject.SalesQA);
+const { promptClient } = 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.
+Memoizing per project is correctness, not caching: each bundle owns a live
+SDK client, 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
@@ -163,10 +203,8 @@ Typed error handling keeps existing semantics: catch
 
 ## 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:
+Create the bundle at module scope so it stays warm across invocations, and
+use per-prompt fallbacks so a Langfuse outage can never break a turn:
 
 ```typescript
 const promptManagement = createPromptManagement({
@@ -177,21 +215,16 @@ const promptManagement = createPromptManagement({
       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();
-  }
+  const prompt = await promptManagement.promptClient.getPrompt(
+    PromptKey.ChatAgentInstructions,
+    { fallback: FALLBACKS[PromptKey.ChatAgentInstructions] },
+  );
+  // ... run the turn
 };
 ```
 
@@ -204,30 +237,48 @@ const promptManagement = createPromptManagement({
     prompts: {
       'chatAgent.instructions': { prompt: 'Reply to {{leadName}}', version: 3 },
     },
+    chatPrompts: {
+      'chatAgent.conversation': {
+        messages: [{ role: LLMPromptMessageRoles.System, content: 'Reply to {{leadName}}' }],
+      },
+    },
     // GenerateStub: unknown names resolve to `Mock prompt for <name>`
     missingPromptBehavior: InMemoryMissingPromptBehaviors.GenerateStub,
   },
 });
 
-// The InMemory bundle is typed with the concrete classes:
+// The InMemory bundle is typed with the concrete class:
 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();
+promptManagement.promptClient.setChatPrompt('closing.chat', {
+  messages: [{ role: LLMPromptMessageRoles.System, content: 'Bye!' }],
+});
 ```
 
+`listPrompts` / `getPromptRecord` on the InMemory client read only the
+seeded prompts (labels default to `['production']`); `missingPromptBehavior`
+never applies to `getPromptRecord` — a missing seed always throws
+`LLMPromptNotFoundError`, since the catalog must report seeded truth for
+codegen tests.
+
 ## 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.
+- Built on `@langfuse/client` v5. Error classification is **structural,
+  never `instanceof`**: v5's Fern-generated errors never assign a
+  distinctive `error.name` (every one reports `'Error'` at runtime), so
+  classification duck-types on `error.statusCode` — `404` maps to
+  `LLMPromptNotFoundError`, everything else to `LLMPromptFetchError`. This
+  survives a duplicate SDK copy in a webpack/serverless bundle, where
+  `instanceof` would silently fail.
+- **Behavior change vs 1.x**: a non-404 HTTP error (5xx, 401, 403) on the
+  prompt endpoint now correctly classifies as `LLMPromptFetchError` instead
+  of falling into the default `LLMPromptNotFoundError` bucket.
+- The SDK's `type: 'text' | 'chat'` option on `prompt.get` is a compile-time
+  overload discriminator only — the runtime still returns whatever prompt
+  the server has. `getPrompt` therefore still rejects a chat prompt (and
+  `getChatPrompt` a text prompt) with `LLMPromptFetchError`.
 - No SDK types leak through the public API; a future SDK swap stays inside
   this package.
 

package/dist/LLMPromptClient.constants.d.ts

@@ -1,2 +1,4 @@
 export declare const DEFAULT_PROMPT_LABEL = "production";
 export declare const DEFAULT_PROMPT_CACHE_TTL_SECONDS = 60;
+export declare const DEFAULT_PROMPT_LIST_PAGE = 1;
+export declare const DEFAULT_PROMPT_LIST_PAGE_SIZE = 100;

package/dist/LLMPromptClient.constants.js

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

package/dist/LLMPromptClient.errors.d.ts

@@ -9,3 +9,8 @@ export declare class LLMPromptNotFoundError extends LLMPromptError {
 export declare class LLMPromptFetchError extends LLMPromptError {
     constructor(promptName: string, cause?: unknown);
 }
+export declare class LLMPromptListError extends Error {
+    readonly label: string;
+    readonly cause?: unknown | undefined;
+    constructor(label: string, cause?: unknown | undefined);
+}

package/dist/LLMPromptClient.errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLMPromptFetchError = exports.LLMPromptNotFoundError = exports.LLMPromptError = void 0;
+exports.LLMPromptListError = exports.LLMPromptFetchError = exports.LLMPromptNotFoundError = exports.LLMPromptError = void 0;
 class LLMPromptError extends Error {
     constructor(message, promptName, cause) {
         super(message);
@@ -24,3 +24,12 @@ class LLMPromptFetchError extends LLMPromptError {
     }
 }
 exports.LLMPromptFetchError = LLMPromptFetchError;
+class LLMPromptListError extends Error {
+    constructor(label, cause) {
+        super(`Failed to list LLM prompts for label: ${label}`);
+        this.label = label;
+        this.cause = cause;
+        this.name = 'LLMPromptListError';
+    }
+}
+exports.LLMPromptListError = LLMPromptListError;

package/dist/LLMPromptClient.typedefs.d.ts

@@ -1,5 +1,15 @@
 export declare enum LLMPromptTypes {
-    Text = "text"
+    Text = "text",
+    Chat = "chat"
+}
+export declare enum LLMPromptMessageRoles {
+    System = "system",
+    User = "user",
+    Assistant = "assistant"
+}
+export interface LLMPromptMessage {
+    role: LLMPromptMessageRoles;
+    content: string;
 }
 export interface LLMPrompt {
     name: string;
@@ -10,13 +20,88 @@ export interface LLMPrompt {
     isFallback: boolean;
     compile(variables?: Record<string, string>): string;
 }
-export interface GetPromptOptions {
+/**
+ * A chat-shaped prompt: role-tagged messages instead of a single text
+ * template. Returned by `getChatPrompt`, the additive counterpart of
+ * `getPrompt` (which stays text-only).
+ */
+export interface LLMChatPrompt {
+    name: string;
+    version: number;
+    type: LLMPromptTypes;
+    messages: LLMPromptMessage[];
+    config: unknown;
+    isFallback: boolean;
+    compile(variables?: Record<string, string>): LLMPromptMessage[];
+}
+interface GetPromptCommonOptions {
+    cacheTtlSeconds?: number;
+    fallback?: string;
+}
+interface GetPromptByVersionOptions extends GetPromptCommonOptions {
     version?: number;
+    label?: never;
+}
+interface GetPromptByLabelOptions extends GetPromptCommonOptions {
+    version?: never;
     label?: string;
+}
+export type GetPromptOptions = GetPromptByVersionOptions | GetPromptByLabelOptions;
+interface GetChatPromptCommonOptions {
     cacheTtlSeconds?: number;
-    fallback?: string;
+    fallback?: LLMPromptMessage[];
+}
+interface GetChatPromptByVersionOptions extends GetChatPromptCommonOptions {
+    version?: number;
+    label?: never;
+}
+interface GetChatPromptByLabelOptions extends GetChatPromptCommonOptions {
+    version?: never;
+    label?: string;
+}
+export type GetChatPromptOptions = GetChatPromptByVersionOptions | GetChatPromptByLabelOptions;
+export interface ListPromptsOptions {
+    label: string;
+    page?: number;
+    pageSize?: number;
+}
+/**
+ * One page of the prompt catalog: names only (the Langfuse list endpoint
+ * returns metadata without bodies) for codegen to iterate and resolve each
+ * name via `getPromptRecord`.
+ */
+export interface LLMPromptCatalogPage {
+    promptNames: string[];
+    page: number;
+    totalPages: number;
+}
+export interface GetPromptRecordOptions {
+    label: string;
+}
+interface LLMPromptRecordBase {
+    name: string;
+    version: number;
+    labels: string[];
+    config: unknown;
+}
+export interface LLMTextPromptRecord extends LLMPromptRecordBase {
+    type: LLMPromptTypes.Text;
+    text: string;
+}
+export interface LLMChatPromptRecord extends LLMPromptRecordBase {
+    type: LLMPromptTypes.Chat;
+    messages: LLMPromptMessage[];
 }
+/**
+ * Uncached, no-fallback raw prompt record — the catalog truth codegen reads
+ * to regenerate the typed prompt registry. Never used on the hot path.
+ */
+export type LLMPromptRecord = LLMTextPromptRecord | LLMChatPromptRecord;
 export interface LLMPromptClient {
     getPrompt(name: string, options?: GetPromptOptions): Promise<LLMPrompt>;
+    getChatPrompt(name: string, options?: GetChatPromptOptions): Promise<LLMChatPrompt>;
+    listPrompts(options: ListPromptsOptions): Promise<LLMPromptCatalogPage>;
+    getPromptRecord(name: string, options: GetPromptRecordOptions): Promise<LLMPromptRecord>;
     shutdown(): Promise<void>;
 }
+export {};

package/dist/LLMPromptClient.typedefs.js

@@ -1,7 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLMPromptTypes = void 0;
+exports.LLMPromptMessageRoles = exports.LLMPromptTypes = void 0;
 var LLMPromptTypes;
 (function (LLMPromptTypes) {
     LLMPromptTypes["Text"] = "text";
+    LLMPromptTypes["Chat"] = "chat";
 })(LLMPromptTypes || (exports.LLMPromptTypes = LLMPromptTypes = {}));
+var LLMPromptMessageRoles;
+(function (LLMPromptMessageRoles) {
+    LLMPromptMessageRoles["System"] = "system";
+    LLMPromptMessageRoles["User"] = "user";
+    LLMPromptMessageRoles["Assistant"] = "assistant";
+})(LLMPromptMessageRoles || (exports.LLMPromptMessageRoles = LLMPromptMessageRoles = {}));

package/dist/PromptManagement.typedefs.d.ts

@@ -1,8 +1,6 @@
 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 {
@@ -13,15 +11,18 @@ export interface PromptManagementProviderOptionsMap {
     [PromptManagementProviders.Langfuse]: LangfuseProviderOptions;
     [PromptManagementProviders.InMemory]: InMemoryProviderOptions;
 }
+/**
+ * A prompts-only bundle: one `LLMPromptClient` plus a single `shutdown`
+ * that stops the underlying provider client. No tracer, no `flush` — a
+ * prompts-only client buffers nothing (see `@mate-academy/llm-tracer` for
+ * tracing).
+ */
 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;

package/dist/index.d.ts

@@ -1,14 +1,10 @@
 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

@@ -17,14 +17,10 @@ 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.js

@@ -2,18 +2,11 @@
 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();
-        },
+        shutdown: () => promptClient.shutdown(),
     };
 };
 exports.createInMemoryPromptManagement = createInMemoryPromptManagement;

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

@@ -1,4 +1,4 @@
-import { type LLMGenerationEndOptions, type LLMGenerationOptions, type LLMTraceOptions, type LLMTraceUpdateOptions } from '../../LLMTracer.typedefs';
+import { type LLMPromptMessage } from '../../LLMPromptClient.typedefs';
 export declare enum InMemoryMissingPromptBehaviors {
     Throw = "Throw",
     GenerateStub = "GenerateStub"
@@ -7,20 +7,16 @@ export interface InMemorySeedPrompt {
     prompt: string;
     version?: number;
     config?: unknown;
+    labels?: string[];
+}
+export interface InMemorySeedChatPrompt {
+    messages: LLMPromptMessage[];
+    version?: number;
+    config?: unknown;
+    labels?: string[];
 }
 export interface InMemoryProviderOptions {
     prompts?: Record<string, InMemorySeedPrompt>;
+    chatPrompts?: Record<string, InMemorySeedChatPrompt>;
     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/InMemoryPrompt.client.d.ts

@@ -1,13 +1,25 @@
-import { type GetPromptOptions, type LLMPrompt, type LLMPromptClient } from '../../LLMPromptClient.typedefs';
-import { type InMemoryProviderOptions, type InMemorySeedPrompt } from '../../providers/InMemory/InMemory.typedefs';
+import { type GetChatPromptOptions, type GetPromptOptions, type GetPromptRecordOptions, type LLMChatPrompt, type LLMPrompt, type LLMPromptCatalogPage, type LLMPromptClient, type LLMPromptRecord, type ListPromptsOptions } from '../../LLMPromptClient.typedefs';
+import { type InMemoryProviderOptions, type InMemorySeedChatPrompt, type InMemorySeedPrompt } from '../../providers/InMemory/InMemory.typedefs';
 export declare class InMemoryPromptClient implements LLMPromptClient {
     private readonly prompts;
+    private readonly chatPrompts;
     private readonly missingPromptBehavior;
     constructor(options: InMemoryProviderOptions);
     getPrompt(name: string, options?: GetPromptOptions): Promise<LLMPrompt>;
+    getChatPrompt(name: string, options?: GetChatPromptOptions): Promise<LLMChatPrompt>;
+    listPrompts(options: ListPromptsOptions): Promise<LLMPromptCatalogPage>;
+    getPromptRecord(name: string, options: GetPromptRecordOptions): Promise<LLMPromptRecord>;
     shutdown(): Promise<void>;
     setPrompt(name: string, seedPrompt: InMemorySeedPrompt): void;
+    setChatPrompt(name: string, seedChatPrompt: InMemorySeedChatPrompt): void;
     clear(): void;
     private buildPrompt;
     private buildFallbackPrompt;
+    private buildChatPrompt;
+    private buildFallbackChatPrompt;
+    private compileMessages;
+    private collectMatchingNames;
+    private matchesLabel;
+    private buildTextPromptRecord;
+    private buildChatPromptRecord;
 }