modality-ai 0.0.0

package/dist/types/ModalityClient.d.ts

@@ -0,0 +1,43 @@
+import { type StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { type SSEClientTransportOptions } from "@modelcontextprotocol/sdk/client/sse.js";
+export type TransportType = "http" | "stdio" | "sse";
+export interface HttpTransportConfig {
+    type: "http";
+    url: string;
+    options?: StreamableHTTPClientTransportOptions;
+}
+export interface StdioTransportConfig {
+    type: "stdio";
+    serverParams: StdioServerParameters;
+}
+export interface SSETransportConfig {
+    type: "sse";
+    url: string;
+    options?: SSEClientTransportOptions;
+}
+export type TransportConfig = HttpTransportConfig | StdioTransportConfig | SSETransportConfig;
+declare class ModalityClientImpl {
+    private client;
+    private transportConfig;
+    private timeout;
+    constructor(config: TransportConfig, timeout?: number);
+    private createTransport;
+    private getTransportIdentifier;
+    call(method: string, params?: any, autoParse?: boolean): Promise<any>;
+    callOnce(method: string, params?: any, autoParse?: boolean): Promise<any>;
+    callStream(method: string, params?: any, callback?: (p: any) => void): ReadableStream;
+    close(): void;
+    listTools(): Promise<any>;
+    parseContent(toolResult: any): any;
+}
+declare function http(url: string, timeout?: number, options?: StreamableHTTPClientTransportOptions): ModalityClientImpl;
+declare function stdio(serverParams: StdioServerParameters, timeout?: number): ModalityClientImpl;
+declare function sse(url: string, timeout?: number, options?: SSEClientTransportOptions): ModalityClientImpl;
+export declare const ModalityClient: {
+    http: typeof http;
+    stdio: typeof stdio;
+    sse: typeof sse;
+};
+export type ModalityClientInstance = ModalityClientImpl;
+export {};

package/dist/types/StreamingMCPTransportWrapper.d.ts

@@ -0,0 +1,19 @@
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Custom transport wrapper that captures FastMCP streaming content
+ * This intercepts HTTP streaming data sent via streamContent() calls using SSE
+ */
+export declare class StreamingMCPTransportWrapper implements Transport {
+    private transport;
+    private onStreamingContent?;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    constructor(url: string, onStreamingContent?: (content: string) => void);
+    private interceptStreamingMessage;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage | JSONRPCMessage[]): Promise<void>;
+    get sessionId(): string | undefined;
+}

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

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

package/dist/types/__tests__/AiModel.tools.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for AI Model Tool Support functionality
+ * Tests the new tool calling capabilities added to util_ai_model.ts
+ */
+export {};

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

@@ -0,0 +1,5 @@
+/**
+ * Unit Tests for AI Response Consistency
+ * Tests that ensure both Ollama and Gemini providers handle new features consistently
+ */
+export {};

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

@@ -0,0 +1,5 @@
+/**
+ * Unit Tests for Message ID Extraction Feature
+ * Tests the new message ID extraction logic from AI SDK responses
+ */
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { createAIChat, mergeToolCallsAndResults, OllamaProvider, } from "./util_ai_model";
+export { ModalityClient } from "./ModalityClient";
+export type { ModalityClientInstance } from "./ModalityClient";

package/dist/types/provider/VsCodeLmProvider.d.ts

