@robota-sdk/agent-provider-openai 3.0.0-beta.63 → 3.0.0-beta.81

package/dist/node/payload-logger-BaW0K8yI.d.cts

@@ -0,0 +1,61 @@
+import { ILogger } from "@robota-sdk/agent-core";
+import OpenAI from "openai";
+//#region src/openai/types/api-types.d.ts
+/**
+ * Payload logging data structure
+ */
+interface IOpenAILogData {
+  model: string;
+  messagesCount: number;
+  hasTools: boolean;
+  temperature?: number | undefined;
+  maxTokens?: number | undefined;
+  timestamp: string;
+  requestId?: string | undefined;
+}
+//#endregion
+//#region src/openai/interfaces/payload-logger.d.ts
+/**
+ * IPayloadLogger interface for logging OpenAI API payloads
+ *
+ * This interface provides a contract for different logging implementations:
+ * - FilePayloadLogger: Node.js file-based logging
+ * - ConsolePayloadLogger: Browser console-based logging
+ * - Custom implementations: User-defined loggers
+ */
+interface IPayloadLogger {
+  /**
+   * Check if logging is enabled
+   * @returns true if logging is active, false otherwise
+   */
+  isEnabled(): boolean;
+  /**
+   * Log API payload data
+   * @param payload - The API request/response payload data
+   * @param type - Type of operation ('chat' or 'stream')
+   */
+  logPayload(payload: IOpenAILogData, type: 'chat' | 'stream'): Promise<void>;
+}
+/**
+ * Configuration options for payload loggers
+ */
+interface IPayloadLoggerOptions {
+  /**
+   * Whether logging is enabled
+   * @defaultValue true
+   */
+  enabled?: boolean;
+  /**
+   * Include timestamp in log entries
+   * @defaultValue true
+   */
+  includeTimestamp?: boolean;
+  /**
+   * Logger instance for console output
+   * @defaultValue SilentLogger
+   */
+  logger?: ILogger;
+}
+//#endregion
+export { IPayloadLoggerOptions as n, IOpenAILogData as r, IPayloadLogger as t };
+//# sourceMappingURL=payload-logger-BaW0K8yI.d.cts.map

package/dist/node/payload-logger-BaW0K8yI.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload-logger-BaW0K8yI.d.cts","names":[],"sources":["../../src/openai/types/api-types.ts","../../src/openai/interfaces/payload-logger.ts"],"mappings":";;;;;;UAwGiB;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;UCpGe;;;;;EAKf;;;;;;EAOA,WAAW,SAAS,gBAAgB,0BAA0B;;;;;UAM/C;;;;;EAKf;;;;;EAMA;;;;;EAMA,SAAS"}

package/dist/node/payload-logger-BaW0K8yI.d.ts

@@ -0,0 +1,61 @@
+import { ILogger } from "@robota-sdk/agent-core";
+import OpenAI from "openai";
+//#region src/openai/types/api-types.d.ts
+/**
+ * Payload logging data structure
+ */
+interface IOpenAILogData {
+  model: string;
+  messagesCount: number;
+  hasTools: boolean;
+  temperature?: number | undefined;
+  maxTokens?: number | undefined;
+  timestamp: string;
+  requestId?: string | undefined;
+}
+//#endregion
+//#region src/openai/interfaces/payload-logger.d.ts
+/**
+ * IPayloadLogger interface for logging OpenAI API payloads
+ *
+ * This interface provides a contract for different logging implementations:
+ * - FilePayloadLogger: Node.js file-based logging
+ * - ConsolePayloadLogger: Browser console-based logging
+ * - Custom implementations: User-defined loggers
+ */
+interface IPayloadLogger {
+  /**
+   * Check if logging is enabled
+   * @returns true if logging is active, false otherwise
+   */
+  isEnabled(): boolean;
+  /**
+   * Log API payload data
+   * @param payload - The API request/response payload data
+   * @param type - Type of operation ('chat' or 'stream')
+   */
+  logPayload(payload: IOpenAILogData, type: 'chat' | 'stream'): Promise<void>;
+}
+/**
+ * Configuration options for payload loggers
+ */
+interface IPayloadLoggerOptions {
+  /**
+   * Whether logging is enabled
+   * @defaultValue true
+   */
+  enabled?: boolean;
+  /**
+   * Include timestamp in log entries
+   * @defaultValue true
+   */
+  includeTimestamp?: boolean;
+  /**
+   * Logger instance for console output
+   * @defaultValue SilentLogger
+   */
+  logger?: ILogger;
+}
+//#endregion
+export { IPayloadLoggerOptions as n, IOpenAILogData as r, IPayloadLogger as t };
+//# sourceMappingURL=payload-logger-BaW0K8yI.d.ts.map

