@robota-sdk/agent-provider-openai 3.0.0-beta.82 → 3.0.0-beta.83

package/dist/node/loggers/index.d.cts

@@ -1,10 +1,10 @@
-import { n as IPayloadLoggerOptions, r as IOpenAILogData, t as IPayloadLogger } from "../payload-logger-BaW0K8yI.cjs";
+import { n as IPayloadLoggerOptions, r as IOpenAILogData, t as IPayloadLogger } from "../payload-logger-n89AQdUn.cjs";
 import { ILogger } from "@robota-sdk/agent-core";
 //#region src/openai/loggers/file-payload-logger.d.ts
 /**
  * File-based payload logger for Node.js environments
  *
- * This logger saves API request/response payloads to JSON files on disk.
+ * This logger saves a summary of each Chat Completions request to a JSON file on disk.
  * It's designed specifically for Node.js environments with filesystem access.
  *
  * @example
@@ -39,8 +39,8 @@ declare class FilePayloadLogger implements IPayloadLogger {
    */
   isEnabled(): boolean;
   /**
-   * Log API payload to file
-   * @param payload - The API request payload
+   * Log a request summary to file
+   * @param payload - Summary of the outgoing Chat Completions request
    * @param type - Type of request ('chat' or 'stream')
    */
   logPayload(payload: IOpenAILogData, type?: 'chat' | 'stream'): Promise<void>;
@@ -54,7 +54,7 @@ declare class FilePayloadLogger implements IPayloadLogger {
 /**
  * Console-based payload logger for browser environments
  *
- * This logger outputs API request/response payloads to the browser console
+ * This logger outputs a summary of each Chat Completions request to the browser console
  * using structured logging. It's designed specifically for browser environments
  * and development/debugging scenarios.
  *
@@ -84,7 +84,7 @@ declare class ConsolePayloadLogger implements IPayloadLogger {
   isEnabled(): boolean;
   /**
    * Log API payload to browser console
-   * @param payload - The API request payload
+   * @param payload - Summary of the outgoing Chat Completions request
    * @param type - Type of request ('chat' or 'stream')
    */
   logPayload(payload: IOpenAILogData, type?: 'chat' | 'stream'): Promise<void>;

package/dist/node/loggers/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/openai/loggers/file-payload-logger.ts","../../../src/openai/loggers/console-payload-logger.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;cAqCa,6BAA6B;mBACvB;mBACA;mBACA;mBACA;EAEL,YAAA;IACV;IACA;IACA;IACA,SAAS;;;;;EAeX;;;;;;EASM,WAAW,SAAS,gBAAgB,2BAAmC;;;;UAwCrE;;;;;;;;;;;;;;;;;;;;;;;;;;cClFG,gCAAgC;mBAC1B;mBACA;mBACA;EAEL,YAAA,UAAS;;;;EASrB;;;;;;EASM,WAAW,SAAS,gBAAgB,2BAAmC"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/openai/loggers/file-payload-logger.ts","../../../src/openai/loggers/console-payload-logger.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;cAqCa,6BAA6B;mBACvB;mBACA;mBACA;mBACA;EAEL,YAAA;IACV;IACA;IACA;IACA,SAAS;;;;;EAeX;;;;;;EASM,WAAW,SAAS,gBAAgB,2BAAmC;;;;UAyCrE;;;;;;;;;;;;;;;;;;;;;;;;;;cCnFG,gCAAgC;mBAC1B;mBACA;mBACA;EAEL,YAAA,UAAS;;;;EASrB;;;;;;EASM,WAAW,SAAS,gBAAgB,2BAAmC"}

package/dist/node/loggers/index.d.ts

@@ -1,10 +1,10 @@
-import { n as IPayloadLoggerOptions, r as IOpenAILogData, t as IPayloadLogger } from "../payload-logger-BaW0K8yI.js";
+import { n as IPayloadLoggerOptions, r as IOpenAILogData, t as IPayloadLogger } from "../payload-logger-n89AQdUn.js";
 import { ILogger } from "@robota-sdk/agent-core";
 //#region src/openai/loggers/file-payload-logger.d.ts
 /**
  * File-based payload logger for Node.js environments
  *
- * This logger saves API request/response payloads to JSON files on disk.
+ * This logger saves a summary of each Chat Completions request to a JSON file on disk.
  * It's designed specifically for Node.js environments with filesystem access.
  *
  * @example
@@ -39,8 +39,8 @@ declare class FilePayloadLogger implements IPayloadLogger {
    */
   isEnabled(): boolean;
   /**
-   * Log API payload to file
-   * @param payload - The API request payload
+   * Log a request summary to file
+   * @param payload - Summary of the outgoing Chat Completions request
    * @param type - Type of request ('chat' or 'stream')
    */
   logPayload(payload: IOpenAILogData, type?: 'chat' | 'stream'): Promise<void>;