@@ -0,0 +1,81 @@
+import { LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2FinishReason, LanguageModelV2StreamPart, LanguageModelV2Content, LanguageModelV2Usage, LanguageModelV2CallWarning, LanguageModelV2ResponseMetadata, SharedV2ProviderMetadata } from "@ai-sdk/provider";
+/**
+ * Provider configuration options specific to our provider
+ */
+export interface VsCodeLmProviderOptions {
+    model?: string;
+    apiUrl?: string;
+    timeout?: number;
+}
+/**
+ * Result interface for doGenerate method
+ */
+export interface VsCodeGenerateResult {
+    content: LanguageModelV2Content[];
+    finishReason: LanguageModelV2FinishReason;
+    usage: LanguageModelV2Usage;
+    warnings: LanguageModelV2CallWarning[];
+    response: LanguageModelV2ResponseMetadata;
+    providerMetadata?: SharedV2ProviderMetadata;
+}
+/**
+ * Result interface for doStream method
+ */
+export interface VsCodeStreamResult {
+    stream: ReadableStream<LanguageModelV2StreamPart>;
+    request?: {
+        body?: unknown;
+    };
+    response?: {
+        headers?: Record<string, string>;
+    };
+}
+/**
+ * VS Code Language Model Provider using ModalityClient for simplified architecture
+ */
+export declare class VsCodeLmProvider implements LanguageModelV2 {
+    readonly specificationVersion: "v2";
+    readonly provider: "vscode-lm";
+    readonly modelId: string;
+    readonly supportedUrls: Record<string, RegExp[]>;
+    private modalityClient;
+    constructor(options: VsCodeLmProviderOptions);
+    /**
+     * Dispose resources (simplified - ModalityClient handles its own cleanup)
+     */
+    dispose(): Promise<void>;
+    /**
+     * Extract and validate prompt from options
+     */
+    private getPrompt;
+    /**
+     * Parse tool calls with ultra-smart hybrid approach
+     */
+    private parseToolCalls;
+    /**
+     * ULTRATHINK MODE: Clean tool call markup with hybrid AI-powered system
+     * Uses tokenizer + parser + regex + JSON validation for 100% bulletproof cleaning
+     */
+    private cleanToolCalls;
+    /**
+     * Prepare request with tools
+     */
+    private prepareRequestWithTools;
+    /**
+     * Simple token estimation based on text length
+     */
+    private estimateTokens;
+    /**
+     * Create simplified Vercel AI SDK compatible stream with tool call support
+     */
+    private createVercelStream;
+    private returnError;
+    /**
+     * Main method to handle language model calls (non-streaming)
+     */
+    doGenerate(options: LanguageModelV2CallOptions): Promise<VsCodeGenerateResult>;
+    /**
+     * Handle streaming language model calls
+     */
+    doStream(options: LanguageModelV2CallOptions): Promise<VsCodeStreamResult>;
+}

package/dist/types/provider/__tests__/VsCodeLmProvider.test.d.ts

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

package/dist/types/provider/ollama-v2-adapter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Ollama V2 Adapter
+ *
+ * Clean V2-only adapter for ollama-ai-provider that converts V1 models to V2 interfaces.
+ * This adapter ensures compatibility with AI SDK 5.0 by providing V2-compliant models.
+ */
+import type { LanguageModelV2, EmbeddingModelV2 } from '@ai-sdk/provider';
+/**
+ * V2-compliant Ollama Provider
+ */
+export interface OllamaV2ProviderOptions {
+    baseURL?: string;
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+}
+export declare class OllamaV2Provider {
+    private provider;
+    constructor(options?: OllamaV2ProviderOptions);
+    /**
+     * Get V2-compliant language model
+     */
+    languageModel(modelId: string): LanguageModelV2;
+    /**
+     * Get V2-compliant embedding model
+     */
+    embeddingModel<VALUE = string>(modelId: string): EmbeddingModelV2<VALUE>;
+}
+/**
+ * Create a V2-compliant Ollama provider
+ */
+export declare function createOllamaV2(options?: OllamaV2ProviderOptions): OllamaV2Provider;

package/dist/types/schemas/schemas_modality.d.ts