package/dist/node/payload-logger-BaW0K8yI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload-logger-BaW0K8yI.d.ts","names":[],"sources":["../../src/openai/types/api-types.ts","../../src/openai/interfaces/payload-logger.ts"],"mappings":";;;;;;UAwGiB;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;UCpGe;;;;;EAKf;;;;;;EAOA,WAAW,SAAS,gBAAgB,0BAA0B;;;;;UAM/C;;;;;EAKf;;;;;EAMA;;;;;EAMA,SAAS"}

package/dist/node/rolldown-runtime-CMqjfN_6.cjs

@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,a)=>(a=n==null?{}:e(i(n)),o(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return s}});

package/package.json

@@ -1,113 +1,91 @@
 {
   "name": "@robota-sdk/agent-provider-openai",
-  "version": "3.0.0-beta.63",
-  "description": "OpenAI integration for Robota SDK using the Responses API, structured outputs, streaming, and tool calling",
+  "version": "3.0.0-beta.81",
+  "description": "OpenAI provider implementation for Robota SDK",
   "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
   "main": "dist/node/index.js",
-  "module": "dist/node/index.mjs",
   "types": "dist/node/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/node/index.d.ts",
       "source": "./src/index.ts",
       "node": {
-        "import": "./dist/node/index.js",
-        "require": "./dist/node/index.cjs"
-      },
-      "browser": {
-        "import": "./dist/browser/index.js"
+        "import": {
+          "types": "./dist/node/index.d.ts",
+          "default": "./dist/node/index.js"
+        },
+        "require": {
+          "types": "./dist/node/index.d.cts",
+          "default": "./dist/node/index.cjs"
+        }
       },
       "default": {
-        "import": "./dist/node/index.js",
-        "require": "./dist/node/index.cjs"
+        "import": {
+          "types": "./dist/node/index.d.ts",
+          "default": "./dist/node/index.js"
+        },
+        "require": {
+          "types": "./dist/node/index.d.cts",
+          "default": "./dist/node/index.cjs"
+        }
       }
     },
-    "./loggers/file": {
-      "types": "./dist/loggers/file.d.ts",
-      "import": "./dist/loggers/file.js",
-      "require": "./dist/loggers/file.cjs"
-    },
-    "./loggers/console": {
-      "types": "./dist/loggers/console.d.ts",
-      "import": "./dist/loggers/console.js",
-      "require": "./dist/loggers/console.cjs"
+    "./loggers": {
+      "source": "./src/openai/loggers/index.ts",
+      "node": {
+        "import": {
+          "types": "./dist/node/loggers/index.d.ts",
+          "default": "./dist/node/loggers/index.js"
+        },
+        "require": {
+          "types": "./dist/node/loggers/index.d.cts",
+          "default": "./dist/node/loggers/index.cjs"
+        }
+      },
+      "default": {
+        "import": {
+          "types": "./dist/node/loggers/index.d.ts",
+          "default": "./dist/node/loggers/index.js"
+        },
+        "require": {
+          "types": "./dist/node/loggers/index.d.cts",
+          "default": "./dist/node/loggers/index.cjs"
+        }
+      }
     }
   },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/woojubb/robota.git",
-    "directory": "packages/agent-provider-openai"
-  },
-  "homepage": "https://robota.io/",
-  "bugs": {
-    "url": "https://github.com/woojubb/robota/issues"
-  },
   "files": [
     "dist",
-    "README.md",
-    "CHANGELOG.md"
-  ],
-  "keywords": [
-    "ai",
-    "agent",
-    "llm",
-    "openai",
-    "gpt",
-    "gpt-4",
-    "responses-api",
-    "structured-outputs",
-    "chatgpt",
-    "function-calling",
-    "typescript",
-    "javascript",
-    "chatbot",
-    "conversational-ai",
-    "artificial-intelligence",
-    "machine-learning",
-    "nlp",
-    "natural-language-processing",
-    "sdk",
-    "library",
-    "tool-integration",
-    "robota",
-    "openai-api",
-    "ai-integration"
+    "src"
   ],
