@atlassian/mcp-compressor 0.33.0 → 0.33.1

package/README.md

@@ -72,7 +72,7 @@ atlassian search-confluence --query oauth
 atlassian get-jira-issue --issue-url https://jira.example.com/browse/PROJ-123
 ```
 
-TOON output formatting is automatically enabled in CLI mode.
+Tool output is returned verbatim in CLI mode. Pass `--toonify` to opt in to TOON conversion of JSON, CSV and YAML results.
 
 ### Bash mode
 

package/dist/cli.js

@@ -64,12 +64,11 @@ function buildProgram(options = {}) {
         .option("--toonify", "Convert JSON, CSV and YAML tool responses to TOON format automatically.")
         .option("--cli-mode", "Start in CLI mode: expose a single help MCP tool, start a local HTTP\n" +
         "bridge, and generate a shell script for interacting with the wrapped\n" +
-        "server via CLI. --toonify is automatically enabled in this mode.")
+        "server via CLI.")
         .option("--cli-port <port>", "Port for the local CLI bridge HTTP server (default: random free port).")
         .option("--just-bash", "Start in just-bash mode: expose a single 'bash' MCP tool powered by\n" +
         "just-bash, with all backend server tools available as custom commands.\n" +
-        "Requires the 'just-bash' package to be installed. --toonify is\n" +
-        "automatically enabled in this mode.")
+        "Requires the 'just-bash' package to be installed.")
         .option("--include-tool <tool>", "Wrapped server tool name to expose. Can be used multiple times.\n" +
         "If omitted, all tools are included.", collect, [])
         .option("--exclude-tool <tool>", "Wrapped server tool name to hide. Can be used multiple times.", collect, []);
@@ -85,7 +84,7 @@ function parseCliArgsWithOptions(argv, parseOptions = {}) {
     const backend = parseBackendArg(program.args);
     const justBash = parsedOptions.justBash ?? false;
     const cliMode = parsedOptions.cliMode ?? false;
-    const toonify = (parsedOptions.toonify ?? false) || cliMode || justBash;
+    const toonify = parsedOptions.toonify ?? false;
     return {
         backend,
         justBash,

package/dist/native.d.ts

@@ -20,7 +20,7 @@ export interface NativeCore {
     listOauthCredentialsJson(): string;
     clearOauthCredentialsJson(target?: string | null): string;
     startCompressedSessionJson(configJson: string, backendsJson: string): Promise<NativeCompressedSession>;
-    startCompressedSessionWithProviderBackendsJson(configJson: string, backendsJson: string, providersJson: string): Promise<NativeCompressedSession>;
+    startCompressedSessionWithProviderBackendsJson(configJson: string, backendsJson: string, providersJson: string, refreshProviders: () => Promise<string>): Promise<NativeCompressedSession>;
     startCompressedSessionFromMcpConfigJson(configJson: string, mcpConfigJson: string): Promise<NativeCompressedSession>;
 }
 export interface NativeCompressedSession {

package/dist/native_client.d.ts

@@ -70,10 +70,8 @@ export declare function adoptNativeSession<T>(session: {
 export declare class CompressorProxy {
     private readonly session;
     private readonly defaultServer;
-    private readonly authProviders;
     private closed;
-    constructor(session: CompressedSession, defaultServer: string | null, authProviders?: AuthProvider[]);
-    private refreshAuthProviders;
+    constructor(session: CompressedSession, defaultServer: string | null);
     info(): CompressedSessionInfo;
     get bridgeUrl(): string;
     get token(): string;

package/dist/native_client.js

@@ -46,7 +46,7 @@ async function normalizeServersWithProviders(servers) {
     for (const [name, config] of Object.entries(servers)) {
         if (typeof config === "object" && config !== null && "url" in config) {
             const provider = providerFromConfig(config);
-            const backend = await sdkObjectToNative(name, config, { includeProvider: true });
+            const backend = await sdkObjectToNative(name, config, { includeProvider: provider === undefined });
             if (provider !== undefined) {
                 backend.providerIndex = providers.length;
                 providers.push(provider);
@@ -180,22 +180,10 @@ export function adoptNativeSession(session, build) {
 export class CompressorProxy {
     session;
     defaultServer;
-    authProviders;
     closed = false;
-    constructor(session, defaultServer, authProviders = []) {
+    constructor(session, defaultServer) {
         this.session = session;
         this.defaultServer = defaultServer;
-        this.authProviders = authProviders;
-    }
-    async refreshAuthProviders() {
-        await Promise.all(this.authProviders.map(async (provider, index) => {
-            const headers = await provider();
-            const materialized = {};
-            for (const [key, value] of Object.entries(headers)) {
-                materialized[key] = String(value);
-            }
-            this.session.updateAuthProviderHeaders(index, materialized);
-        }));
     }
     info() {
         return this.session.info();
@@ -233,7 +221,6 @@ export class CompressorProxy {
         if (this.closed) {
             throw new Error("Compressor proxy is closed");
         }
-        await this.refreshAuthProviders();
         const response = await fetch(`${this.bridgeUrl}/exec`, {
             method: "POST",
             headers: {
@@ -372,7 +359,7 @@ export class CompressorClient {
                 ? await startCompressedSessionWithAuthProviders(config, normalized.backends, normalized.providers)
                 : await startCompressedSession(config, normalized.backends);
         const proxy = adoptNativeSession(session, () => {
-            const adopted = new CompressorProxy(session, this.defaultServer(), this.authProviders);
+            const adopted = new CompressorProxy(session, this.defaultServer());
             proxyCloseCallbacks.set(adopted, () => {
                 if (this.proxy === adopted) {
                     this.proxy = null;

package/dist/rust_core.js

@@ -88,13 +88,19 @@ export async function startCompressedSession(config, backends) {
     const session = await loadNativeCore().startCompressedSessionJson(stringify(toNativeSessionConfig(config)), stringify(backends.map(toNativeBackendConfig)));
     return new CompressedSession(session);
 }
+async function materializeAuthProviderHeaders(providers) {
+    return Promise.all(providers.map(async (provider) => {
+        const headers = await provider();
+        return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, String(value)]));
+    }));
+}
 export async function startCompressedSessionWithAuthProviders(config, backends, providers) {
     const nativeBackends = backends.map((backend) => ({
         ...toNativeBackendConfig(backend),
         provider_index: backend.providerIndex ?? null,
     }));
-    const initialHeaders = await Promise.all(providers.map((provider) => provider()));
-    const session = await loadNativeCore().startCompressedSessionWithProviderBackendsJson(stringify(toNativeSessionConfig(config)), stringify(nativeBackends), stringify(initialHeaders));
+    const initialHeaders = await materializeAuthProviderHeaders(providers);
+    const session = await loadNativeCore().startCompressedSessionWithProviderBackendsJson(stringify(toNativeSessionConfig(config)), stringify(nativeBackends), stringify(initialHeaders), async () => stringify(await materializeAuthProviderHeaders(providers)));
     return new CompressedSession(session);
 }
 export async function startCompressedSessionFromMcpConfig(config, mcpConfigJson) {

package/dist/transforms.d.ts

@@ -3,10 +3,16 @@ import { type JustBashCommandRegistration } from "./just_bash_commands.js";
 export interface TransformToolOptions {
     serverName?: string;
 }
-export interface TransformToolsForJustBashOptions extends TransformToolOptions {
-    bash: unknown;
-}
 export interface PlanToolsForJustBashOptions extends TransformToolOptions {
+    /**
+     * Convert JSON/CSV/YAML tool results to TOON before writing them to stdout.
+     * Defaults to ``false`` so Just Bash output matches the generated CLI byte for
+     * byte (and stays pipeable into tools such as ``jq``).
+     */
+    toonify?: boolean;
+}
+export interface TransformToolsForJustBashOptions extends PlanToolsForJustBashOptions {
+    bash: unknown;
 }
 export interface JustBashTransformResult {
     tools: Record<string, ExecutableTool>;

package/dist/transforms.js

@@ -6,7 +6,7 @@ export function planToolsForJustBash(tools, options = {}) {
     const serverName = normalizeServerName(options.serverName);
     const toolSpecs = executableToolsToSpecs(tools);
     const plan = buildHostTransformPlan({ kind: "just-bash", serverName, tools: toolSpecs });
-    const registrations = createJustBashCommandRegistrations((plan.justBash?.commands ?? []).map((command) => justBashSource(serverName, command.commandName, command.backendToolName, tools)));
+    const registrations = createJustBashCommandRegistrations((plan.justBash?.commands ?? []).map((command) => justBashSource(serverName, command.commandName, command.backendToolName, tools, options.toonify ?? false)));
     return {
         registrations,
         tools: helpTools({
@@ -38,7 +38,7 @@ export async function transformToolsForCliMode(tools, options = {}) {
         commandName: serverName,
     });
 }
-function justBashSource(serverName, commandName, backendToolName, tools) {
+function justBashSource(serverName, commandName, backendToolName, tools, toonify) {
     const tool = tools[backendToolName];
     if (tool === undefined) {
         throw new Error(`missing Just Bash backend tool: ${backendToolName}`);
@@ -49,7 +49,7 @@ function justBashSource(serverName, commandName, backendToolName, tools) {
         backendToolName,
         helpToolName: `${serverName}_help`,
         tool: executableToolToSpec(backendToolName, tool),
-        invoke: async (input) => normalizeHostToolResult(await tool.execute(input), true),
+        invoke: async (input) => normalizeHostToolResult(await tool.execute(input), toonify),
     };
 }
 async function generatedTransform(tools, options) {

package/native/index.d.ts

@@ -40,4 +40,4 @@ export declare function startCompressedSessionFromMcpConfigJson(configJson: stri
 
 export declare function startCompressedSessionJson(configJson: string, backendsJson: string): Promise<NativeCompressedSession>
 
-export declare function startCompressedSessionWithProviderBackendsJson(configJson: string, backendsJson: string, providersJson: string): Promise<NativeCompressedSession>
+export declare function startCompressedSessionWithProviderBackendsJson(configJson: string, backendsJson: string, providersJson: string, refreshProviders: RefreshProviders): Promise<NativeCompressedSession>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlassian/mcp-compressor",
-  "version": "0.33.0",
+  "version": "0.33.1",
   "description": "TypeScript MCP server wrapper for reducing tokens consumed by MCP tools.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/atlassian-labs/mcp-compressor",