@@ -0,0 +1,109 @@
+import { z } from "zod";
+export declare const DEFAULT_AI_PROVIDER = "gemini";
+export declare const OLLAMA_URL: string;
+export declare const chatMessageSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+        system: "system";
+    }>;
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const DEFAULT_OLLAMA_CONFIG: {
+    baseURL: string;
+    model: string;
+};
+export declare const DEFAULT_VSCODE_CONFIG: {
+    baseURL: string;
+    model: string;
+};
+export declare const DEFAULT_GEMINI_CONFIG: {
+    apiKey: string;
+    model: string;
+};
+export declare const vscodeConfigSchema: z.ZodObject<{
+    baseURL: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    model: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const ollamaConfigSchema: z.ZodObject<{
+    baseURL: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    model: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const geminiConfigSchema: z.ZodObject<{
+    apiKey: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    model: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+declare const chatOptionsSchema: z.ZodObject<{
+    temperature: z.ZodOptional<z.ZodNumber>;
+    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+    topP: z.ZodOptional<z.ZodNumber>;
+    toolChoice: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        none: "none";
+        required: "required";
+    }>>;
+    maxSteps: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const memoryOptionsSchema: z.ZodObject<{
+    maxMessages: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    showContext: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare const simpleModalityAnswerSchema: z.ZodObject<{
+    question: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    useMemory: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const providerEnum: z.ZodOptional<z.ZodEnum<{
+    ollama: "ollama";
+    gemini: "gemini";
+    vscode: "vscode";
+}>>;
+export declare const modalityAnswerSchema: z.ZodObject<{
+    question: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    useMemory: z.ZodDefault<z.ZodBoolean>;
+    provider: z.ZodOptional<z.ZodEnum<{
+        ollama: "ollama";
+        gemini: "gemini";
+        vscode: "vscode";
+    }>>;
+    ollama: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        baseURL: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        model: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>>;
+    gemini: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        apiKey: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        model: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>>;
+    vscode: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        baseURL: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        model: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>>;
+    chatOptions: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        toolChoice: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            none: "none";
+            required: "required";
+        }>>;
+        maxSteps: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    memoryOptions: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        maxMessages: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        showContext: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const conversationResetSchema: z.ZodObject<{
+    sessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ModalityAnswerSchema = z.input<typeof modalityAnswerSchema>;
+export type ChatMessageSchema = z.infer<typeof chatMessageSchema>;
+export type ChatOptionsSchema = z.infer<typeof chatOptionsSchema>;
+export type MemoryOptionsSchema = z.infer<typeof memoryOptionsSchema>;
+export type OllamaConfig = z.input<typeof ollamaConfigSchema>;
+export type VSCodeConfig = z.input<typeof vscodeConfigSchema>;
+export type GeminiConfig = z.input<typeof geminiConfigSchema>;
+export type ProviderType = z.input<typeof providerEnum>;
+export {};

package/dist/types/util_ai_model.d.ts

@@ -0,0 +1,149 @@
+/**
+ * AI Chat and Embedding Abstraction
+ * Supports both Gemini and Ollama providers for chat and embedding generation
+ */
+/**
+ * Type Imports
+ */
+import type { ModelMessage } from "ai";
+import type { AITools } from "modality-mcp-kit";
+import type { OllamaConfig, GeminiConfig, VSCodeConfig } from "./schemas/schemas_modality";
+export type AIProvider = "gemini" | "ollama" | "vscode";
+export interface AIConfig {
+    provider: AIProvider;
+    ollama?: OllamaConfig;
+    gemini?: GeminiConfig;
+    vscode?: VSCodeConfig;
+}
+export interface ChatOptions {
+    temperature?: number;
+    maxOutputTokens?: number;
+    topP?: number;
+    tools?: AITools;
+    toolChoice?: "auto" | "none" | "required" | {
+        type: "tool";
+        toolName: string;
+    };
+    rateLimitDelay?: number;
+    enableRateLimit?: boolean;
+    maxSteps?: number;
+}
+export interface ChatResponse {
+    content: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    toolCalls?: any[];
+    toolResults?: any[];
+    steps?: any[];
+    messageId?: string;
+}
+export interface AIProviderInterface {
+    generateEmbedding(text: string): Promise<number[]>;
+    chat(messages: ModelMessage[], options?: ChatOptions): Promise<ChatResponse>;
+    evict(): void;
+    getModel(): string;
+}
+/**
+ * Ollama AI Provider Implementation
+ */
+export declare class OllamaProvider implements AIProviderInterface {
+    private config;
+    constructor(config: OllamaConfig);
+    evict(): void;
+    getModel(): string;
+    /**
+     * Generate embeddings using Ollama
+     */
+    generateEmbedding(text: string): Promise<number[]>;
+    /**
+     * Generate chat response using Ollama
+     */
+    chat(messages: ModelMessage[], options?: ChatOptions): Promise<ChatResponse>;
+}
+export declare class GeminiProvider implements AIProviderInterface {
+    private config;
+    private model;
+    constructor(config: GeminiConfig);
+    evict(): void;
+    getModel(): string;
+    /**
+     * Generate embeddings using Gemini
+     */
+    generateEmbedding(text: string): Promise<number[]>;
+    /**
+     * Generate chat response using Gemini
+     */
+    chat(messages: ModelMessage[], options?: ChatOptions): Promise<ChatResponse>;
+}
+/**
+ * VS Code AI Provider Implementation
+ */
+export declare class VsCodeProvider implements AIProviderInterface {
+    private config;
+    private provider;
+    constructor(config: VSCodeConfig);
+    evict(): void;
+    getModel(): string;
+    /**
+     * Generate embeddings using VS Code provider
+     * Note: VS Code provider doesn't support embeddings, so we'll throw an error
+     */
+    generateEmbedding(_text: string): Promise<number[]>;
+    /**
+     * Generate chat response using VS Code provider
+     * Uses direct callGenerateText approach - SIMPLICITY FIRST!
+     */
+    chat(messages: ModelMessage[], options?: ChatOptions): Promise<ChatResponse>;
+}
+/**
+ * AI Chat Abstraction - Main class for managing different AI providers
+ */
+export declare class AIChat {
+    private provider;
+    private lastRequestTime;
+    constructor(config: AIConfig);
+    evict(): void;
+    getModel(): string;
+    /**
+     * Generate embeddings using the configured provider
+     */
+    generateEmbedding(text: string): Promise<number[]>;
+    /**
+     * Generate chat response using the configured provider
+     */
+    chat(messages: ModelMessage[], options?: ChatOptions): Promise<ChatResponse>;
+}
+/**
+ * Create a standalone function for generating embeddings (backwards compatibility)
+ */
+export declare function generateEmbedding(text: string, config: OllamaConfig): Promise<number[]>;
+/**
+ * Factory function to create AI chat instances
+ */
+export declare function createAIChat(config: AIConfig): AIChat;
+/**
+ * Convenience function to create Ollama chat instance
+ */
+export declare function createOllamaChat(config: OllamaConfig): AIChat;
+/**
+ * Convenience function to create Gemini chat instance
+ */
+export declare function createGeminiChat(config: GeminiConfig): AIChat;
+/**
+ * Convenience function to create VS Code chat instance
+ */
+export declare function createVsCodeChat(config: VSCodeConfig): AIChat;
+export declare function createTextMessage(role: "user" | "assistant" | "system", content: string): ModelMessage;
+export declare function createAssistantMessageWithToolCalls(toolCalls: Array<{
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, any>;
+}>): ModelMessage;
+export declare function buildMessagesWithToolResults(baseMessages: ModelMessage[], response: any): ModelMessage[];
+export declare function mergeToolCallsAndResults(response: any): {
+    call: any;
+    result: any;
+}[];

package/dist/types/util_tests/aiModelMocks.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared mock utilities for AI Model testing
+ * Centralizes mock class definitions to reduce duplication across test files
+ */
+export declare const mockOllamaError: Error;
+export declare const mockGeminiError: Error;
+export declare class MockOllamaProvider {
+    constructor(_config: any);
+    chat(_messages: any[], _options?: any): Promise<any>;
+}
+export declare class MockGeminiProvider {
+    constructor(_config: any);
+    chat(_messages: any[], _options?: any): Promise<any>;
+}
+export declare class MockAIChat {
+    private config;
+    constructor(config: any);
+    generateEmbedding(_text: string): Promise<any>;
+    chat(_messages: any[], _options?: any): Promise<any>;
+}
+export declare const createMockOllamaChat: (_config: any) => {
+    chat: () => Promise<never>;
+};
+export declare const createMockGeminiChat: (_config: any) => {
+    chat: () => Promise<never>;
+};
+export declare const createAiModelMockModule: () => {
+    OllamaProvider: typeof MockOllamaProvider;
+    GeminiProvider: typeof MockGeminiProvider;
+    AIChat: typeof MockAIChat;
+    createOllamaChat: (_config: any) => {
+        chat: () => Promise<never>;
+    };
+    createGeminiChat: (_config: any) => {
+        chat: () => Promise<never>;
+    };
+    AIConfig: any;
+    ChatOptions: any;
+    ChatResponse: any;
+};

package/dist/types/util_tests/modalityClientMocks.d.ts

@@ -0,0 +1,101 @@
+import { mock } from "bun:test";
+/**
+ * Centralized mock utilities for ModalityClient testing
+ * Provides reusable mocks with easy configuration and cleanup
+ */
+export interface MockModalityClient {
+    call: ReturnType<typeof mock>;
+    callOnce: ReturnType<typeof mock>;
+    callStream: ReturnType<typeof mock>;
+    listTools: ReturnType<typeof mock>;
+    close: ReturnType<typeof mock>;
+    parseContent?: ReturnType<typeof mock>;
+}
+export interface MockClientConfig {
+    shouldThrow?: boolean;
+    throwMessage?: string;
+    defaultResponses?: {
+        call?: any;
+        callOnce?: any;
+        callStream?: any;
+        listTools?: any;
+    };
+}
+/**
+ * Creates a mock ModalityClient with configurable behavior
+ */
+export declare function createMockModalityClient(config?: MockClientConfig): MockModalityClient;
+/**
+ * Creates mock factory functions for the ModalityClient namespace
+ */
+export declare function createMockModalityClientFactories(httpConfig?: MockClientConfig, stdioConfig?: MockClientConfig, sseConfig?: MockClientConfig): {
+    http: import("bun:test").Mock<() => MockModalityClient>;
+    stdio: import("bun:test").Mock<() => MockModalityClient>;
+    sse: import("bun:test").Mock<() => MockModalityClient>;
+};
+/**
+ * Utility to reset all mocks in a MockModalityClient
+ */
+export declare function resetMockModalityClient(mockClient: MockModalityClient): void;
+/**
+ * Utility to reset all factory mocks
+ */
+export declare function resetMockFactories(factories: ReturnType<typeof createMockModalityClientFactories>): void;
+/**
+ * Creates a complete mock module for ModalityClient
+ */
+export declare function createModalityClientMockModule(config?: {
+    http?: MockClientConfig;
+    stdio?: MockClientConfig;
+    sse?: MockClientConfig;
+}): {
+    ModalityClient: {
+        http: import("bun:test").Mock<() => MockModalityClient>;
+        stdio: import("bun:test").Mock<() => MockModalityClient>;
+        sse: import("bun:test").Mock<() => MockModalityClient>;
+    };
+    __testFactories: {
+        http: import("bun:test").Mock<() => MockModalityClient>;
+        stdio: import("bun:test").Mock<() => MockModalityClient>;
+        sse: import("bun:test").Mock<() => MockModalityClient>;
+    };
+};
+/**
+ * Default successful responses for common test scenarios
+ */
+export declare const DEFAULT_RESPONSES: {
+    readonly SUCCESS: {
+        readonly call: {
+            readonly content: {
+                readonly message: "success";
+            };
+        };
+        readonly callOnce: {
+            readonly content: {
+                readonly message: "success";
+            };
+        };
+        readonly callStream: ReadableStream<any>;
+    };
+    readonly ERROR: {
+        readonly shouldThrow: true;
+        readonly throwMessage: "Mock client error";
+    };
+};
+/**
+ * Pre-configured mock scenarios for common test cases
+ */
+export declare const MOCK_SCENARIOS: {
+    /**
+     * Normal working client that returns successful responses
+     */
+    readonly WORKING_CLIENT: () => MockModalityClient;
+    /**
+     * Client that throws errors on all operations
+     */
+    readonly ERROR_CLIENT: () => MockModalityClient;
+    /**
+     * Client with custom responses
+     */
+    readonly CUSTOM_CLIENT: (responses: MockClientConfig["defaultResponses"]) => MockModalityClient;
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "version": "0.0.0",
+  "name": "modality-ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/react-atomic/modality.git"
+  },
+  "homepage": "https://github.com/react-atomic/modality/tree/main/modality-ai",
+  "description": "",
+  "keywords": [],
+  "author": "Hill <hill@kimo.com>",
+  "license": "ISC",
+  "peerDependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1"
+  },
+  "dependencies": {
+    "@ai-sdk/google": "^3.0.2",
+    "ai": "^6.0.5",
+    "modality-mcp-kit": "^0.4.0",
+    "ollama-ai-provider": "^1.2.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.5",
+    "modality-bun-kit": "^0.0.2",
+    "typescript": "^5.9.3"
+  },
+  "exports": {
+    "types": "./dist/types/index.d.ts",
+    "require": "./dist/index.js",
+    "import": "./dist/index.js"
+  },
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "scripts": {
+    "build:clean": "find ./dist -name '*.*' | xargs rm -rf",
+    "build:types": "bun tsc -p ./",
+    "build:src": "bun build src/index.ts --outdir dist --external @modelcontextprotocol/sdk",
+    "build": "bun run build:clean && bun run build:types && bun run build:src",
+    "dev": "bunx concurrently 'bun --watch tsc  -p ./' 'bun build:src -- --watch --sourcemap=inline'",
+    "test": "npm run build && bun test",
+    "prepublishOnly": "npm t"
+  },
+  "files": ["package.json", "README.md", "dist"]
+}