@@ -54,7 +54,7 @@ declare class FilePayloadLogger implements IPayloadLogger {
 /**
  * Console-based payload logger for browser environments
  *
- * This logger outputs API request/response payloads to the browser console
+ * This logger outputs a summary of each Chat Completions request to the browser console
  * using structured logging. It's designed specifically for browser environments
  * and development/debugging scenarios.
  *
@@ -84,7 +84,7 @@ declare class ConsolePayloadLogger implements IPayloadLogger {
   isEnabled(): boolean;
   /**
    * Log API payload to browser console
-   * @param payload - The API request payload
+   * @param payload - Summary of the outgoing Chat Completions request
    * @param type - Type of request ('chat' or 'stream')
    */
   logPayload(payload: IOpenAILogData, type?: 'chat' | 'stream'): Promise<void>;

package/dist/node/loggers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/openai/loggers/file-payload-logger.ts","../../../src/openai/loggers/console-payload-logger.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;cAqCa,6BAA6B;mBACvB;mBACA;mBACA;mBACA;EAEL,YAAA;IACV;IACA;IACA;IACA,SAAS;;;;;EAeX;;;;;;EASM,WAAW,SAAS,gBAAgB,2BAAmC;;;;UAwCrE;;;;;;;;;;;;;;;;;;;;;;;;;;cClFG,gCAAgC;mBAC1B;mBACA;mBACA;EAEL,YAAA,UAAS;;;;EASrB;;;;;;EASM,WAAW,SAAS,gBAAgB,2BAAmC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/openai/loggers/file-payload-logger.ts","../../../src/openai/loggers/console-payload-logger.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;cAqCa,6BAA6B;mBACvB;mBACA;mBACA;mBACA;EAEL,YAAA;IACV;IACA;IACA;IACA,SAAS;;;;;EAeX;;;;;;EASM,WAAW,SAAS,gBAAgB,2BAAmC;;;;UAyCrE;;;;;;;;;;;;;;;;;;;;;;;;;;cCnFG,gCAAgC;mBAC1B;mBACA;mBACA;EAEL,YAAA,UAAS;;;;EASrB;;;;;;EASM,WAAW,SAAS,gBAAgB,2BAAmC"}

package/dist/node/loggers/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../src/openai/loggers/sanitize-openai-log-data.ts","../../../src/openai/loggers/file-payload-logger.ts","../../../src/openai/loggers/console-payload-logger.ts"],"sourcesContent":["import type { IOpenAILogData } from '../types/api-types';\n\n/**\n * Creates a defensive deep copy of OpenAI log data.\n * SSOT utility shared by payload loggers.\n */\nexport function sanitizeOpenAILogData(payload: IOpenAILogData): IOpenAILogData {\n  // Create a deep copy to avoid modifying original\n  const sanitized = JSON.parse(JSON.stringify(payload)) as IOpenAILogData;\n\n  // Remove or mask sensitive data if needed.\n  // For now, we keep everything as OpenAI payloads don't contain API keys.\n  return sanitized;\n}\n","import * as fs from 'fs';\nimport * as path from 'path';\n\nimport { SilentLogger } from '@robota-sdk/agent-core';\n\nimport { sanitizeOpenAILogData } from './sanitize-openai-log-data';\n\nimport type { IPayloadLogger } from '../interfaces/payload-logger';\nimport type { IOpenAILogData } from '../types/api-types';\nimport type { ILogger } from '@robota-sdk/agent-core';\n\n/** Owner-only access — no group or other bits (SEC-003 / CWE-377). */\nconst OWNER_ONLY_FILE_MODE = 0o600;\nconst OWNER_ONLY_DIR_MODE = 0o700;\n\n/**\n * File-based payload logger for Node.js environments\n *\n * This logger saves API request/response payloads to JSON files on disk.\n * It's designed specifically for Node.js environments with filesystem access.\n *\n * @example\n * ```typescript\n * import { FilePayloadLogger } from '@robota-sdk/agent-provider-openai/loggers';\n *\n * const logger = new FilePayloadLogger({\n *   logDir: './logs/api-payloads',\n *   enabled: true,\n *   includeTimestamp: true\n * });\n *\n * const provider = new OpenAIProvider({\n *   client: openaiClient,\n *   payloadLogger: logger\n * });\n * ```\n */\nexport class FilePayloadLogger implements IPayloadLogger {\n  private readonly enabled: boolean;\n  private readonly logDir: string;\n  private readonly includeTimestamp: boolean;\n  private readonly logger: ILogger;\n\n  constructor(options: {\n    logDir: string;\n    enabled?: boolean;\n    includeTimestamp?: boolean;\n    logger?: ILogger;\n  }) {\n    this.enabled = options.enabled ?? true;\n    this.logDir = options.logDir;\n    this.includeTimestamp = options.includeTimestamp ?? true;\n    this.logger = options.logger || SilentLogger;\n\n    if (this.enabled) {\n      this.ensureLogDirectoryExists();\n    }\n  }\n\n  /**\n   * Check if logging is enabled\n   */\n  isEnabled(): boolean {\n    return this.enabled;\n  }\n\n  /**\n   * Log API payload to file\n   * @param payload - The API request payload\n   * @param type - Type of request ('chat' or 'stream')\n   */\n  async logPayload(payload: IOpenAILogData, type: 'chat' | 'stream' = 'chat'): Promise<void> {\n    if (!this.enabled) {\n      return;\n    }\n\n    try {\n      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');\n      const filename = this.includeTimestamp\n        ? `openai-${type}-${timestamp}.json`\n        : `openai-${type}-${Date.now()}.json`;\n\n      const filepath = path.join(this.logDir, filename);\n\n      const logData = {\n        timestamp: new Date().toISOString(),\n        type,\n        provider: 'openai',\n        payload: sanitizeOpenAILogData(payload),\n      };\n\n      // SEC-003: payload logs contain prompt/response content and `logDir` is\n      // caller-supplied, so create them owner-only rather than under the process umask.\n      await fs.promises.writeFile(filepath, JSON.stringify(logData, null, 2), {\n        encoding: 'utf8',\n        mode: OWNER_ONLY_FILE_MODE,\n      });\n\n      // Payload saved successfully (silent operation)\n    } catch (error) {\n      // Don't throw errors - just log them and continue\n      // This ensures that API logging failures don't break the main functionality\n      this.logger.error('[FilePayloadLogger] Failed to save payload log:', {\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n\n  /**\n   * Ensure log directory exists\n   */\n  private ensureLogDirectoryExists(): void {\n    try {\n      if (!fs.existsSync(this.logDir)) {\n        fs.mkdirSync(this.logDir, { recursive: true, mode: OWNER_ONLY_DIR_MODE });\n      }\n    } catch (error) {\n      this.logger.error('[FilePayloadLogger] Failed to create log directory:', {\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n  // Sanitization intentionally lives in ./sanitize-openai-log-data.ts (SSOT utility).\n}\n","import { SilentLogger, type ILogger } from '@robota-sdk/agent-core';\n\nimport { sanitizeOpenAILogData } from './sanitize-openai-log-data';\n\nimport type { IPayloadLogger, IPayloadLoggerOptions } from '../interfaces/payload-logger';\nimport type { IOpenAILogData } from '../types/api-types';\n\n/**\n * Console-based payload logger for browser environments\n *\n * This logger outputs API request/response payloads to the browser console\n * using structured logging. It's designed specifically for browser environments\n * and development/debugging scenarios.\n *\n * @example\n * ```typescript\n * import { ConsolePayloadLogger } from '@robota-sdk/agent-provider-openai/loggers';\n *\n * const logger = new ConsolePayloadLogger({\n *   enabled: true,\n *   includeTimestamp: true\n * });\n *\n * const provider = new OpenAIProvider({\n *   client: openaiClient,\n *   payloadLogger: logger\n * });\n * ```\n */\nexport class ConsolePayloadLogger implements IPayloadLogger {\n  private readonly enabled: boolean;\n  private readonly includeTimestamp: boolean;\n  private readonly logger: ILogger;\n\n  constructor(options: IPayloadLoggerOptions = {}) {\n    this.enabled = options.enabled ?? true;\n    this.includeTimestamp = options.includeTimestamp ?? true;\n    this.logger = options.logger || SilentLogger;\n  }\n\n  /**\n   * Check if logging is enabled\n   */\n  isEnabled(): boolean {\n    return this.enabled;\n  }\n\n  /**\n   * Log API payload to browser console\n   * @param payload - The API request payload\n   * @param type - Type of request ('chat' or 'stream')\n   */\n  async logPayload(payload: IOpenAILogData, type: 'chat' | 'stream' = 'chat'): Promise<void> {\n    if (!this.enabled) {\n      return;\n    }\n\n    try {\n      const sanitizedPayload = sanitizeOpenAILogData(payload);\n\n      // Use structured console logging for better browser developer tools integration\n      const title = `[OpenAI ${type.toUpperCase()}] API Payload`;\n      const timeInfo = this.includeTimestamp ? ` (${sanitizedPayload.timestamp})` : '';\n\n      // Group related log entries for better organization\n      this.logger.group?.(`${title}${timeInfo}`);\n\n      // Log different aspects with appropriate console methods\n      this.logger.info('📋 Request Details:', {\n        model: payload.model,\n        messagesCount: payload.messagesCount,\n        hasTools: payload.hasTools,\n        temperature: payload.temperature,\n        maxTokens: payload.maxTokens,\n      });\n\n      this.logger.debug('🔍 Full Payload:', { type, provider: 'openai', ...sanitizedPayload });\n\n      this.logger.groupEnd?.();\n    } catch (error) {\n      // Don't throw errors - just log them and continue\n      // This ensures that API logging failures don't break the main functionality\n      this.logger.error(\n        '[ConsolePayloadLogger] Failed to log payload:',\n        error instanceof Error ? error.message : 'Unknown error',\n      );\n    }\n  }\n\n  /**\n   * Sanitize payload to remove sensitive information\n   * @param payload - Raw payload object\n   * @returns Sanitized payload\n   */\n  // Sanitization intentionally lives in ./sanitize-openai-log-data.ts (SSOT utility).\n}\n"],"mappings":"kGAMA,SAAgB,EAAsB,EAAyC,CAM7E,OAJkB,KAAK,MAAM,KAAK,UAAU,CAAO,CAIpC,CACjB,CCwBA,IAAa,EAAb,KAAyD,CACvD,QACA,OACA,iBACA,OAEA,YAAY,EAKT,CACD,KAAK,QAAU,EAAQ,SAAW,GAClC,KAAK,OAAS,EAAQ,OACtB,KAAK,iBAAmB,EAAQ,kBAAoB,GACpD,KAAK,OAAS,EAAQ,QAAU,EAE5B,KAAK,SACP,KAAK,yBAAyB,CAElC,CAKA,WAAqB,CACnB,OAAO,KAAK,OACd,CAOA,MAAM,WAAW,EAAyB,EAA0B,OAAuB,CACpF,QAAK,QAIV,GAAI,CACF,IAAM,EAAY,IAAI,KAAK,CAAA,CAAE,YAAY,CAAC,CAAC,QAAQ,QAAS,GAAG,EACzD,EAAW,KAAK,iBAClB,UAAU,EAAK,GAAG,EAAU,OAC5B,UAAU,EAAK,GAAG,KAAK,IAAI,EAAE,OAE3B,EAAW,EAAK,KAAK,KAAK,OAAQ,CAAQ,EAE1C,EAAU,CACd,UAAW,IAAI,KAAK,CAAA,CAAE,YAAY,EAClC,OACA,SAAU,SACV,QAAS,EAAsB,CAAO,CACxC,EAIA,MAAM,EAAG,SAAS,UAAU,EAAU,KAAK,UAAU,EAAS,KAAM,CAAC,EAAG,CACtE,SAAU,OACV,KAAM,GACR,CAAC,CAGH,OAAS,EAAO,CAGd,KAAK,OAAO,MAAM,kDAAmD,CACnE,MAAO,aAAiB,MAAQ,EAAM,QAAU,OAAO,CAAK,CAC9D,CAAC,CACH,CACF,CAKA,0BAAyC,CACvC,GAAI,CACG,EAAG,WAAW,KAAK,MAAM,GAC5B,EAAG,UAAU,KAAK,OAAQ,CAAE,UAAW,GAAM,KAAM,GAAoB,CAAC,CAE5E,OAAS,EAAO,CACd,KAAK,OAAO,MAAM,sDAAuD,CACvE,MAAO,aAAiB,MAAQ,EAAM,QAAU,OAAO,CAAK,CAC9D,CAAC,CACH,CACF,CAEF,EC9Fa,EAAb,KAA4D,CAC1D,QACA,iBACA,OAEA,YAAY,EAAiC,CAAC,EAAG,CAC/C,KAAK,QAAU,EAAQ,SAAW,GAClC,KAAK,iBAAmB,EAAQ,kBAAoB,GACpD,KAAK,OAAS,EAAQ,QAAU,CAClC,CAKA,WAAqB,CACnB,OAAO,KAAK,OACd,CAOA,MAAM,WAAW,EAAyB,EAA0B,OAAuB,CACpF,QAAK,QAIV,GAAI,CACF,IAAM,EAAmB,EAAsB,CAAO,EAGhD,EAAQ,WAAW,EAAK,YAAY,EAAE,eACtC,EAAW,KAAK,iBAAmB,KAAK,EAAiB,UAAU,GAAK,GAG9E,KAAK,OAAO,QAAQ,GAAG,IAAQ,GAAU,EAGzC,KAAK,OAAO,KAAK,sBAAuB,CACtC,MAAO,EAAQ,MACf,cAAe,EAAQ,cACvB,SAAU,EAAQ,SAClB,YAAa,EAAQ,YACrB,UAAW,EAAQ,SACrB,CAAC,EAED,KAAK,OAAO,MAAM,mBAAoB,CAAE,OAAM,SAAU,SAAU,GAAG,CAAiB,CAAC,EAEvF,KAAK,OAAO,WAAW,CACzB,OAAS,EAAO,CAGd,KAAK,OAAO,MACV,gDACA,aAAiB,MAAQ,EAAM,QAAU,eAC3C,CACF,CACF,CAQF"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/openai/loggers/sanitize-openai-log-data.ts","../../../src/openai/loggers/file-payload-logger.ts","../../../src/openai/loggers/console-payload-logger.ts"],"sourcesContent":["import type { IOpenAILogData } from '../types/api-types';\n\n/**\n * Creates a defensive deep copy of OpenAI log data.\n * SSOT utility shared by payload loggers.\n */\nexport function sanitizeOpenAILogData(payload: IOpenAILogData): IOpenAILogData {\n  // Create a deep copy to avoid modifying original\n  const sanitized = JSON.parse(JSON.stringify(payload)) as IOpenAILogData;\n\n  // Remove or mask sensitive data if needed.\n  // For now, we keep everything as OpenAI payloads don't contain API keys.\n  return sanitized;\n}\n","import * as fs from 'fs';\nimport * as path from 'path';\n\nimport { SilentLogger } from '@robota-sdk/agent-core';\n\nimport { sanitizeOpenAILogData } from './sanitize-openai-log-data';\n\nimport type { IPayloadLogger } from '../interfaces/payload-logger';\nimport type { IOpenAILogData } from '../types/api-types';\nimport type { ILogger } from '@robota-sdk/agent-core';\n\n/** Owner-only access — no group or other bits (SEC-003 / CWE-377). */\nconst OWNER_ONLY_FILE_MODE = 0o600;\nconst OWNER_ONLY_DIR_MODE = 0o700;\n\n/**\n * File-based payload logger for Node.js environments\n *\n * This logger saves a summary of each Chat Completions request to a JSON file on disk.\n * It's designed specifically for Node.js environments with filesystem access.\n *\n * @example\n * ```typescript\n * import { FilePayloadLogger } from '@robota-sdk/agent-provider-openai/loggers';\n *\n * const logger = new FilePayloadLogger({\n *   logDir: './logs/api-payloads',\n *   enabled: true,\n *   includeTimestamp: true\n * });\n *\n * const provider = new OpenAIProvider({\n *   client: openaiClient,\n *   payloadLogger: logger\n * });\n * ```\n */\nexport class FilePayloadLogger implements IPayloadLogger {\n  private readonly enabled: boolean;\n  private readonly logDir: string;\n  private readonly includeTimestamp: boolean;\n  private readonly logger: ILogger;\n\n  constructor(options: {\n    logDir: string;\n    enabled?: boolean;\n    includeTimestamp?: boolean;\n    logger?: ILogger;\n  }) {\n    this.enabled = options.enabled ?? true;\n    this.logDir = options.logDir;\n    this.includeTimestamp = options.includeTimestamp ?? true;\n    this.logger = options.logger || SilentLogger;\n\n    if (this.enabled) {\n      this.ensureLogDirectoryExists();\n    }\n  }\n\n  /**\n   * Check if logging is enabled\n   */\n  isEnabled(): boolean {\n    return this.enabled;\n  }\n\n  /**\n   * Log a request summary to file\n   * @param payload - Summary of the outgoing Chat Completions request\n   * @param type - Type of request ('chat' or 'stream')\n   */\n  async logPayload(payload: IOpenAILogData, type: 'chat' | 'stream' = 'chat'): Promise<void> {\n    if (!this.enabled) {\n      return;\n    }\n\n    try {\n      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');\n      const filename = this.includeTimestamp\n        ? `openai-${type}-${timestamp}.json`\n        : `openai-${type}-${Date.now()}.json`;\n\n      const filepath = path.join(this.logDir, filename);\n\n      const logData = {\n        timestamp: new Date().toISOString(),\n        type,\n        provider: 'openai',\n        payload: sanitizeOpenAILogData(payload),\n      };\n\n      // SEC-003: payload logs record the caller's request history (a request summary, not\n      // prompt/response content) and `logDir` is caller-supplied, so create them owner-only\n      // rather than under the process umask.\n      await fs.promises.writeFile(filepath, JSON.stringify(logData, null, 2), {\n        encoding: 'utf8',\n        mode: OWNER_ONLY_FILE_MODE,\n      });\n\n      // Payload saved successfully (silent operation)\n    } catch (error) {\n      // Don't throw errors - just log them and continue\n      // This ensures that API logging failures don't break the main functionality\n      this.logger.error('[FilePayloadLogger] Failed to save payload log:', {\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n\n  /**\n   * Ensure log directory exists\n   */\n  private ensureLogDirectoryExists(): void {\n    try {\n      if (!fs.existsSync(this.logDir)) {\n        fs.mkdirSync(this.logDir, { recursive: true, mode: OWNER_ONLY_DIR_MODE });\n      }\n    } catch (error) {\n      this.logger.error('[FilePayloadLogger] Failed to create log directory:', {\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n  // Sanitization intentionally lives in ./sanitize-openai-log-data.ts (SSOT utility).\n}\n","import { SilentLogger, type ILogger } from '@robota-sdk/agent-core';\n\nimport { sanitizeOpenAILogData } from './sanitize-openai-log-data';\n\nimport type { IPayloadLogger, IPayloadLoggerOptions } from '../interfaces/payload-logger';\nimport type { IOpenAILogData } from '../types/api-types';\n\n/**\n * Console-based payload logger for browser environments\n *\n * This logger outputs a summary of each Chat Completions request to the browser console\n * using structured logging. It's designed specifically for browser environments\n * and development/debugging scenarios.\n *\n * @example\n * ```typescript\n * import { ConsolePayloadLogger } from '@robota-sdk/agent-provider-openai/loggers';\n *\n * const logger = new ConsolePayloadLogger({\n *   enabled: true,\n *   includeTimestamp: true\n * });\n *\n * const provider = new OpenAIProvider({\n *   client: openaiClient,\n *   payloadLogger: logger\n * });\n * ```\n */\nexport class ConsolePayloadLogger implements IPayloadLogger {\n  private readonly enabled: boolean;\n  private readonly includeTimestamp: boolean;\n  private readonly logger: ILogger;\n\n  constructor(options: IPayloadLoggerOptions = {}) {\n    this.enabled = options.enabled ?? true;\n    this.includeTimestamp = options.includeTimestamp ?? true;\n    this.logger = options.logger || SilentLogger;\n  }\n\n  /**\n   * Check if logging is enabled\n   */\n  isEnabled(): boolean {\n    return this.enabled;\n  }\n\n  /**\n   * Log API payload to browser console\n   * @param payload - Summary of the outgoing Chat Completions request\n   * @param type - Type of request ('chat' or 'stream')\n   */\n  async logPayload(payload: IOpenAILogData, type: 'chat' | 'stream' = 'chat'): Promise<void> {\n    if (!this.enabled) {\n      return;\n    }\n\n    try {\n      const sanitizedPayload = sanitizeOpenAILogData(payload);\n\n      // Use structured console logging for better browser developer tools integration\n      const title = `[OpenAI ${type.toUpperCase()}] API Payload`;\n      const timeInfo = this.includeTimestamp ? ` (${sanitizedPayload.timestamp})` : '';\n\n      // Group related log entries for better organization\n      this.logger.group?.(`${title}${timeInfo}`);\n\n      // Log different aspects with appropriate console methods\n      this.logger.info('📋 Request Details:', {\n        model: payload.model,\n        messagesCount: payload.messagesCount,\n        hasTools: payload.hasTools,\n        temperature: payload.temperature,\n        maxTokens: payload.maxTokens,\n      });\n\n      this.logger.debug('🔍 Full Payload:', { type, provider: 'openai', ...sanitizedPayload });\n\n      this.logger.groupEnd?.();\n    } catch (error) {\n      // Don't throw errors - just log them and continue\n      // This ensures that API logging failures don't break the main functionality\n      this.logger.error(\n        '[ConsolePayloadLogger] Failed to log payload:',\n        error instanceof Error ? error.message : 'Unknown error',\n      );\n    }\n  }\n\n  /**\n   * Sanitize payload to remove sensitive information\n   * @param payload - Raw payload object\n   * @returns Sanitized payload\n   */\n  // Sanitization intentionally lives in ./sanitize-openai-log-data.ts (SSOT utility).\n}\n"],"mappings":"kGAMA,SAAgB,EAAsB,EAAyC,CAM7E,OAJkB,KAAK,MAAM,KAAK,UAAU,CAAO,CAIpC,CACjB,CCwBA,IAAa,EAAb,KAAyD,CACvD,QACA,OACA,iBACA,OAEA,YAAY,EAKT,CACD,KAAK,QAAU,EAAQ,SAAW,GAClC,KAAK,OAAS,EAAQ,OACtB,KAAK,iBAAmB,EAAQ,kBAAoB,GACpD,KAAK,OAAS,EAAQ,QAAU,EAE5B,KAAK,SACP,KAAK,yBAAyB,CAElC,CAKA,WAAqB,CACnB,OAAO,KAAK,OACd,CAOA,MAAM,WAAW,EAAyB,EAA0B,OAAuB,CACpF,QAAK,QAIV,GAAI,CACF,IAAM,EAAY,IAAI,KAAK,CAAA,CAAE,YAAY,CAAC,CAAC,QAAQ,QAAS,GAAG,EACzD,EAAW,KAAK,iBAClB,UAAU,EAAK,GAAG,EAAU,OAC5B,UAAU,EAAK,GAAG,KAAK,IAAI,EAAE,OAE3B,EAAW,EAAK,KAAK,KAAK,OAAQ,CAAQ,EAE1C,EAAU,CACd,UAAW,IAAI,KAAK,CAAA,CAAE,YAAY,EAClC,OACA,SAAU,SACV,QAAS,EAAsB,CAAO,CACxC,EAKA,MAAM,EAAG,SAAS,UAAU,EAAU,KAAK,UAAU,EAAS,KAAM,CAAC,EAAG,CACtE,SAAU,OACV,KAAM,GACR,CAAC,CAGH,OAAS,EAAO,CAGd,KAAK,OAAO,MAAM,kDAAmD,CACnE,MAAO,aAAiB,MAAQ,EAAM,QAAU,OAAO,CAAK,CAC9D,CAAC,CACH,CACF,CAKA,0BAAyC,CACvC,GAAI,CACG,EAAG,WAAW,KAAK,MAAM,GAC5B,EAAG,UAAU,KAAK,OAAQ,CAAE,UAAW,GAAM,KAAM,GAAoB,CAAC,CAE5E,OAAS,EAAO,CACd,KAAK,OAAO,MAAM,sDAAuD,CACvE,MAAO,aAAiB,MAAQ,EAAM,QAAU,OAAO,CAAK,CAC9D,CAAC,CACH,CACF,CAEF,EC/Fa,EAAb,KAA4D,CAC1D,QACA,iBACA,OAEA,YAAY,EAAiC,CAAC,EAAG,CAC/C,KAAK,QAAU,EAAQ,SAAW,GAClC,KAAK,iBAAmB,EAAQ,kBAAoB,GACpD,KAAK,OAAS,EAAQ,QAAU,CAClC,CAKA,WAAqB,CACnB,OAAO,KAAK,OACd,CAOA,MAAM,WAAW,EAAyB,EAA0B,OAAuB,CACpF,QAAK,QAIV,GAAI,CACF,IAAM,EAAmB,EAAsB,CAAO,EAGhD,EAAQ,WAAW,EAAK,YAAY,EAAE,eACtC,EAAW,KAAK,iBAAmB,KAAK,EAAiB,UAAU,GAAK,GAG9E,KAAK,OAAO,QAAQ,GAAG,IAAQ,GAAU,EAGzC,KAAK,OAAO,KAAK,sBAAuB,CACtC,MAAO,EAAQ,MACf,cAAe,EAAQ,cACvB,SAAU,EAAQ,SAClB,YAAa,EAAQ,YACrB,UAAW,EAAQ,SACrB,CAAC,EAED,KAAK,OAAO,MAAM,mBAAoB,CAAE,OAAM,SAAU,SAAU,GAAG,CAAiB,CAAC,EAEvF,KAAK,OAAO,WAAW,CACzB,OAAS,EAAO,CAGd,KAAK,OAAO,MACV,gDACA,aAAiB,MAAQ,EAAM,QAAU,eAC3C,CACF,CACF,CAQF"}

package/dist/node/{payload-logger-BaW0K8yI.d.ts → payload-logger-n89AQdUn.d.cts}

@@ -16,7 +16,9 @@ interface IOpenAILogData {
 //#endregion
 //#region src/openai/interfaces/payload-logger.d.ts
 /**
- * IPayloadLogger interface for logging OpenAI API payloads
+ * IPayloadLogger interface for logging a summary of each OpenAI Chat Completions request
+ * (request metadata such as model, message count and whether tools were sent — not prompt or
+ * response content).
  *
  * This interface provides a contract for different logging implementations:
  * - FilePayloadLogger: Node.js file-based logging
@@ -30,8 +32,8 @@ interface IPayloadLogger {
    */
   isEnabled(): boolean;
   /**
-   * Log API payload data
-   * @param payload - The API request/response payload data
+   * Log a request summary
+   * @param payload - Summary of the outgoing Chat Completions request
    * @param type - Type of operation ('chat' or 'stream')
    */
   logPayload(payload: IOpenAILogData, type: 'chat' | 'stream'): Promise<void>;
@@ -58,4 +60,4 @@ interface IPayloadLoggerOptions {
 }
 //#endregion
 export { IPayloadLoggerOptions as n, IOpenAILogData as r, IPayloadLogger as t };
-//# sourceMappingURL=payload-logger-BaW0K8yI.d.ts.map
+//# sourceMappingURL=payload-logger-n89AQdUn.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"payload-logger-n89AQdUn.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;;;;;;;;;;;;;;UClGe;;;;;EAKf;;;;;;EAOA,WAAW,SAAS,gBAAgB,0BAA0B;;;;;UAM/C;;;;;EAKf;;;;;EAMA;;;;;EAMA,SAAS"}

package/dist/node/{payload-logger-BaW0K8yI.d.cts → payload-logger-n89AQdUn.d.ts}

@@ -16,7 +16,9 @@ interface IOpenAILogData {
 //#endregion
 //#region src/openai/interfaces/payload-logger.d.ts
 /**
- * IPayloadLogger interface for logging OpenAI API payloads
+ * IPayloadLogger interface for logging a summary of each OpenAI Chat Completions request
+ * (request metadata such as model, message count and whether tools were sent — not prompt or
+ * response content).
  *
  * This interface provides a contract for different logging implementations:
  * - FilePayloadLogger: Node.js file-based logging
@@ -30,8 +32,8 @@ interface IPayloadLogger {
    */
   isEnabled(): boolean;
   /**
-   * Log API payload data
-   * @param payload - The API request/response payload data
+   * Log a request summary
+   * @param payload - Summary of the outgoing Chat Completions request
    * @param type - Type of operation ('chat' or 'stream')
    */
   logPayload(payload: IOpenAILogData, type: 'chat' | 'stream'): Promise<void>;
@@ -58,4 +60,4 @@ interface IPayloadLoggerOptions {
 }
 //#endregion
 export { IPayloadLoggerOptions as n, IOpenAILogData as r, IPayloadLogger as t };
-//# sourceMappingURL=payload-logger-BaW0K8yI.d.cts.map
+//# sourceMappingURL=payload-logger-n89AQdUn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"payload-logger-n89AQdUn.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;;;;;;;;;;;;;;UClGe;;;;;EAKf;;;;;;EAOA,WAAW,SAAS,gBAAgB,0BAA0B;;;;;UAM/C;;;;;EAKf;;;;;EAMA;;;;;EAMA,SAAS"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robota-sdk/agent-provider-openai",
-  "version": "3.0.0-beta.82",
+  "version": "3.0.0-beta.83",
   "description": "OpenAI provider implementation for Robota SDK",
   "type": "module",
   "publishConfig": {
@@ -54,11 +54,16 @@
           "default": "./dist/node/loggers/index.cjs"
         }
       }
-    }
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=22.12.0"
   },
   "files": [
     "dist",
-    "src"
+    "src",
+    "CHANGELOG.md"
   ],
   "devDependencies": {
     "@types/node": "^22.19.21",
@@ -75,8 +80,8 @@
   },
   "dependencies": {
     "openai": "^4.104.0",
-    "@robota-sdk/agent-core": "3.0.0-beta.82",
-    "@robota-sdk/agent-provider-openai-compatible": "3.0.0-beta.82"
+    "@robota-sdk/agent-core": "3.0.0-beta.83",
+    "@robota-sdk/agent-provider-openai-compatible": "3.0.0-beta.83"
   },
   "volta": {
     "extends": "../../package.json"

package/src/openai/__tests__/abort-signal-wire.test.ts

@@ -0,0 +1,210 @@
+/**
+ * The run's `AbortSignal` reaches the SDK request on every call site of both API surfaces
+ * (agent-core SPEC, Cancellation Contract). The non-streaming Chat Completions path is the one the
+ * forced summary takes, and it used to send no signal, so an aborted run left that request running.
+ */
+import { createServer } from 'node:http';
+
+import { classifyProviderFailure } from '@robota-sdk/agent-core';
+import { APIUserAbortError } from 'openai';
+import { describe, expect, it, vi } from 'vitest';
+
+import { OpenAIProvider } from '../provider';
+
+import type { IChatOptions, TUniversalMessage } from '@robota-sdk/agent-core';
+import type { AddressInfo } from 'node:net';
+import type OpenAI from 'openai';
+
+const completion = {
+  id: 'c1',
+  object: 'chat.completion',
+  created: 0,
+  model: 'gpt-test',
+  choices: [{ index: 0, message: { role: 'assistant', content: 'hi' }, finish_reason: 'stop' }],
+};
+const completionChunks = [
+  {
+    id: 'c1',
+    object: 'chat.completion.chunk',
+    created: 0,
+    model: 'gpt-test',
+    choices: [{ index: 0, delta: { role: 'assistant', content: 'hi' }, finish_reason: null }],
+  },
+  {
+    id: 'c1',
+    object: 'chat.completion.chunk',
+    created: 0,
+    model: 'gpt-test',
+    choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+  },
+];
+const response = {
+  id: 'resp_1',
+  object: 'response',
+  created_at: 0,
+  model: 'gpt-test',
+  status: 'completed',
+  output: [
+    {
+      type: 'message',
+      id: 'msg_1',
+      role: 'assistant',
+      status: 'completed',
+      content: [{ type: 'output_text', text: 'hi', annotations: [] }],
+    },
+  ],
+  usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 },
+};
+const responseEvents = [
+  {
+    type: 'response.output_text.delta',
+    item_id: 'msg_1',
+    output_index: 0,
+    content_index: 0,
+    delta: 'hi',
+    sequence_number: 1,
+  },
+  { type: 'response.completed', response, sequence_number: 2 },
+];
+
+const messages: TUniversalMessage[] = [
+  { id: 'u1', role: 'user', content: 'hello', state: 'complete', timestamp: new Date() },
+];
+
+async function* iterate(items: readonly object[]): AsyncGenerator<object> {
+  for (const item of items) yield item;
+}
+
+/** An SDK client double whose `create` answers like the SDK and records the request options. */
+function fakeClient() {
+  const chatCreate = vi.fn(
+    (params: { stream?: boolean }, _requestOptions?: OpenAI.RequestOptions) =>
+      Promise.resolve(params.stream ? iterate(completionChunks) : completion),
+  );
+  const responsesCreate = vi.fn(
+    (params: { stream?: boolean }, _requestOptions?: OpenAI.RequestOptions) =>
+      Promise.resolve(params.stream ? iterate(responseEvents) : response),
+  );
+  const client = {
+    chat: { completions: { create: chatCreate } },
+    responses: { create: responsesCreate },
+  } as unknown as OpenAI;
+  return { client, chatCreate, responsesCreate };
+}
+
+const CALL_SITES: ReadonlyArray<
+  readonly [string, (provider: OpenAIProvider, options: IChatOptions) => Promise<void>]
+> = [
+  [
+    'chat() without a delta callback (non-streaming request, the forced-summary path)',
+    async (provider, options) => {
+      await provider.chat(messages, options);
+    },
+  ],
+  [
+    'chat() with a delta callback (streaming assembly)',
+    async (provider, options) => {
+      await provider.chat(messages, { ...options, onTextDelta: () => undefined });
+    },
+  ],
+  [
+    'chatStream()',
+    async (provider, options) => {
+      for await (const _chunk of provider.chatStream(messages, options)) {
+        // drain
+      }
+    },
+  ],
+];
+
+describe('OpenAI run AbortSignal on the wire', () => {
+  for (const apiSurface of ['chat-completions', 'responses'] as const) {
+    for (const [callSite, run] of CALL_SITES) {
+      it(`${apiSurface}: ${callSite} hands the run's own signal to the SDK request`, async () => {
+        const { client, chatCreate, responsesCreate } = fakeClient();
+        const create = apiSurface === 'responses' ? responsesCreate : chatCreate;
+        const controller = new AbortController();
+
+        await run(new OpenAIProvider({ client, apiSurface }), {
+          model: 'gpt-test',
+          signal: controller.signal,
+        });
+
+        expect(create).toHaveBeenCalledTimes(1);
+        expect(create.mock.calls[0]?.[1]?.signal).toBe(controller.signal);
+      });
+    }
+  }
+
+  it('closes the HTTP request when the run aborts a non-streaming Chat Completions call', async () => {
+    const server = await startUnansweringServer();
+    let bound: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const provider = new OpenAIProvider({
+        apiKey: 'test-key',
+        baseURL: server.baseURL,
+        apiSurface: 'chat-completions',
+      });
+      const controller = new AbortController();
+      const pending = provider.chat(messages, { model: 'gpt-test', signal: controller.signal });
+      const outcome = pending.then(
+        () => 'resolved' as const,
+        (error: unknown) => error,
+      );
+
+      await server.requestReceived;
+      controller.abort();
+
+      // The server never answers, so only the client hanging up can close the request. Without the
+      // signal it stays open until the SDK's own 10-minute timeout; the bound only decides failure.
+      const closed = await Promise.race([
+        server.clientHungUp.then(() => 'closed' as const),
+        new Promise<'still open'>((resolve) => {
+          bound = setTimeout(() => resolve('still open'), 2_000);
+        }),
+      ]);
+      expect(closed).toBe('closed');
+
+      // The SDK's own abort error, passed through rather than wrapped as a provider failure, so the
+      // run layer classifies it as an interruption — without needing the signal to tell it so.
+      const error = await outcome;
+      expect(error).toBeInstanceOf(APIUserAbortError);
+      expect(classifyProviderFailure(error)).toEqual({ switchable: false, reason: 'aborted' });
+    } finally {
+      clearTimeout(bound);
+      await server.close();
+    }
+  });
+});
+
+/** A local endpoint that accepts a request and never answers it, reporting when the client hangs up. */
+async function startUnansweringServer(): Promise<{
+  baseURL: string;
+  requestReceived: Promise<void>;
+  clientHungUp: Promise<void>;
+  close: () => Promise<void>;
+}> {
+  let onRequest!: () => void;
+  let onHangUp!: () => void;
+  const requestReceived = new Promise<void>((resolve) => (onRequest = resolve));
+  const clientHungUp = new Promise<void>((resolve) => (onHangUp = resolve));
+  const server = createServer((request, reply) => {
+    request.resume();
+    reply.on('close', () => {
+      if (!reply.writableEnded) onHangUp();
+    });
+    onRequest();
+  });
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const { port } = server.address() as AddressInfo;
+  return {
+    baseURL: `http://127.0.0.1:${port}/v1`,
+    requestReceived,
+    clientHungUp,
+    close: () =>
+      new Promise<void>((resolve) => {
+        server.closeAllConnections();
+        server.close(() => resolve());
+      }),
+  };
+}

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

