ai 4.3.11 → 4.3.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "4.3.11",
+  "version": "4.3.12",
   "description": "AI SDK by Vercel - The AI Toolkit for TypeScript and JavaScript",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -9,7 +9,7 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*",
-    "mcp-stdio/**/*",
+    "mcp-stdio/dist/**/*",
     "react/dist/**/*",
     "rsc/dist/**/*",
     "test/dist/**/*",

package/mcp-stdio/create-child-process.test.ts

@@ -1,93 +0,0 @@
-import { beforeEach, vi } from 'vitest';
-import * as getEnvironmentModule from './get-environment';
-
-const DEFAULT_ENV = {
-  PATH: 'path',
-};
-
-const mockGetEnvironment = vi
-  .fn()
-  .mockImplementation((customEnv?: Record<string, string>) => {
-    return {
-      ...DEFAULT_ENV,
-      ...customEnv,
-    };
-  });
-vi.spyOn(getEnvironmentModule, 'getEnvironment').mockImplementation(
-  mockGetEnvironment,
-);
-
-// important: import after mocking getEnv
-const { createChildProcess } = await import('./create-child-process');
-
-describe('createChildProcess', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should spawn a child process', async () => {
-    const childProcess = createChildProcess(
-      { command: process.execPath },
-      new AbortController().signal,
-    );
-
-    expect(childProcess.pid).toBeDefined();
-    expect(mockGetEnvironment).toHaveBeenCalledWith(undefined);
-    childProcess.kill();
-  });
-
-  it('should spawn a child process with custom env', async () => {
-    const customEnv = { FOO: 'bar' };
-    const childProcessWithCustomEnv = createChildProcess(
-      { command: process.execPath, env: customEnv },
-      new AbortController().signal,
-    );
-
-    expect(childProcessWithCustomEnv.pid).toBeDefined();
-    expect(mockGetEnvironment).toHaveBeenCalledWith(customEnv);
-    expect(mockGetEnvironment).toHaveReturnedWith({
-      ...DEFAULT_ENV,
-      ...customEnv,
-    });
-    childProcessWithCustomEnv.kill();
-  });
-
-  it('should spawn a child process with args', async () => {
-    const childProcessWithArgs = createChildProcess(
-      { command: process.execPath, args: ['-c', 'echo', 'test'] },
-      new AbortController().signal,
-    );
-
-    expect(childProcessWithArgs.pid).toBeDefined();
-    expect(childProcessWithArgs.spawnargs).toContain(process.execPath);
-    expect(childProcessWithArgs.spawnargs).toEqual([
-      process.execPath,
-      '-c',
-      'echo',
-      'test',
-    ]);
-
-    childProcessWithArgs.kill();
-  });
-
-  it('should spawn a child process with cwd', async () => {
-    const childProcessWithCwd = createChildProcess(
-      { command: process.execPath, cwd: '/tmp' },
-      new AbortController().signal,
-    );
-
-    expect(childProcessWithCwd.pid).toBeDefined();
-    childProcessWithCwd.kill();
-  });
-
-  it('should spawn a child process with stderr', async () => {
-    const childProcessWithStderr = createChildProcess(
-      { command: process.execPath, stderr: 'pipe' },
-      new AbortController().signal,
-    );
-
-    expect(childProcessWithStderr.pid).toBeDefined();
-    expect(childProcessWithStderr.stderr).toBeDefined();
-    childProcessWithStderr.kill();
-  });
-});

package/mcp-stdio/create-child-process.ts

@@ -1,21 +0,0 @@
-import { ChildProcess, spawn } from 'node:child_process';
-import { getEnvironment } from './get-environment';
-import { StdioConfig } from './mcp-stdio-transport';
-
-export function createChildProcess(
-  config: StdioConfig,
-  signal: AbortSignal,
-): ChildProcess {
-  return spawn(config.command, config.args ?? [], {
-    env: getEnvironment(config.env),
-    stdio: ['pipe', 'pipe', config.stderr ?? 'inherit'],
-    shell: false,
-    signal,
-    windowsHide: globalThis.process.platform === 'win32' && isElectron(),
-    cwd: config.cwd,
-  });
-}
-
-function isElectron() {
-  return 'type' in globalThis.process;
-}

package/mcp-stdio/get-environment.test.ts

