CHORE: Added more tests for caching and the openai provider

Author: PredictabilityAtScale

src/index.ts

@@ -227,7 +227,9 @@ export class PromptOpsKit {
     }
 
     const adapter = getAdapter(options.provider);
-    const validation = adapter.validate(resolved);
+    const validation = adapter.validate(resolved, {
+      openaiResponses: options.openaiResponses,
+    });
 
     if (!validation.valid) {
       throw new Error(

tests/cache.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp, rm, unlink, utimes, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { PromptCache } from '../src/cache.js';
@@ -36,4 +36,51 @@ describe('PromptCache', () => {
     expect(cache.get(fileB)).toBeUndefined();
     expect(cache.get(fileC)).toBe('asset-c');
   });
-});
+
+  it('invalidates an entry when the file mtime changes', async () => {
+    const file = join(tmpDir, 'changed.md');
+    await writeFile(file, 'original');
+
+    const cache = new PromptCache<string>(2);
+    cache.set(file, 'asset');
+
+    expect(cache.get(file)).toBe('asset');
+
+    const future = new Date(Date.now() + 10_000);
+    await utimes(file, future, future);
+
+    expect(cache.get(file)).toBeUndefined();
+    expect(cache.size).toBe(0);
+  });
+
+  it('invalidates an entry when the file is deleted', async () => {
+    const file = join(tmpDir, 'deleted.md');
+    await writeFile(file, 'content');
+
+    const cache = new PromptCache<string>(2);
+    cache.set(file, 'asset');
+
+    await unlink(file);
+
+    expect(cache.get(file)).toBeUndefined();
+    expect(cache.size).toBe(0);
+  });
+
+  it('clears all entries', async () => {
+    const fileA = join(tmpDir, 'clear-a.md');
+    const fileB = join(tmpDir, 'clear-b.md');
+
+    await writeFile(fileA, 'A');
+    await writeFile(fileB, 'B');
+
+    const cache = new PromptCache<string>(2);
+    cache.set(fileA, 'asset-a');
+    cache.set(fileB, 'asset-b');
+
+    cache.clear();
+
+    expect(cache.size).toBe(0);
+    expect(cache.get(fileA)).toBeUndefined();
+    expect(cache.get(fileB)).toBeUndefined();
+  });
+});

tests/providers.test.ts

@@ -479,6 +479,97 @@ describe('OpenAI Responses adapter', () => {
     );
   });
 
+  it('reports Responses-specific validation warnings and model errors', () => {
+    const validation = openaiResponsesAdapter.validate({
+      ...baseAsset,
+      model: undefined,
+      reasoning: { budget_tokens: 1000 },
+      response: {
+        schema: {
+          type: 'object',
+          properties: {
+            answer: { type: 'string' },
+          },
+        },
+      },
+    });
+
+    expect(validation.valid).toBe(false);
+    expect(validation.errors).toContain('OpenAI Responses adapter requires a model to be specified.');
+    expect(validation.warnings).toContain(
+      'OpenAI Responses uses reasoning.effort, not budget_tokens. budget_tokens will be ignored.',
+    );
+    expect(validation.warnings).toContain(
+      'OpenAI Responses response.schema requires response.format: json. schema will still be applied as JSON schema output.',
+    );
+  });
+
+  it('renders default schema names, non-strict schemas, unknown tool stubs, and conversation ids', () => {
+    const result = openaiResponsesAdapter.render(
+      {
+        ...baseAsset,
+        response: {
+          format: 'json',
+          schema_strict: false,
+          schema: {
+            type: 'object',
+            properties: {
+              answer: { type: 'string' },
+            },
+          },
+        },
+        tools: ['lookup_customer'],
+      },
+      {
+        variables: { name: 'World' },
+        openaiResponses: {
+          conversation: 'conv_456',
+        },
+      },
+    );
+
+    expect(result.body.conversation).toBe('conv_456');
+    expect(result.body.text).toEqual({
+      format: {
+        type: 'json_schema',
+        name: 'test_response',
+        schema: {
+          type: 'object',
+          properties: {
+            answer: { type: 'string' },
+          },
+        },
+        strict: false,
+      },
+    });
+    expect(result.body.tools).toEqual([{ type: 'function', name: 'lookup_customer' }]);
+  });
+
+  it('rejects invalid Responses runtime options through PromptOpsKit.renderPrompt', async () => {
+    const kit = createPromptOpsKit({ sourceDir: '.', cache: false });
+
+    await expect(
+      kit.renderPrompt({
+        provider: 'openai-responses',
+        source: [
+          '---',
+          'id: inline-responses',
+          'provider: openai-responses',
+          'model: gpt-5.4',
+          '---',
+          '',
+          '# Prompt template',
+          '',
+          'Hello.',
+        ].join('\n'),
+        openaiResponses: {
+          previous_response_id: 'resp_123',
+          conversation: 'conv_456',
+        },
+      }),
+    ).rejects.toThrow('OpenAI Responses options "conversation" and "previous_response_id" cannot both be set.');
+  });
+
   it('includes history messages as input items', () => {
     const result = openaiResponsesAdapter.render(baseAsset, {
       variables: { name: 'World' },