-  "author": "Robota SDK Team",
-  "license": "MIT",
-  "dependencies": {
-    "openai": "^4.98.0",
-    "@robota-sdk/agent-provider-openai-compatible": "3.0.0-beta.63"
-  },
-  "peerDependencies": {
-    "@robota-sdk/agent-core": "3.0.0-beta.63"
-  },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^6.18.0",
-    "@typescript-eslint/parser": "^6.18.0",
-    "eslint": "^8.56.0",
-    "rimraf": "^5.0.5",
-    "tsup": "^8.0.1",
-    "typescript": "^5.3.3",
-    "vitest": "^1.1.0",
-    "@robota-sdk/agent-core": "3.0.0-beta.63"
+    "@types/node": "^22.19.21",
+    "rimraf": "^5.0.10",
+    "tsdown": "^0.22.14",
+    "typescript": "^6.0.3",
+    "vitest": "^3.2.6"
   },
-  "publishConfig": {
-    "access": "public"
+  "license": "AGPL-3.0-only OR LicenseRef-Commercial",
+  "dependencies": {
+    "openai": "^4.104.0",
+    "@robota-sdk/agent-core": "3.0.0-beta.81",
+    "@robota-sdk/agent-provider-openai-compatible": "3.0.0-beta.81"
+  },
+  "volta": {
+    "extends": "../../package.json"
   },
   "scripts": {
-    "build": "tsup",
-    "build:js": "tsup --no-dts",
-    "build:types": "tsup --dts-only",
-    "dev": "tsup --watch",
-    "clean": "rimraf dist",
+    "build": "rimraf dist && tsdown",
+    "build:js": "pnpm run build",
+    "build:types": "pnpm run build",
+    "typecheck": "tsgo --noEmit && tsgo -p tsconfig.examples.json --noEmit",
+    "scenario:verify": "pnpm typecheck",
+    "scenario:verify:tool-schema-projection": "pnpm exec tsx --conditions=source examples/verify-tool-schema-projection.ts",
     "test": "vitest run --passWithNoTests",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "lint": "eslint src --ext .ts,.tsx",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "lint:fix": "eslint src --ext .ts,.tsx --fix",
-    "scenario:verify": "pnpm --filter @robota-sdk/agent-core build && pnpm exec tsx examples/verify-executor.ts",
-    "scenario:record": "node ../../scripts/harness/record-owner-scenario.mjs --scope packages/agent-provider-openai --output examples/scenarios/executor-verify.record.json -- pnpm scenario:verify"
+    "test:coverage": "vitest run --coverage --passWithNoTests",
+    "lint": "eslint src/ --ext .ts",
+    "clean": "rimraf dist"
   }
 }

package/src/index.ts

@@ -0,0 +1 @@
+export * from './openai/index.js';

package/src/openai/__tests__/endpoint-provenance.test.ts

