modality-ai 0.2.1 → 0.3.0

package/dist/index.js

@@ -125288,6 +125288,23 @@ class ModalityClientImpl {
         return "unknown-transport";
     }
   }
+  async closeTransportAndKillProcess(transport) {
+    await transport.close();
+    if (this.transportConfig.type === "stdio") {
+      const stdioBased = transport;
+      const pid2 = stdioBased.pid;
+      if (pid2) {
+        try {
+          process.kill(pid2, "SIGTERM");
+          await new Promise((resolve2) => setTimeout(resolve2, 50));
+          try {
+            process.kill(pid2, 0);
+            process.kill(pid2, "SIGKILL");
+          } catch {}
+        } catch {}
+      }
+    }
+  }
   async call(method, params, autoParse = true) {
     try {
       const client = this.client;
@@ -125318,6 +125335,37 @@ class ModalityClientImpl {
     this.client.close();
     return result;
   }
+  async callOnceAndKill(method, params, autoParse = true) {
+    let transport = null;
+    try {
+      const client = this.client;
+      transport = this.createTransport();
+      await client.connect(transport);
+      const result = await client.callTool({
+        name: method,
+        arguments: params
+      }, undefined, { timeout: this.timeout });
+      await this.closeTransportAndKillProcess(transport);
+      client.close();
+      if (autoParse) {
+        return this.parseContent(result);
+      } else {
+        return result;
+      }
+    } catch (error48) {
+      if (transport) {
+        try {
+          await this.closeTransportAndKillProcess(transport);
+        } catch (closeError) {}
+      }
+      try {
+        this.client.close();
+      } catch {}
+      const transportId = this.getTransportIdentifier();
+      logger6.error(`${transportId}-callOnceAndKill-failed`, error48);
+      throw error48;
+    }
+  }
   callStream(method, params, callback) {
     try {
       const client = this.client;
@@ -126643,17 +126691,23 @@ var createStdioToHttpClient = (options) => {
     args: optionArgs = [],
     env: optionEnv,
     pkg,
-    timeout: timeout6 = 120000
+    timeout: timeout6 = 120000,
+    quiet = false
   } = options || {};
   const args2 = pkg ? [pkg, ...optionArgs] : optionArgs;
   const env = {
     ...Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== undefined)),
     ...optionEnv || {}
   };
+  if (quiet) {
+    env.QUIET = "true";
+    env.DEBUG = "";
+  }
   const client = ModalityClient.stdio({
     command,
     args: args2,
-    env
+    env,
+    stderr: quiet ? "ignore" : "inherit"
   }, timeout6);
   return client;
 };

package/dist/types/ModalityClient.d.ts

@@ -25,8 +25,18 @@ declare class ModalityClientImpl {
     constructor(config: TransportConfig, timeout?: number);
     private createTransport;
     private getTransportIdentifier;
+    /**
+     * Close transport and kill subprocess (for stdio transports only)
+     * Useful for one-off CLI operations where the subprocess should not persist
+     */
+    private closeTransportAndKillProcess;
     call(method: string, params?: any, autoParse?: boolean): Promise<any>;
     callOnce(method: string, params?: any, autoParse?: boolean): Promise<any>;
+    /**
+     * Call a tool once and kill the subprocess (for stdio transports only)
+     * Useful for one-off CLI operations where the subprocess should not persist
+     */
+    callOnceAndKill(method: string, params?: any, autoParse?: boolean): Promise<any>;
     callStream(method: string, params?: any, callback?: (p: any) => void): ReadableStream;
     close(): void;
     listTools(): Promise<ListToolsResult>;

package/dist/types/setupStdioToHttpTools.d.ts

@@ -6,6 +6,7 @@ export interface StdioToHttpOptions {
     env?: Record<string, string>;
     pkg?: string;
     timeout?: number;
+    quiet?: boolean;
 }
 export declare const createStdioToHttpClient: (options?: StdioToHttpOptions) => ModalityClientInstance;
 /**

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.2.1",
+  "version": "0.3.0",
   "name": "modality-ai",
   "repository": {
     "type": "git",