@guru-ai-product/ai-product-kit 0.2.251112183752 → 0.2.251113155253

package/mcp/knowledge/Specification.md

@@ -0,0 +1,138 @@
+# Specification
+
+<div id="enable-section-numbers" />
+
+[Model Context Protocol](https://modelcontextprotocol.io) (MCP) is an open protocol that
+enables seamless integration between LLM applications and external data sources and
+tools. Whether you're building an AI-powered IDE, enhancing a chat interface, or creating
+custom AI workflows, MCP provides a standardized way to connect LLMs with the context
+they need.
+
+This specification defines the authoritative protocol requirements, based on the
+TypeScript schema in
+[schema.ts](https://github.com/modelcontextprotocol/specification/blob/main/schema/2025-06-18/schema.ts).
+
+For implementation guides and examples, visit
+[modelcontextprotocol.io](https://modelcontextprotocol.io).
+
+The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD
+NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be
+interpreted as described in [BCP 14](https://datatracker.ietf.org/doc/html/bcp14)
+\[[RFC2119](https://datatracker.ietf.org/doc/html/rfc2119)]
+\[[RFC8174](https://datatracker.ietf.org/doc/html/rfc8174)] when, and only when, they
+appear in all capitals, as shown here.
+
+## Overview
+
+MCP provides a standardized way for applications to:
+
+* Share contextual information with language models
+* Expose tools and capabilities to AI systems
+* Build composable integrations and workflows
+
+The protocol uses [JSON-RPC](https://www.jsonrpc.org/) 2.0 messages to establish
+communication between:
+
+* **Hosts**: LLM applications that initiate connections
+* **Clients**: Connectors within the host application
+* **Servers**: Services that provide context and capabilities
+
+MCP takes some inspiration from the
+[Language Server Protocol](https://microsoft.github.io/language-server-protocol/), which
+standardizes how to add support for programming languages across a whole ecosystem of
+development tools. In a similar way, MCP standardizes how to integrate additional context
+and tools into the ecosystem of AI applications.
+
+## Key Details
+
+### Base Protocol
+
+* [JSON-RPC](https://www.jsonrpc.org/) message format
+* Stateful connections
+* Server and client capability negotiation
+
+### Features
+
+Servers offer any of the following features to clients:
+
+* **Resources**: Context and data, for the user or the AI model to use
+* **Prompts**: Templated messages and workflows for users
+* **Tools**: Functions for the AI model to execute
+
+Clients may offer the following features to servers:
+
+* **Sampling**: Server-initiated agentic behaviors and recursive LLM interactions
+* **Roots**: Server-initiated inquiries into uri or filesystem boundaries to operate in
+* **Elicitation**: Server-initiated requests for additional information from users
+
+### Additional Utilities
+
+* Configuration
+* Progress tracking
+* Cancellation
+* Error reporting
+* Logging
+
+## Security and Trust & Safety
+
+The Model Context Protocol enables powerful capabilities through arbitrary data access
+and code execution paths. With this power comes important security and trust
+considerations that all implementors must carefully address.
+
+### Key Principles
+
+1. **User Consent and Control**
+
+   * Users must explicitly consent to and understand all data access and operations
+   * Users must retain control over what data is shared and what actions are taken
+   * Implementors should provide clear UIs for reviewing and authorizing activities
+
+2. **Data Privacy**
+
+   * Hosts must obtain explicit user consent before exposing user data to servers
+   * Hosts must not transmit resource data elsewhere without user consent
+   * User data should be protected with appropriate access controls
+
+3. **Tool Safety**
+
+   * Tools represent arbitrary code execution and must be treated with appropriate
+     caution.
+     * In particular, descriptions of tool behavior such as annotations should be
+       considered untrusted, unless obtained from a trusted server.
+   * Hosts must obtain explicit user consent before invoking any tool
+   * Users should understand what each tool does before authorizing its use
+
+4. **LLM Sampling Controls**
+   * Users must explicitly approve any LLM sampling requests
+   * Users should control:
+     * Whether sampling occurs at all
+     * The actual prompt that will be sent
+     * What results the server can see
+   * The protocol intentionally limits server visibility into prompts
+
+### Implementation Guidelines
+
+While MCP itself cannot enforce these security principles at the protocol level,
+implementors **SHOULD**:
+
+1. Build robust consent and authorization flows into their applications
+2. Provide clear documentation of security implications
+3. Implement appropriate access controls and data protections
+4. Follow security best practices in their integrations
+5. Consider privacy implications in their feature designs
+
+## Learn More
+
+Explore the detailed specification for each protocol component:
+
+<CardGroup cols={5}>
+  <Card title="Architecture" icon="sitemap" href="/specification/2025-06-18/architecture" />
+
+  <Card title="Base Protocol" icon="code" href="/specification/2025-06-18/basic" />
+
+  <Card title="Server Features" icon="server" href="/specification/2025-06-18/server" />
+
+  <Card title="Client Features" icon="user" href="/specification/2025-06-18/client" />
+
+  <Card title="Contributing" icon="pencil" href="/development/contributing" />
+</CardGroup>

package/mcp/knowledge/guide.md

@@ -0,0 +1,54 @@
+# Building MCP with LLMs
+
+> Speed up your MCP development using LLMs such as Claude!
+
+This guide will help you use LLMs to help you build custom Model Context Protocol (MCP) servers and clients. We'll be focusing on Claude for this tutorial, but you can do this with any frontier LLM.
+
+## Preparing the documentation
+
+Before starting, gather the necessary documentation to help Claude understand MCP:
+
+1. Read the Introduction of [MCP](./Introduction%20to%20MCP.md)
+2. Read the [MCP documentation](./Building%20MCP%20with%20LLMs.md)
+3. Read the SDK Readme file [Python SDK](./MCP%20Python%20SDK%20Readme.md)
+4. Read the Specification of [MCP](./Specification.md)
+
+## Describing your server
+
+Once you've provided the documentation, clearly describe to Claude what kind of server you want to build. Be specific about:
+
+* What resources your server will expose
+* What tools it will provide
+* Any prompts it should offer
+* What external systems it needs to interact with
+
+For example:
+
+```
+Build an MCP server that:
+- Connects to my company's PostgreSQL database
+- Exposes table schemas as resources
+- Provides tools for running read-only SQL queries
+- Includes prompts for common data analysis tasks
+```
+
+## Best practices
+
+When building MCP servers:
+
+* Break down complex servers into smaller pieces
+* Test each component thoroughly before moving on
+* Keep security in mind - validate inputs and limit access appropriately
+* Document your code well for future maintenance
+* Follow MCP protocol specifications carefully
+
+## Next steps
+
+After you build your server:
+
+1. Review the generated code carefully
+2. Test the server with the MCP Inspector tool
+3. Connect it to Claude.app or other MCP clients
+4. Iterate based on real usage and feedback
+
+Source: [https://modelcontextprotocol.io/tutorials/building-mcp-with-llms](https://modelcontextprotocol.io/tutorials/building-mcp-with-llms)

package/mcp/knowledge/introduction of mcp.md

@@ -0,0 +1,140 @@
+# Introduction
+
+> Get started with the Model Context Protocol (MCP)
+
+MCP is an open protocol that standardizes how applications provide context to LLMs. Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect your devices to various peripherals and accessories, MCP provides a standardized way to connect AI models to different data sources and tools.
+
+## Why MCP?
+
+MCP helps you build agents and complex workflows on top of LLMs. LLMs frequently need to integrate with data and tools, and MCP provides:
+
+* A growing list of pre-built integrations that your LLM can directly plug into
+* The flexibility to switch between LLM providers and vendors
+* Best practices for securing your data within your infrastructure
+
+### General architecture
+
+At its core, MCP follows a client-server architecture where a host application can connect to multiple servers:
+
+```mermaid
+flowchart LR
+    subgraph "Your Computer"
+        Host["Host with MCP Client<br/>(Claude, IDEs, Tools)"]
+        S1["MCP Server A"]
+        S2["MCP Server B"]
+        D1[("Local<br/>Data Source A")]
+        Host <-->|"MCP Protocol"| S1
+        Host <-->|"MCP Protocol"| S2
+        S1 <--> D1
+    end
+    subgraph "Internet"
+        S3["MCP Server C"]
+        D2[("Remote<br/>Service B")]
+        D3[("Remote<br/>Service C")]
+        S2 <-->|"Web APIs"| D2
+        S3 <-->|"Web APIs"| D3
+    end
+    Host <-->|"MCP Protocol"| S3
+```
+
+* **MCP Hosts**: Programs like Claude Desktop, IDEs, or AI tools that want to access data through MCP
+* **MCP Clients**: Protocol clients that maintain 1:1 connections with servers
+* **MCP Servers**: Lightweight programs that each expose specific capabilities through the standardized Model Context Protocol
+* **Local Data Sources**: Your computer's files, databases, and services that MCP servers can securely access
+* **Remote Services**: External systems available over the internet (e.g., through APIs) that MCP servers can connect to
+
+## Get started
+
+Choose the path that best fits your needs:
+
+### Quick Starts
+
+<CardGroup cols={2}>
+  <Card title="For Server Developers" icon="bolt" href="/quickstart/server">
+    Get started building your own server to use in Claude for Desktop and other
+    clients
+  </Card>
+
+  <Card title="For Client Developers" icon="bolt" href="/quickstart/client">
+    Get started building your own client that can integrate with all MCP servers
+  </Card>
+
+  <Card title="For Claude Desktop Users" icon="bolt" href="/quickstart/user">
+    Get started using pre-built servers in Claude for Desktop
+  </Card>
+</CardGroup>
+
+### Examples
+
+<CardGroup cols={2}>
+  <Card title="Example Servers" icon="grid" href="/examples">
+    Check out our gallery of official MCP servers and implementations
+  </Card>
+
+  <Card title="Example Clients" icon="cubes" href="/clients">
+    View the list of clients that support MCP integrations
+  </Card>
+</CardGroup>
+
+## Tutorials
+
+<CardGroup cols={2}>
+  <Card title="Building MCP with LLMs" icon="comments" href="/tutorials/building-mcp-with-llms">
+    Learn how to use LLMs like Claude to speed up your MCP development
+  </Card>
+
+  <Card title="Debugging Guide" icon="bug" href="/docs/tools/debugging">
+    Learn how to effectively debug MCP servers and integrations
+  </Card>
+
+  <Card title="MCP Inspector" icon="magnifying-glass" href="/docs/tools/inspector">
+    Test and inspect your MCP servers with our interactive debugging tool
+  </Card>
+
+  <Card title="MCP Workshop (Video, 2hr)" icon="person-chalkboard" href="https://www.youtube.com/watch?v=kQmXtrmQ5Zg">
+    <iframe src="https://www.youtube.com/embed/kQmXtrmQ5Zg" />
+  </Card>
+</CardGroup>
+
+## Explore MCP
+
+Dive deeper into MCP's core concepts and capabilities:
+
+<CardGroup cols={2}>
+  <Card title="Core architecture" icon="sitemap" href="/docs/concepts/architecture">
+    Understand how MCP connects clients, servers, and LLMs
+  </Card>
+
+  <Card title="Resources" icon="database" href="/docs/concepts/resources">
+    Expose data and content from your servers to LLMs
+  </Card>
+
+  <Card title="Prompts" icon="message" href="/docs/concepts/prompts">
+    Create reusable prompt templates and workflows
+  </Card>
+
+  <Card title="Tools" icon="wrench" href="/docs/concepts/tools">
+    Enable LLMs to perform actions through your server
+  </Card>
+
+  <Card title="Sampling" icon="robot" href="/docs/concepts/sampling">
+    Let your servers request completions from LLMs
+  </Card>
+
+  <Card title="Transports" icon="network-wired" href="/docs/concepts/transports">
+    Learn about MCP's communication mechanism
+  </Card>
+</CardGroup>
+
+## Contributing
+
+Want to contribute? Check out our [Contributing Guide](/development/contributing) to learn how you can help improve MCP.
+
+## Support and Feedback
+
+Here's how to get help or provide feedback:
+
+* For bug reports and feature requests related to the MCP specification, SDKs, or documentation (open source), please [create a GitHub issue](https://github.com/modelcontextprotocol)
+* For discussions or Q\&A about the MCP specification, use the [specification discussions](https://github.com/modelcontextprotocol/specification/discussions)
+* For discussions or Q\&A about other MCP open source components, use the [organization discussions](https://github.com/orgs/modelcontextprotocol/discussions)
+* For bug reports, feature requests, and questions related to Claude.app and claude.ai's MCP integration, please see Anthropic's guide on [How to Get Support](https://support.anthropic.com/en/articles/9015913-how-to-get-support)

package/mcp/node_modules/.package-lock.json

@@ -0,0 +1,147 @@
+{
+  "name": "ai-product-kit-mcp",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/@modelcontextprotocol/sdk": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-0.5.0.tgz",
+      "integrity": "sha512-RXgulUX6ewvxjAG0kOpLMEdXXWkzWgaoCGaA2CwNW7cQCIphjpJhjpHSiaPdVCnisjRF/0Cm9KWHUuIoeiAblQ==",
+      "license": "MIT",
+      "dependencies": {
+        "content-type": "^1.0.5",
+        "raw-body": "^3.0.0",
+        "zod": "^3.23.8"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.0.tgz",
+      "integrity": "sha512-cf6L2Ds3h57VVmkZe+Pn+5APsT7FpqJtEhhieDCvrE2MK5Qk9MyffgQyuxQTm6BChfeZNtcOLHp9IcWRVcIcBQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/raw-body": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.1.tgz",
+      "integrity": "sha512-9G8cA+tuMS75+6G/TzW8OtLzmBDMo8p1JRxN5AZ+LAp8uxGA8V8GZm4GQ4/N5QNQEnLmg6SS7wyuSmbKepiKqA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.7.0",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}

package/mcp/node_modules/@modelcontextprotocol/sdk/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2024 Anthropic, PBC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/mcp/node_modules/@modelcontextprotocol/sdk/README.md

@@ -0,0 +1,110 @@
+# MCP TypeScript SDK
+
+TypeScript implementation of the Model Context Protocol (MCP), providing both client and server capabilities for integrating with LLM surfaces.
+
+## Overview
+
+The Model Context Protocol allows applications to provide context for LLMs in a standardized way, separating the concerns of providing context from the actual LLM interaction. This TypeScript SDK implements the full MCP specification, making it easy to:
+
+- Build MCP clients that can connect to any MCP server
+- Create MCP servers that expose resources, prompts and tools
+- Use standard transports like stdio and SSE
+- Handle all MCP protocol messages and lifecycle events
+
+## Installation
+
+```bash
+npm install @modelcontextprotocol/sdk
+```
+
+## Quick Start
+
+### Creating a Client
+
+```typescript
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio";
+
+const transport = new StdioClientTransport({
+  command: "path/to/server",
+});
+
+const client = new Client({
+  name: "example-client",
+  version: "1.0.0",
+});
+
+await client.connect(transport);
+
+// List available resources
+const resources = await client.request(
+  { method: "resources/list" },
+  ListResourcesResultSchema
+);
+
+// Read a specific resource
+const resourceContent = await client.request(
+  {
+    method: "resources/read",
+    params: {
+      uri: "file:///example.txt"
+    }
+  },
+  ReadResourceResultSchema
+);
+```
+
+### Creating a Server
+
+```typescript
+import { Server } from "@modelcontextprotocol/sdk/server";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio";
+
+const server = new Server({
+  name: "example-server",
+  version: "1.0.0",
+});
+
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  return {
+    resources: [
+      {
+        uri: "file:///example.txt",
+        name: "Example Resource",
+      },
+    ],
+  };
+});
+
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  if (request.params.uri === "file:///example.txt") {
+    return {
+      contents: [
+        {
+          uri: "file:///example.txt",
+          mimeType: "text/plain",
+          text: "This is the content of the example resource.",
+        },
+      ],
+    };
+  } else {
+    throw new Error("Resource not found");
+  }
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+```
+
+## Documentation
+
+- [MCP Specification](https://modelcontextprotocol.github.io)
+- [Example Servers](https://github.com/modelcontextprotocol/example-servers)
+
+## Contributing
+
+Issues and pull requests are welcome on GitHub at https://github.com/modelcontextprotocol/typescript-sdk.
+
+## License
+
+This project is licensed under the MIT License—see the [LICENSE](LICENSE) file for details.

package/mcp/node_modules/@modelcontextprotocol/sdk/dist/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/mcp/node_modules/@modelcontextprotocol/sdk/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}