@@ -0,0 +1,44 @@
+/**
+ * CORE-043 decision (1): the advertised gateway configuration must not report enforcement it has not
+ * got.
+ *
+ * `llms.txt` and `types.ts` advertise `baseURL` for OpenAI-compatible gateways. Setting it also
+ * switches the API surface to `chat-completions` (`resolveApiSurface`), so it is precisely the
+ * configuration where whatever is on the far end is least likely to honour a structured-output
+ * parameter — and the runtime claimed early enforcement on it anyway.
+ *
+ * This provider declares no capability table by choice; nobody has verified one, and inventing one
+ * would be a fabricated claim. It can still answer this question, which is why the endpoint signal is
+ * a separate member rather than a field on the table.
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { OpenAIProvider } from '../provider';
+
+import type { IAIProvider } from '@robota-sdk/agent-core';
+
+describe('CORE-043 — OpenAI endpoint provenance', () => {
+  it('reports the vendor endpoint when no baseURL is configured', () => {
+    const provider = new OpenAIProvider({ apiKey: 'test-key' });
+    expect(provider.endpointIsVendorDefault()).toBe(true);
+  });
+
+  it('reports a gateway when baseURL is configured', () => {
+    const provider = new OpenAIProvider({ apiKey: 'test-key', baseURL: 'https://gateway.test/v1' });
+    expect(provider.endpointIsVendorDefault()).toBe(false);
+  });
+
+  it('still declares no capability table, so the signal cannot depend on one', () => {
+    // If the endpoint signal had been a field on the table, this provider could only report its
+    // endpoint by first inventing capability claims nobody verified. Read through `IAIProvider`
+    // rather than the class: `capabilityTable` is optional on the contract, and the point is that
+    // this provider leaves it unimplemented while still answering the endpoint question.
+    const provider: IAIProvider = new OpenAIProvider({
+      apiKey: 'test-key',
+      baseURL: 'https://gateway.test/v1',
+    });
+    expect(provider.capabilityTable).toBeUndefined();
+    expect(provider.endpointIsVendorDefault?.()).toBe(false);
+  });
+});

package/src/openai/__tests__/provider-errors.test.ts

@@ -0,0 +1,114 @@
+/**
+ * A failed OpenAI call keeps the HTTP status and OpenAI's error type on every API surface, instead of
+ * collapsing into a bare `Error` whose only trace of the status is its message text.
+ */
+
+import { ProviderError, RateLimitError, classifyProviderFailure } from '@robota-sdk/agent-core';
+import { APIConnectionError, APIError, APIUserAbortError } from 'openai';
+import { describe, expect, it, vi } from 'vitest';
+
+import { OpenAIProvider } from '../provider';
+
+import type { TUniversalMessage } from '@robota-sdk/agent-core';
+import type OpenAI from 'openai';
+
+const messages: TUniversalMessage[] = [
+  { id: '1', role: 'user', content: 'hi', state: 'complete', timestamp: new Date() },
+];
+
+function httpError(status: number, type: string): Error {
+  return APIError.generate(status, { error: { type, message: `${type} happened` } }, undefined, {});
+}
+
+function providerWith(apiSurface: 'chat-completions' | 'responses', error: Error): OpenAIProvider {
+  const create = vi.fn().mockRejectedValue(error);
+  const client = { chat: { completions: { create } }, responses: { create } };
+  return new OpenAIProvider({ client: client as unknown as OpenAI, apiSurface });
+}
+
+async function failure(run: () => Promise<unknown>): Promise<Error> {
+  try {
+    await run();
+  } catch (error) {
+    return error as Error;
+  }
+  throw new Error('expected the call to fail');
+}
+
+async function drain(stream: AsyncIterable<TUniversalMessage>): Promise<void> {
+  for await (const chunk of stream) void chunk;
+}
+
+const surfaces = ['chat-completions', 'responses'] as const;
+const statuses: Array<[number, string]> = [
+  [529, 'overloaded_error'],
+  [503, 'server_error'],
+  [500, 'server_error'],
+  [401, 'invalid_api_key'],
+];
+
+describe('OpenAI provider errors', () => {
+  for (const surface of surfaces) {
+    it.each(statuses)(`${surface} chat keeps HTTP %i`, async (status, type) => {
+      const provider = providerWith(surface, httpError(status, type));
+      const error = await failure(() => provider.chat(messages, { model: 'gpt-4o' }));
+      expect(error).toBeInstanceOf(ProviderError);
+      expect((error as ProviderError).status).toBe(status);
+      expect((error as ProviderError).type).toBe(type);
+      expect(error.message).toContain(`${status}`);
+    });
+
+    it(`${surface} chatStream keeps HTTP 503`, async () => {
+      const provider = providerWith(surface, httpError(503, 'server_error'));
+      const error = await failure(() => drain(provider.chatStream(messages, { model: 'gpt-4o' })));
+      expect(error).toBeInstanceOf(ProviderError);
+      expect((error as ProviderError).status).toBe(503);
+    });
+
+    it(`${surface} passes the SDK abort error through unchanged`, async () => {
+      const abort = new APIUserAbortError();
+      const provider = providerWith(surface, abort);
+      const error = await failure(() => provider.chat(messages, { model: 'gpt-4o' }));
+      expect(error).toBe(abort);
+      expect(classifyProviderFailure(error)).toEqual({ switchable: false, reason: 'aborted' });
+    });
+
+    it(`${surface} classifies an SDK connection failure as network`, async () => {
+      const provider = providerWith(
+        surface,
+        new APIConnectionError({
+          message: 'Connection error.',
+          cause: new TypeError('fetch failed'),
+        }),
+      );
+      const error = await failure(() => provider.chat(messages, { model: 'gpt-4o' }));
+      expect(error).toBeInstanceOf(ProviderError);
+      expect(classifyProviderFailure(error)).toEqual({ switchable: false, reason: 'network' });
+    });
+
+    it(`${surface} classifies a 400 model_not_found as model-unavailable`, async () => {
+      const provider = providerWith(
+        surface,
+        APIError.generate(
+          400,
+          {
+            error: { type: 'invalid_request_error', code: 'model_not_found', message: 'no model' },
+          },
+          undefined,
+          {},
+        ),
+      );
+      const error = await failure(() => provider.chat(messages, { model: 'gpt-4o' }));
+      expect(classifyProviderFailure(error)).toEqual({
+        switchable: true,
+        reason: 'model-unavailable',
+      });
+    });
+
+    it(`${surface} chat maps 429 to RateLimitError`, async () => {
+      const provider = providerWith(surface, httpError(429, 'rate_limit_exceeded'));
+      const error = await failure(() => provider.chat(messages, { model: 'gpt-4o' }));
+      expect(error).toBeInstanceOf(RateLimitError);
+    });
+  }
+});