@@ -27,8 +27,9 @@ vi.mock('openai', () => {
   return { default: MockOpenAI };
 });
 
-interface IFakeResponsesClient {
+interface IFakeOpenAIClient {
   responses: { create: ReturnType<typeof vi.fn> };
+  chat: { completions: { create: ReturnType<typeof vi.fn> } };
 }
 
 function createUserMessage(content: string): TUniversalMessage {
@@ -49,7 +50,7 @@ async function sendChat(
   provider: OpenAIProvider,
   tools: IToolSchema[],
 ): Promise<Record<string, unknown>> {
-  const client = (provider as unknown as { client: IFakeResponsesClient }).client;
+  const client = (provider as unknown as { client: IFakeOpenAIClient }).client;
   client.responses.create.mockResolvedValue(fakeResponsesResult());
   await provider.chat([createUserMessage('hello')], { model: 'gpt-4o', tools });
   const [requestParams] = client.responses.create.mock.calls[
@@ -58,6 +59,25 @@ async function sendChat(
   return requestParams;
 }
 
+/** The same request through the Chat Completions surface (the default once `baseURL` is set). */
+async function sendChatCompletions(
+  provider: OpenAIProvider,
+  tools: IToolSchema[],
+): Promise<Record<string, unknown>> {
+  const client = (provider as unknown as { client: IFakeOpenAIClient }).client;
+  client.chat.completions.create.mockResolvedValue({
+    id: 'chatcmpl-strict-tools',
+    object: 'chat.completion',
+    created: 1,
+    model: 'gpt-4o',
+    choices: [{ index: 0, message: { role: 'assistant', content: 'ok' }, finish_reason: 'stop' }],
+  });
+  await provider.chat([createUserMessage('hello')], { model: 'gpt-4o', tools });
+  const calls = client.chat.completions.create.mock.calls;
+  const [requestParams] = calls[calls.length - 1] as [Record<string, unknown>];
+  return requestParams;
+}
+
 const NESTED_TOOL: IToolSchema = {
   name: 'create_user',
   description: 'Creates a user',
@@ -134,3 +154,30 @@ describe('MCP-005 TC-08 — the non-strict path carries the permissive projectio
     expect(tool.parameters).toEqual(NESTED_TOOL.parameters);
   });
 });
+
+describe('strictTools on the Chat Completions surface (#3209)', () => {
+  const GATEWAY = { apiKey: 'sk-test', baseURL: 'https://gateway.example/v1' };
+
+  it('declares each function strict, with the same closed schema the Responses surface sends', async () => {
+    const provider = new OpenAIProvider({ ...GATEWAY, strictTools: true });
+    const requestParams = await sendChatCompletions(provider, [NESTED_TOOL]);
+    const [tool] = requestParams.tools as Array<{ function: Record<string, unknown> }>;
+
+    expect(tool?.function.strict).toBe(true);
+    expect(tool?.function.parameters).toEqual(
+      closeObjectSchemas(NESTED_TOOL.parameters, {
+        requireAllProperties: true,
+        optionalAsNullable: true,
+      }),
+    );
+  });
+
+  it('sends no strict key when strictTools is off', async () => {
+    const provider = new OpenAIProvider(GATEWAY);
+    const requestParams = await sendChatCompletions(provider, [NESTED_TOOL]);
+    const [tool] = requestParams.tools as Array<{ function: Record<string, unknown> }>;
+
+    expect(tool?.function).not.toHaveProperty('strict');
+    expect(tool?.function.parameters).toEqual(NESTED_TOOL.parameters);
+  });
+});

package/src/openai/__tests__/tool-schema-projection.test.ts

@@ -113,16 +113,23 @@ interface ISentTool {
   name: string;
   description: string;
   parameters: unknown;
+  /** Whether the tool was declared strict on the wire (absent counts as not strict). */
+  strict: boolean;
 }
 
 function sentToolsFromResponses(client: IFakeClient): ISentTool[] {
   const [requestParams] = client.responses.create.mock.calls[
     client.responses.create.mock.calls.length - 1
-  ] as [{ tools?: Array<{ name: string; description: string; parameters: unknown }> }];
+  ] as [
+    {
+      tools?: Array<{ name: string; description: string; parameters: unknown; strict?: boolean }>;
+    },
+  ];
   return (requestParams.tools ?? []).map((tool) => ({
     name: tool.name,
     description: tool.description,
     parameters: tool.parameters,
+    strict: tool.strict === true,
   }));
 }
 
@@ -131,13 +138,16 @@ function sentToolsFromChatCompletions(client: IFakeClient): ISentTool[] {
     client.chat.completions.create.mock.calls.length - 1
   ] as [
     {
-      tools?: Array<{ function: { name: string; description: string; parameters: unknown } }>;
+      tools?: Array<{
+        function: { name: string; description: string; parameters: unknown; strict?: boolean };
+      }>;
     },
   ];
   return (requestParams.tools ?? []).map((tool) => ({
     name: tool.function.name,
     description: tool.function.description,
     parameters: tool.function.parameters,
+    strict: tool.function.strict === true,
   }));
 }
 
