fixes

Author: omermorad

README.md

@@ -1,6 +1,6 @@
 # Tadata Node SDK
 
-A Node.js SDK for deploying MCP (Multi-Channel Proxy) servers with your OpenAPI specifications.
+A Node.js SDK for deploying Model Context Protocol (MCP) servers with your OpenAPI specifications.
 
 ## Installation
 
@@ -14,16 +14,16 @@ pnpm add @tadata/node-sdk
 
 ## Quickstart
 
-Deploy an MCP server with your OpenAPI specification:
+Deploy a Model Context Protocol (MCP) server with your OpenAPI specification:
 
 ```typescript
-import { TadataNodeSDK, OpenApiSource } from '@tadata/node-sdk';
+import { TadataNodeSDK, OpenApiSource, ApiVersion } from '@tadata/node-sdk';
 
 // Initialize the SDK
 const tadata = new TadataNodeSDK({
   apiKey: process.env.TADATA_KEY!,
   dev: process.env.NODE_ENV !== 'production',
-  version: '10-10-2024',  // Optional: specify API version
+  version: ApiVersion.V_05_2025,  // Optional: specify API version
   logger: pino(),         // Optional: use custom logger
 });
 
@@ -37,7 +37,7 @@ const deployment = await tadata.mcp.deploy({
   name: 'Acme API',  // Optional
 });
 
-console.log(`Deployed MCP server: ${deployment.url}`);
+console.log(`Deployed Model Context Protocol (MCP) server: ${deployment.url}`);
 ```
 
 ## OpenAPI Source Formats

package.json

@@ -17,6 +17,9 @@
     "LICENSE",
     "README.md"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "clean": "npx rimraf dist",
     "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:types",
@@ -62,6 +65,7 @@
     "nock": "^13.3.0",
     "prettier": "^3.1.0",
     "rimraf": "^5.0.5",
+    "semantic-release": "^24.2.4",
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.1",
     "typescript": "^5.2.2",

pnpm-lock.yaml

@@ -1,12 +1,12 @@
 import { initClient } from '@ts-rest/core';
 import axios, { AxiosError } from 'axios';
-import { tadataContract } from './tadata-contract';
-import { AuthError, NetworkError, ApiError } from '../errors';
 import { Logger } from '../core/logger';
+import { ApiError, AuthError, NetworkError } from '../errors';
+import { tadataContract } from './tadata-contract';
 
 interface ClientOptions {
   baseUrl: string;
-  version: string;
+  version: '05-2025' | 'latest';
   timeout?: number;
   logger?: Logger;
   isDev: boolean;
@@ -32,7 +32,7 @@ export function createApiClient(apiKey: string, options: ClientOptions) {
     timeout,
     headers: {
       'Authorization': `Bearer ${apiKey}`,
-      'x-api-version': version,
+      'x-api-version': version as string,
       'Content-Type': 'application/json',
     },
   });