package/src/openai/__tests__/request-format.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+
+import { buildOpenAIChatResponseFormat, mergeChatResponseFormat } from '../openai-request-format';
+
+import type { IOpenAIProviderOptions } from '../types';
+
+const providerOptions: IOpenAIProviderOptions = { apiKey: 'test-key' };
+
+describe('mergeChatResponseFormat (CORE-015)', () => {
+  it('returns provider options untouched when no chat responseFormat is set', () => {
+    expect(mergeChatResponseFormat(providerOptions, undefined)).toBe(providerOptions);
+  });
+
+  it('carries a json_schema chat option with its schema payload into jsonSchema', () => {
+    const schema = {
+      type: 'object',
+      properties: { title: { type: 'string' } },
+      required: ['title'],
+    };
+    const merged = mergeChatResponseFormat(providerOptions, {
+      type: 'json_schema',
+      name: 'report',
+      schema,
+    });
+
+    expect(merged.responseFormat).toBe('json_schema');
+    expect(merged.jsonSchema).toEqual({ name: 'report', schema });
+  });
+
+  it('defaults the schema name when omitted', () => {
+    const merged = mergeChatResponseFormat(providerOptions, {
+      type: 'json_schema',
+      schema: { type: 'object', properties: {} },
+    });
+    expect(merged.jsonSchema?.name).toBe('structured_output');
+  });
+
+  it('maps text/json_object formats without a schema payload', () => {
+    expect(mergeChatResponseFormat(providerOptions, { type: 'json_object' }).responseFormat).toBe(
+      'json_object',
+    );
+    expect(mergeChatResponseFormat(providerOptions, { type: 'text' }).responseFormat).toBe('text');
+  });
+
+  it('composes with buildOpenAIChatResponseFormat into response_format json_schema', () => {
+    const schema = {
+      type: 'object',
+      properties: { title: { type: 'string' } },
+      required: ['title'],
+    };
+    const format = buildOpenAIChatResponseFormat(
+      mergeChatResponseFormat(providerOptions, { type: 'json_schema', name: 'report', schema }),
+    );
+    expect(format).toEqual({
+      type: 'json_schema',
+      json_schema: { name: 'report', schema },
+    });
+  });
+});

package/src/openai/__tests__/strict-tools-closure.test.ts