@@ -1,13 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getEnvironment } from './get-environment';
-
-describe('getEnvironment', () => {
-  it('should not mutate the original custom environment object', () => {
-    const customEnv = { CUSTOM_VAR: 'custom_value' };
-
-    const result = getEnvironment(customEnv);
-
-    expect(customEnv).toStrictEqual({ CUSTOM_VAR: 'custom_value' });
-    expect(result).not.toBe(customEnv);
-  });
-});

package/mcp-stdio/get-environment.ts

@@ -1,43 +0,0 @@
-/**
- * Constructs the environment variables for the child process.
- *
- * @param customEnv - Custom environment variables to merge with default environment variables.
- * @returns The environment variables for the child process.
- */
-export function getEnvironment(
-  customEnv?: Record<string, string>,
-): Record<string, string> {
-  const DEFAULT_INHERITED_ENV_VARS =
-    globalThis.process.platform === 'win32'
-      ? [
-          'APPDATA',
-          'HOMEDRIVE',
-          'HOMEPATH',
-          'LOCALAPPDATA',
-          'PATH',
-          'PROCESSOR_ARCHITECTURE',
-          'SYSTEMDRIVE',
-          'SYSTEMROOT',
-          'TEMP',
-          'USERNAME',
-          'USERPROFILE',
-        ]
-      : ['HOME', 'LOGNAME', 'PATH', 'SHELL', 'TERM', 'USER'];
-
-  const env: Record<string, string> = customEnv ? { ...customEnv } : {};
-
-  for (const key of DEFAULT_INHERITED_ENV_VARS) {
-    const value = globalThis.process.env[key];
-    if (value === undefined) {
-      continue;
-    }
-
-    if (value.startsWith('()')) {
-      continue;
-    }
-
-    env[key] = value;
-  }
-
-  return env;
-}

package/mcp-stdio/index.ts

@@ -1,4 +0,0 @@
-export {
-  StdioMCPTransport as Experimental_StdioMCPTransport,
-  type StdioConfig,
-} from './mcp-stdio-transport';

package/mcp-stdio/mcp-stdio-transport.test.ts