@@ -173,6 +183,7 @@ describe.each([
 
       const sent = sentTools(client);
       expect(sent).toHaveLength(3);
+      expect(sent.every((tool) => !tool.strict)).toBe(true);
       for (const [index, tool] of tools.entries()) {
         const projection = projectToolSchema(tool, PERMISSIVE_PROFILE);
         expect(sent[index]?.parameters).toEqual(projection.tool.parameters);
@@ -242,6 +253,7 @@ describe.each([
 
       const sent = sentTools(client);
       expect(sent.map((tool) => tool.name)).toEqual(['good_tool_one', 'good_tool_two']);
+      expect(sent.every((tool) => !tool.strict)).toBe(true);
     });
   },
 );
@@ -274,6 +286,7 @@ describe.each([
         const projection = projectToolSchema(tool, STRICT_PROFILE);
         expect(sent[index]?.parameters).toEqual(projection.tool.parameters);
         expect(sent[index]?.description).toEqual(projection.tool.description);
+        expect(sent[index]?.strict).toBe(true);
       }
     });
 
@@ -297,6 +310,7 @@ describe.each([
       const sent = sentTools(client);
       const projection = projectToolSchema(fixtures.subsetOnly, STRICT_PROFILE);
       expect(sent[0]?.parameters).toEqual(projection.tool.parameters);
+      expect(sent[0]?.strict).toBe(true);
     });
   },
 );