@@ -42,6 +42,8 @@ export function createApiClient(apiKey: string, options: ClientOptions) {
     axiosInstance.interceptors.request.use(
       config => {
         logger.debug(`Making request to ${config.method?.toUpperCase()} ${config.url}`);
+        // Log API version header specifically
+        logger.debug(`Using API version: ${config.headers['x-api-version']}`);
         return config;
       },
       error => {

src/contract/client.ts

@@ -1,5 +1,10 @@
 /**
- * Logger interface for the SDK
+ * Logger interface for the SDK.
+ * Consumers of the SDK can implement this interface to provide a custom logging
+ * solution (e.g., to integrate with their existing logging infrastructure like Pino or Winston).
+ * If no logger is provided to `TadataNodeSDK`, a default `ConsoleLogger` will be used.
+ *
+ * @since 0.1.0
  */
 export interface Logger {
   debug(msg: string, ...meta: unknown[]): void;
@@ -10,6 +15,8 @@ export interface Logger {
 
 /**
  * Simple console-based logger implementation
+ *
+ * @since 0.1.0
  */
 export class ConsoleLogger implements Logger {
   debug(msg: string, ...meta: unknown[]): void {
@@ -31,6 +38,8 @@ export class ConsoleLogger implements Logger {
 
 /**
  * Creates a default console logger
+ *
+ * @since 0.1.0
  */
 export function createDefaultLogger(): Logger {
   return new ConsoleLogger();

src/core/logger.ts

@@ -1,76 +1,91 @@
 import { createApiClient } from '../contract';
 import { McpResource } from '../resources/mcp';
-import { Logger, createDefaultLogger } from './logger';
+import { createDefaultLogger, Logger } from './logger';
 
 /**
- * Options for initializing the Tadata Node SDK
+ * Options for initializing the Tadata Node SDK.
+ * These settings configure the behavior of the SDK client.
+ *
+ * @since 0.1.0
  */
 export interface TadataOptions {
   /**
-   * API key for authentication
+   * Your Tadata API key. This is required for authentication.
+   * You can obtain an API key from the Tadata dashboard.
    */
   apiKey: string;
 
   /**
-   * Whether to use development mode (sandbox)
+   * Specifies whether to use the development mode (sandbox environment).
+   * Set to `true` to use the sandbox for testing purposes.
    * @default false
    */
   dev?: boolean;
 
   /**
-   * API version to use
-   * @default latest
+   * The API version to use for requests.
+   * It's recommended to use a specific version for stability.
+   * @default ApiVersion.LATEST
    */
-  version?: string;
-
+  version?: '05-2025' | 'latest';
   /**
-   * Custom logger instance
+   * A custom logger instance that conforms to the {@link Logger} interface.
+   * If not provided, a default console logger (`ConsoleLogger`) will be used.
+   * This allows you to integrate SDK logging with your application's logging solution.
    * @default ConsoleLogger
    */
   logger?: Logger;
 }
 
 /**
- * Main class for the Tadata Node SDK
+ * The main class for interacting with the Tadata API.
+ * This class provides access to various Tadata resources and functionalities.
  *
+ * @since 0.1.0
  * @example
- * ```typescript
- * import { TadataNodeSDK, OpenApiSource } from '@tadata/node-sdk';
+ * \`\`\`typescript
+ * import { TadataNodeSDK, ApiVersion } from '@tadata/node-sdk';
+ * // Assumes pino is installed for custom logging, otherwise default logger is used.
+ * // import pino from 'pino';
  *
  * const tadata = new TadataNodeSDK({
  *   apiKey: process.env.TADATA_KEY!,
  *   dev: process.env.NODE_ENV !== 'production',
- *   version: '10-10-2024',
- *   logger: pino(),          // optional
+ *   version: ApiVersion.V_05_2025, // Optional: Defaults to ApiVersion.LATEST
+ *   // logger: pino(),             // Optional: Provide a custom logger
  * });
  *
- * // Load from JSON file
- * const source = await OpenApiSource.fromFile('./acme-openapi.json');
- * // Or from JSON string or object
- * // const source = OpenApiSource.fromJson(jsonString);
- * // const source = OpenApiSource.fromObject(specObject);
+ * async function main() {
+ *   // Example usage (assuming OpenApiSource and MCP deployment)
+ *   // const source = await OpenApiSource.fromFile('./my-api-spec.json');
+ *   // const deployment = await tadata.mcp.deploy({
+ *   //   spec: source,
+ *   //   specBaseUrl: 'https://api.example.com',
+ *   //   name: 'My API Proxy'
+ *   // });
+ *   // console.log('Deployment URL:', deployment.url);
+ * }
  *
- * await tadata.mcp.deploy({
- *   spec: source,
- *   specBaseUrl: 'https://acme.com/api',
- * });
- * ```
+ * main().catch(console.error);
+ * \`\`\`
  */
 export class TadataNodeSDK {
   /**
-   * MCP resource for deploying and managing Multi-Channel Proxies
+   * Access to Model Context Protocol (MCP) functionalities.
+   * Use this resource to deploy and manage your Model Context Protocol instances.
+   * @readonly
    */
   public readonly mcp: McpResource;
+
   /**
-   * Create a new Tadata Node SDK instance
+   * Creates a new instance of the TadataNodeSDK.
+   *
+   * @param options Configuration options for the SDK. See {@link TadataOptions}.
    */
   constructor(options: TadataOptions) {
     const logger = options.logger || createDefaultLogger();
     const isDev = options.dev || false;
-
-    // Always use http://localhost:3000 as the baseUrl
-    // This is a requirement for the current implementation
-    const baseUrl = 'http://localhost:3000';
+    const baseUrl = isDev ? 'https://api.stage.tadata.com' : 'https://api.tadata.com';
 
     const client = createApiClient(options.apiKey, {
       baseUrl,