@@ -1,249 +0,0 @@
-import type { ChildProcess } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { JSONRPCMessage } from '../core/tool/mcp/json-rpc-message';
-import { MCPClientError } from '../errors';
-import { createChildProcess } from './create-child-process';
-import { StdioMCPTransport } from './mcp-stdio-transport';
-
-vi.mock('./create-child-process', { spy: true });
-
-interface MockChildProcess {
-  stdin: EventEmitter & { write?: ReturnType<typeof vi.fn> };
-  stdout: EventEmitter;
-  stderr: EventEmitter;
-  on: ReturnType<typeof vi.fn>;
-  removeAllListeners: ReturnType<typeof vi.fn>;
-}
-
-describe('StdioMCPTransport', () => {
-  let transport: StdioMCPTransport;
-  let mockChildProcess: MockChildProcess;
-  let mockStdin: EventEmitter & { write?: ReturnType<typeof vi.fn> };
-  let mockStdout: EventEmitter;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    mockStdin = new EventEmitter();
-    mockStdout = new EventEmitter();
-    mockChildProcess = {
-      stdin: mockStdin,
-      stdout: mockStdout,
-      stderr: new EventEmitter(),
-      on: vi.fn(),
-      removeAllListeners: vi.fn(),
-    };
-
-    vi.mocked(createChildProcess).mockReturnValue(
-      mockChildProcess as unknown as ChildProcess,
-    );
-
-    transport = new StdioMCPTransport({
-      command: 'test-command',
-      args: ['--test'],
-    });
-  });
-
-  afterEach(() => {
-    transport.close();
-  });
-
-  describe('start', () => {
-    it('should successfully start the transport', async () => {
-      const stdinOnSpy = vi.spyOn(mockStdin, 'on');
-      const stdoutOnSpy = vi.spyOn(mockStdout, 'on');
-
-      mockChildProcess.on.mockImplementation(
-        (event: string, callback: () => void) => {
-          if (event === 'spawn') {
-            callback();
-          }
-        },
-      );
-
-      const startPromise = transport.start();
-      await expect(startPromise).resolves.toBeUndefined();
-
-      expect(mockChildProcess.on).toHaveBeenCalledWith(
-        'error',
-        expect.any(Function),
-      );
-      expect(mockChildProcess.on).toHaveBeenCalledWith(
-        'spawn',
-        expect.any(Function),
-      );
-      expect(mockChildProcess.on).toHaveBeenCalledWith(
-        'close',
-        expect.any(Function),
-      );
-
-      expect(stdinOnSpy).toHaveBeenCalledWith('error', expect.any(Function));
-      expect(stdoutOnSpy).toHaveBeenCalledWith('error', expect.any(Function));
-      expect(stdoutOnSpy).toHaveBeenCalledWith('data', expect.any(Function));
-    });
-
-    it('should throw error if already started', async () => {
-      mockChildProcess.on.mockImplementation(
-        (event: string, callback: () => void) => {
-          if (event === 'spawn') {
-            callback();
-          }
-        },
-      );
-      const firstStart = transport.start();
-      await expect(firstStart).resolves.toBeUndefined();
-      const secondStart = transport.start();
-      await expect(secondStart).rejects.toThrow(MCPClientError);
-    });
-
-    it('should handle spawn errors', async () => {
-      const error = new Error('Spawn failed');
-      const onErrorSpy = vi.fn();
-      transport.onerror = onErrorSpy;
-
-      // simulate `spawn` failure by emitting error event after returning child process
-      mockChildProcess.on.mockImplementation(
-        (event: string, callback: (err: Error) => void) => {
-          if (event === 'error') {
-            callback(error);
-          }
-        },
-      );
-
-      const startPromise = transport.start();
-      await expect(startPromise).rejects.toThrow('Spawn failed');
-      expect(onErrorSpy).toHaveBeenCalledWith(error);
-    });
-  });
-
-  describe('send', () => {
-    beforeEach(async () => {
-      mockChildProcess.on.mockImplementation(
-        (event: string, callback: () => void) => {
-          if (event === 'spawn') {
-            callback();
-          }
-        },
-      );
-      await transport.start();
-    });
-
-    it('should successfully send a message', async () => {
-      const message: JSONRPCMessage = {
-        jsonrpc: '2.0',
-        id: '1',
-        method: 'test',
-        params: {},
-      };
-
-      mockStdin.write = vi.fn().mockReturnValue(true);
-
-      await transport.send(message);
-
-      expect(mockStdin.write).toHaveBeenCalledWith(
-        JSON.stringify(message) + '\n',
-      );
-    });
-
-    it('should handle write backpressure', async () => {
-      const message: JSONRPCMessage = {
-        jsonrpc: '2.0',
-        id: '1',
-        method: 'test',
-        params: {},
-      };
-
-      mockStdin.write = vi.fn().mockReturnValue(false);
-
-      const sendPromise = transport.send(message);
-
-      mockStdin.emit('drain');
-
-      await expect(sendPromise).resolves.toBeUndefined();
-    });
-
-    it('should throw error if transport is not connected', async () => {
-      await transport.close();
-
-      const message: JSONRPCMessage = {
-        jsonrpc: '2.0',
-        id: '1',
-        method: 'test',
-        params: {},
-      };
-
-      await expect(transport.send(message)).rejects.toThrow(MCPClientError);
-    });
-  });
-
-  describe('message handling', () => {
-    const onMessageSpy = vi.fn();
-
-    beforeEach(async () => {
-      mockChildProcess.on.mockImplementation(
-        (event: string, callback: () => void) => {
-          if (event === 'spawn') {
-            callback();
-          }
-        },
-      );
-      transport.onmessage = onMessageSpy;
-      await transport.start();
-    });
-
-    it('should handle incoming messages correctly', async () => {
-      const message: JSONRPCMessage = {
-        jsonrpc: '2.0',
-        id: '1',
-        method: 'test',
-        params: {},
-      };
-
-      mockStdout.emit('data', Buffer.from(JSON.stringify(message) + '\n'));
-      expect(onMessageSpy).toHaveBeenCalledWith(message);
-    });
-
-    it('should handle partial messages correctly', async () => {
-      const message = {
-        jsonrpc: '2.0',
-        id: '1',
-        method: 'test',
-        params: {},
-      };
-
-      const messageStr = JSON.stringify(message);
-      mockStdout.emit('data', Buffer.from(messageStr.slice(0, 10)));
-      mockStdout.emit('data', Buffer.from(messageStr.slice(10) + '\n'));
-      expect(onMessageSpy).toHaveBeenCalledWith(message);
-    });
-  });
-
-  describe('close', () => {
-    const onCloseSpy = vi.fn();
-
-    beforeEach(async () => {
-      mockChildProcess.on.mockImplementation(
-        (event: string, callback: (code?: number) => void) => {
-          if (event === 'spawn') {
-            callback();
-          } else if (event === 'close') {
-            callback(0);
-          }
-        },
-      );
-      transport.onclose = onCloseSpy;
-      await transport.start();
-    });
-
-    it('should close the transport successfully', async () => {
-      await transport.close();
-
-      expect(mockChildProcess.on).toHaveBeenCalledWith(
-        'close',
-        expect.any(Function),
-      );
-      expect(onCloseSpy).toHaveBeenCalled();
-    });
-  });
-});

