modality-ai 0.7.4 → 0.8.0

package/dist/index.js

@@ -126465,16 +126465,31 @@ class ModalityClientImpl {
     }
   }
   parseContent(toolResult) {
-    try {
-      const content = toolResult?.content?.[0];
-      if (content?.type === "text" && content.text) {
-        return JSON.parse(content.text);
+    const blocks = Array.isArray(toolResult?.content) ? toolResult.content : [];
+    const parsed = blocks.filter((b) => b?.type === "text" && b.text).map((b) => {
+      try {
+        return JSON.parse(b.text);
+      } catch {
+        return b.text;
       }
-      return content ?? toolResult;
-    } catch {
-      const content = toolResult?.content?.[0];
-      return content?.text ?? content ?? toolResult;
+    });
+    if (parsed.length === 0) {
+      return toolResult?.content?.[0] ?? toolResult;
     }
+    const objects = parsed.filter((p) => typeof p === "object" && p !== null && !Array.isArray(p));
+    const extras = parsed.filter((p) => typeof p !== "object" || p === null || Array.isArray(p));
+    if (objects.length === 0) {
+      return parsed.length === 1 ? parsed[0] : parsed;
+    }
+    const merged = Object.assign({}, ...objects);
+    if (extras.length > 0) {
+      const key = objects.some((o) => ("_extra" in o)) ? "__extra" : "_extra";
+      merged[key] = extras.length === 1 ? extras[0] : extras;
+    }
+    if (merged.success === undefined) {
+      merged.success = toolResult?.isError !== true;
+    }
+    return merged;
   }
 }
 function http(url3, timeout, options) {
@@ -129443,7 +129458,7 @@ var setupStdioToHttpTools = async (client, mcpServer) => {
   return setupAITools(aiTools, mcpServer);
 };
 // src/mcp-oauth-provider.ts
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join as join9 } from "node:path";
@@ -129459,6 +129474,10 @@ class CLIBrowserOAuthProvider {
   _serverIdentity;
   _noOpen;
   _cachePath;
+  _callbackPath;
+  _callbackHost;
+  _state;
+  _onAuthorizationUrl;
   _port;
   _server;
   _resolveCode;
@@ -129471,6 +129490,10 @@ class CLIBrowserOAuthProvider {
   constructor(options = {}) {
     this._clientName = options.clientName ?? "mcp-cli";
     this._noOpen = options.noOpen ?? false;
+    this._onAuthorizationUrl = options.onAuthorizationUrl;
+    this._state = randomBytes(16).toString("hex");
+    this._callbackPath = options.externalCallback?.path ?? "/callback";
+    this._callbackHost = options.externalCallback?.host ?? "127.0.0.1";
     this._serverIdentity = options.serverUrl ? resolveServerIdentity(options.serverUrl) : null;
     if (options.serverUrl === null) {
       this._cachePath = null;
@@ -129490,11 +129513,15 @@ class CLIBrowserOAuthProvider {
       this._resolveCode = resolve2;
       this._rejectCode = reject3;
     });
-    this._server = Bun.serve({
-      port: options.callbackPort ?? 9876,
-      fetch: (req) => this._handleCallback(req)
-    });
-    this._port = this._server.port ?? 9876;
+    if (options.externalCallback) {
+      this._port = options.externalCallback.port;
+    } else {
+      this._server = Bun.serve({
+        port: options.callbackPort ?? 9876,
+        fetch: (req) => this._handleCallback(req)
+      });
+      this._port = this._server.port ?? 9876;
+    }
     if (this._clientInfo) {
       const uris = this._clientInfo.redirect_uris ?? [];
       if (!uris.includes(this.redirectUrl)) {
@@ -129503,7 +129530,7 @@ class CLIBrowserOAuthProvider {
     }
   }
   get redirectUrl() {
-    return `http://127.0.0.1:${this._port}/callback`;
+    return `http://${this._callbackHost}:${this._port}${this._callbackPath}`;
   }
   get clientMetadata() {
     const identity7 = this._serverIdentity;
@@ -129554,7 +129581,11 @@ class CLIBrowserOAuthProvider {
       params.set("client_secret", secret3);
     }
   };
+  state() {
+    return this._state;
+  }
   async redirectToAuthorization(authorizationUrl) {
+    this._onAuthorizationUrl?.(authorizationUrl);
     const url5 = authorizationUrl.toString();
     if (this._noOpen) {
       console.error(`
@@ -129577,6 +129608,15 @@ class CLIBrowserOAuthProvider {
   waitForCode() {
     return this._pendingCode;
   }
+  get oauthState() {
+    return this._state;
+  }
+  get callbackPath() {
+    return this._callbackPath;
+  }
+  handleCallback(req) {
+    return this._handleCallback(req);
+  }
   getDiscoveryState() {
     return this._discoveryState;
   }
@@ -129585,7 +129625,7 @@ class CLIBrowserOAuthProvider {
     this._persistCache();
   }
   stop() {
-    this._server.stop(true);
+    this._server?.stop(true);
   }
   _loadCache() {
     if (!this._cachePath)
@@ -129611,9 +129651,14 @@ class CLIBrowserOAuthProvider {
   }
   _handleCallback(req) {
     const url5 = new URL(req.url);
-    if (url5.pathname !== "/callback") {
+    if (url5.pathname !== this._callbackPath) {
       return new Response("Not found", { status: 404 });
     }
+    const returnedState = url5.searchParams.get("state");
+    if (returnedState !== null && returnedState !== this._state) {
+      this._rejectCode?.(new Error("OAuth state mismatch"));
+      return errorPage("state_mismatch", "State parameter did not match.");
+    }
     const error54 = url5.searchParams.get("error");
     if (error54) {
       const description = url5.searchParams.get("error_description") ?? "";

package/dist/types/ModalityClient.d.ts

@@ -47,6 +47,19 @@ declare class ModalityClientImpl {
     callStream(method: string, params?: any, callback?: (p: any) => void): ReadableStream;
     close(): Promise<void>;
     listTools(): Promise<ListToolsResult>;
+    /**
+     * Parse a CallToolResult into a plain value.
+     *
+     * modality-kit's `formatSuccessResponse(data, meta)` splits results across
+     * text blocks — block 0 is the envelope (`{message}`), blocks 1+ carry the
+     * payload — so ALL text blocks are parsed and object blocks shallow-merged
+     * (later blocks win on key collisions). Non-object blocks (e.g. the
+     * `DEBUG=1` "Response size" note) are collected under `_extra` (or
+     * `__extra` when the tool's payload already carries `_extra`).
+     *
+     * The merged object always carries `success`: derived from the MCP-level
+     * `isError` flag unless the tool set it explicitly.
+     */
     parseContent(toolResult: any): unknown;
 }
 export type ModalityClientInstance = ModalityClientImpl;

package/dist/types/__tests__/CLIBrowserOAuthProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/ModalityClient.parseContent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/mcp-oauth-provider.d.ts

@@ -11,8 +11,28 @@ interface CLIBrowserOAuthProviderOptions {
     /**
      * Port for the local callback server.
      * Defaults to 9876 for a stable redirect_uri across runs.
+     * Ignored when `externalCallback` is set.
      */
     callbackPort?: number;
+    /**
+     * Route the OAuth redirect through an existing HTTP server instead of
+     * starting a local Bun.serve. When set, the provider binds no port of its
+     * own — the host app must forward the redirect request to `handleCallback()`.
+     * `port`/`path`/`host` define the advertised redirect_uri and must match the
+     * host server (defaults: host "127.0.0.1", path "/callback").
+     * Correlate the inbound callback to this provider via `oauthState`.
+     */
+    externalCallback?: {
+        port: number;
+        path?: string;
+        host?: string;
+    };
+    /**
+     * Invoked with the full authorization URL just before the browser opens.
+     * Lets the host correlate the later callback to this provider (e.g. by
+     * reading the `state` query param, which equals `oauthState`).
+     */
+    onAuthorizationUrl?: (url: URL) => void;
     /**
      * Skip opening the system browser automatically.
      * When true the authorization URL is printed but not launched.
@@ -58,8 +78,12 @@ export declare class CLIBrowserOAuthProvider implements OAuthClientProvider {
     private readonly _serverIdentity;
     private readonly _noOpen;
     private readonly _cachePath;
+    private readonly _callbackPath;
+    private readonly _callbackHost;
+    private readonly _state;
+    private readonly _onAuthorizationUrl?;
     private _port;
-    private _server;
+    private _server?;
     private _resolveCode?;
     private _rejectCode?;
     private _pendingCode;
@@ -89,16 +113,36 @@ export declare class CLIBrowserOAuthProvider implements OAuthClientProvider {
      * auth-method string the registration response contained.
      */
     readonly addClientAuthentication: AddClientAuthentication;
+    /**
+     * CSRF `state` echoed back on the redirect. The SDK reads this via the
+     * optional `state()` hook and appends it to the authorization request; the
+     * callback validates it. Also used by host apps to correlate an external
+     * callback to this provider instance.
+     */
+    state(): string;
     redirectToAuthorization(authorizationUrl: URL): Promise<void>;
     /**
      * Resolves with the authorization code once the browser redirect completes.
      */
     waitForCode(): Promise<string>;
+    /** CSRF state for this flow — key an external callback route by this value. */
+    get oauthState(): string;
+    /** Advertised redirect path — the route an external host server must expose. */
+    get callbackPath(): string;
+    /**
+     * Handle an OAuth redirect request forwarded from an external host server
+     * (externalCallback mode). Resolves waitForCode() and returns the page to
+     * render in the browser tab.
+     */
+    handleCallback(req: Request): Response;
     /** Discovery state captured before registration — available even when registration fails. */
     getDiscoveryState(): OAuthDiscoveryState | undefined;
     /** Clear cached tokens only — forces browser re-auth on next run while keeping client registration. */
     clearCache(): void;
-    /** Stop the local callback HTTP server. Call once auth is complete. */
+    /**
+     * Stop the local callback HTTP server. Call once auth is complete.
+     * No-op in externalCallback mode, where the host owns the server.
+     */
     stop(): void;
     private _loadCache;
     private _persistCache;

package/package.json

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