@@ -0,0 +1,136 @@
+import { closeObjectSchemas } from '@robota-sdk/agent-core';
+import { describe, expect, it, vi } from 'vitest';
+
+import { OpenAIProvider } from '../provider';
+
+import type { IToolSchema, TUniversalMessage } from '@robota-sdk/agent-core';
+
+/**
+ * MCP-005 (TC-08) — `strictTools` no longer closes schemas inside `responses-converter.ts`; the
+ * projection step (`AbstractAIProvider.projectTools()`, `STRICT_TOOL_SCHEMA_PROFILE`) runs BEFORE the
+ * converter now. This test drives the real `OpenAIProvider` end to end (profile → projector →
+ * converter) over a fake Responses client and asserts the request's `parameters` is byte-identical to
+ * today's `closeObjectSchemas(input, { requireAllProperties: true, optionalAsNullable: true })` for a
+ * fixture the projector does not reject — the capability-preservation premise GATE-WRITE recorded.
+ *
+ * PROV-007's original story stays true below: strict mode does not accept an arbitrary JSON Schema —
+ * every object node, nested included, must carry `additionalProperties: false` and list all of its
+ * properties in `required` — so a schema that is correct for this repository was rejected whenever a
+ * caller opted in, root included.
+ */
+
+vi.mock('openai', () => {
+  const MockOpenAI = vi.fn().mockImplementation(() => ({
+    chat: { completions: { create: vi.fn() } },
+    responses: { create: vi.fn() },
+  }));
+  return { default: MockOpenAI };
+});
+
+interface IFakeResponsesClient {
+  responses: { create: ReturnType<typeof vi.fn> };
+}
+
+function createUserMessage(content: string): TUniversalMessage {
+  return { id: 'msg-1', state: 'complete' as const, role: 'user', content, timestamp: new Date() };
+}
+
+function fakeResponsesResult(): Record<string, unknown> {
+  return {
+    id: 'resp-strict-tools-closure',
+    model: 'gpt-4o',
+    output_text: '',
+    output: [],
+    status: 'completed',
+  };
+}
+
+async function sendChat(
+  provider: OpenAIProvider,
+  tools: IToolSchema[],
+): Promise<Record<string, unknown>> {
+  const client = (provider as unknown as { client: IFakeResponsesClient }).client;
+  client.responses.create.mockResolvedValue(fakeResponsesResult());
+  await provider.chat([createUserMessage('hello')], { model: 'gpt-4o', tools });
+  const [requestParams] = client.responses.create.mock.calls[
+    client.responses.create.mock.calls.length - 1
+  ] as [Record<string, unknown>];
+  return requestParams;
+}
+
+const NESTED_TOOL: IToolSchema = {
+  name: 'create_user',
+  description: 'Creates a user',
+  parameters: {
+    type: 'object',
+    additionalProperties: true,
+    properties: {
+      email: { type: 'string' },
+      profile: {
+        type: 'object',
+        additionalProperties: true,
+        properties: { nickname: { type: 'string' }, bio: { type: 'string' } },
+        required: ['nickname'],
+      },
+    },
+    required: ['email'],
+  },
+};
+
+const FLAT_TOOL: IToolSchema = {
+  name: 'ping',
+  description: 'Pings',
+  parameters: { type: 'object', additionalProperties: true, properties: {}, required: [] },
+};
+
+describe('MCP-005 TC-08 — the strict path (profile → projector → converter)', () => {
+  it('closes and completes every object node, root and nested, byte-identical to closeObjectSchemas', async () => {
+    const provider = new OpenAIProvider({ apiKey: 'sk-test', strictTools: true });
+    const requestParams = await sendChat(provider, [NESTED_TOOL]);
+    const [tool] = requestParams.tools as Array<Record<string, unknown>>;
+
+    expect(tool.strict).toBe(true);
+    expect(tool.parameters).toEqual(
+      closeObjectSchemas(NESTED_TOOL.parameters, {
+        requireAllProperties: true,
+        optionalAsNullable: true,
+      }),
+    );
+  });
+
+  it('is not only about nesting — an open ROOT is refused too', async () => {
+    const provider = new OpenAIProvider({ apiKey: 'sk-test', strictTools: true });
+    const requestParams = await sendChat(provider, [FLAT_TOOL]);
+    const [tool] = requestParams.tools as Array<Record<string, unknown>>;
+
+    expect((tool.parameters as Record<string, unknown>).additionalProperties).toBe(false);
+  });
+
+  it('leaves the description byte-identical for a fixture with no lossy strip', async () => {
+    const provider = new OpenAIProvider({ apiKey: 'sk-test', strictTools: true });
+    const requestParams = await sendChat(provider, [NESTED_TOOL]);
+    const [tool] = requestParams.tools as Array<Record<string, unknown>>;
+
+    expect(tool.description).toBe(NESTED_TOOL.description);
+  });
+});
+
+describe('MCP-005 TC-08 — the non-strict path carries the permissive projection', () => {
+  it('forwards the schema unchanged and sends strict: false', async () => {
+    const provider = new OpenAIProvider({ apiKey: 'sk-test', strictTools: false });
+    const requestParams = await sendChat(provider, [NESTED_TOOL]);
+    const [tool] = requestParams.tools as Array<Record<string, unknown>>;
+
+    expect(tool.strict).toBe(false);
+    expect(tool.parameters).toEqual(NESTED_TOOL.parameters);
+  });
+
+  it('treats an unset strictTools as non-strict', async () => {
+    const provider = new OpenAIProvider({ apiKey: 'sk-test' });
+    const requestParams = await sendChat(provider, [NESTED_TOOL]);
+    const [tool] = requestParams.tools as Array<Record<string, unknown>>;
+
+    expect(tool.strict).toBe(false);
+    expect(tool.parameters).toEqual(NESTED_TOOL.parameters);
+  });
+});