package/mcp-stdio/mcp-stdio-transport.ts

@@ -1,157 +0,0 @@
-import type { ChildProcess, IOType } from 'node:child_process';
-import { Stream } from 'node:stream';
-import {
-  JSONRPCMessage,
-  JSONRPCMessageSchema,
-} from '../core/tool/mcp/json-rpc-message';
-import { MCPTransport } from '../core/tool/mcp/mcp-transport';
-import { MCPClientError } from '../errors';
-import { createChildProcess } from './create-child-process';
-
-export interface StdioConfig {
-  command: string;
-  args?: string[];
-  env?: Record<string, string>;
-  stderr?: IOType | Stream | number;
-  cwd?: string;
-}
-
-export class StdioMCPTransport implements MCPTransport {
-  private process?: ChildProcess;
-  private abortController: AbortController = new AbortController();
-  private readBuffer: ReadBuffer = new ReadBuffer();
-  private serverParams: StdioConfig;
-
-  onclose?: () => void;
-  onerror?: (error: unknown) => void;
-  onmessage?: (message: JSONRPCMessage) => void;
-
-  constructor(server: StdioConfig) {
-    this.serverParams = server;
-  }
-
-  async start(): Promise<void> {
-    if (this.process) {
-      throw new MCPClientError({
-        message: 'StdioMCPTransport already started.',
-      });
-    }
-
-    return new Promise((resolve, reject) => {
-      try {
-        const process = createChildProcess(
-          this.serverParams,
-          this.abortController.signal,
-        );
-
-        this.process = process;
-
-        this.process.on('error', error => {
-          if (error.name === 'AbortError') {
-            this.onclose?.();
-            return;
-          }
-
-          reject(error);
-          this.onerror?.(error);
-        });
-
-        this.process.on('spawn', () => {
-          resolve();
-        });
-
-        this.process.on('close', _code => {
-          this.process = undefined;
-          this.onclose?.();
-        });
-
-        this.process.stdin?.on('error', error => {
-          this.onerror?.(error);
-        });
-
-        this.process.stdout?.on('data', chunk => {
-          this.readBuffer.append(chunk);
-          this.processReadBuffer();
-        });
-
-        this.process.stdout?.on('error', error => {
-          this.onerror?.(error);
-        });
-      } catch (error) {
-        reject(error);
-        this.onerror?.(error);
-      }
-    });
-  }
-
-  private processReadBuffer() {
-    while (true) {
-      try {
-        const message = this.readBuffer.readMessage();
-        if (message === null) {
-          break;
-        }
-
-        this.onmessage?.(message);
-      } catch (error) {
-        this.onerror?.(error as Error);
-      }
-    }
-  }
-
-  async close(): Promise<void> {
-    this.abortController.abort();
-    this.process = undefined;
-    this.readBuffer.clear();
-  }
-
-  send(message: JSONRPCMessage): Promise<void> {
-    return new Promise(resolve => {
-      if (!this.process?.stdin) {
-        throw new MCPClientError({
-          message: 'StdioClientTransport not connected',
-        });
-      }
-
-      const json = serializeMessage(message);
-      if (this.process.stdin.write(json)) {
-        resolve();
-      } else {
-        this.process.stdin.once('drain', resolve);
-      }
-    });
-  }
-}
-
-class ReadBuffer {
-  private buffer?: Buffer;
-
-  append(chunk: Buffer): void {
-    this.buffer = this.buffer ? Buffer.concat([this.buffer, chunk]) : chunk;
-  }
-
-  readMessage(): JSONRPCMessage | null {
-    if (!this.buffer) return null;
-
-    const index = this.buffer.indexOf('\n');
-    if (index === -1) {
-      return null;
-    }
-
-    const line = this.buffer.toString('utf8', 0, index);
-    this.buffer = this.buffer.subarray(index + 1);
-    return deserializeMessage(line);
-  }
-
-  clear(): void {
-    this.buffer = undefined;
-  }
-}
-
-function serializeMessage(message: JSONRPCMessage): string {
-  return JSON.stringify(message) + '\n';
-}
-
-export function deserializeMessage(line: string): JSONRPCMessage {
-  return JSONRPCMessageSchema.parse(JSON.parse(line));
-}