package/src/openai/chat-completions-chat.ts

@@ -56,7 +56,7 @@ export async function chatWithOpenAIChatCompletions(
       payloadKind: 'request',
       payload: requestParams,
     });
-    const requestOptions = openAIRequestOptions(undefined, input.requestHeaders);
+    const requestOptions = openAIRequestOptions(input.chatOptions?.signal, input.requestHeaders);
     const response = requestOptions
       ? await client.chat.completions.create(requestParams, requestOptions)
       : await client.chat.completions.create(requestParams);
@@ -151,7 +151,7 @@ function buildChatRequestParams(
     }),
     ...(input.chatOptions?.maxTokens !== undefined && { max_tokens: input.chatOptions.maxTokens }),
     ...(input.chatOptions?.tools && {
-      tools: convertToOpenAITools(input.chatOptions.tools),
+      tools: convertToOpenAITools(input.chatOptions.tools, input.providerOptions.strictTools),
       tool_choice: toOpenAICompatibleToolChoice(input.chatOptions.toolChoice),
     }),
     ...(responseFormat !== undefined && { response_format: responseFormat }),

package/src/openai/interfaces/payload-logger.ts

@@ -2,7 +2,9 @@ import type { IOpenAILogData } from '../types/api-types';
 import type { ILogger } from '@robota-sdk/agent-core';
 
 /**
- * IPayloadLogger interface for logging OpenAI API payloads
+ * IPayloadLogger interface for logging a summary of each OpenAI Chat Completions request
+ * (request metadata such as model, message count and whether tools were sent — not prompt or
+ * response content).
  *
  * This interface provides a contract for different logging implementations:
  * - FilePayloadLogger: Node.js file-based logging
@@ -17,8 +19,8 @@ export interface IPayloadLogger {
   isEnabled(): boolean;
 
   /**
-   * Log API payload data
-   * @param payload - The API request/response payload data
+   * Log a request summary
+   * @param payload - Summary of the outgoing Chat Completions request
    * @param type - Type of operation ('chat' or 'stream')
    */
   logPayload(payload: IOpenAILogData, type: 'chat' | 'stream'): Promise<void>;