toolcraft 0.0.5 → 0.0.7

package/node_modules/tiny-mcp-client/src/mcp-client-tiny-stdio-test-server-tools.test.ts

@@ -0,0 +1,143 @@
+import { createTestServer } from "tiny-stdio-mcp-test-server";
+import { describe, expect, it } from "vitest";
+import { McpClient, createTestPair } from "./internal.js";
+
+describe("McpClient integration tools with tiny-stdio-mcp-test-server", () => {
+  it("completes full lifecycle: connect, list tools, call each tool, and close", async () => {
+    const server = createTestServer();
+    const { client, cleanup } = await createTestPair(server, () =>
+      new McpClient({
+        clientInfo: {
+          name: "test-client",
+          version: "1.0.0",
+        },
+      })
+    );
+
+    try {
+      expect(client.serverInfo).toEqual({
+        name: "tiny-stdio-mcp-test-server",
+        version: "0.0.1",
+      });
+
+      const { tools } = await client.listTools();
+      const toolNames = tools.map((tool) => tool.name).sort();
+
+      expect(toolNames).toEqual(["caesar_cipher_encrypt", "word_of_the_day"]);
+
+      const expectedCallResultsByTool: Record<
+        string,
+        {
+          arguments: Record<string, unknown>;
+          result: { content: [{ type: "text"; text: string }] };
+        }
+      > = {
+        caesar_cipher_encrypt: {
+          arguments: { text: "hello" },
+          result: {
+            content: [{ type: "text", text: "khoor" }],
+          },
+        },
+        word_of_the_day: {
+          arguments: {},
+          result: {
+            content: [{ type: "text", text: "Bumfuzzle - to confuse or fluster someone" }],
+          },
+        },
+      };
+
+      for (const toolName of toolNames) {
+        const expectedCall = expectedCallResultsByTool[toolName];
+        expect(expectedCall).toBeDefined();
+
+        if (expectedCall === undefined) {
+          continue;
+        }
+
+        const result = await client.callTool({
+          name: toolName,
+          arguments: expectedCall.arguments,
+        });
+
+        expect(result).toEqual(expectedCall.result);
+      }
+    } finally {
+      await cleanup();
+    }
+
+    expect(client.state).toBe("closed");
+  });
+
+  it("lists caesar_cipher_encrypt and word_of_the_day via createTestPair", async () => {
+    const server = createTestServer();
+    const { client, cleanup } = await createTestPair(server, () =>
+      new McpClient({
+        clientInfo: {
+          name: "test-client",
+          version: "1.0.0",
+        },
+      })
+    );
+
+    try {
+      const result = await client.listTools();
+      const toolNames = result.tools.map((tool) => tool.name);
+
+      expect(result.tools).toHaveLength(2);
+      expect(toolNames).toContain("caesar_cipher_encrypt");
+      expect(toolNames).toContain("word_of_the_day");
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("returns khoor when calling caesar_cipher_encrypt with text=hello", async () => {
+    const server = createTestServer();
+    const { client, cleanup } = await createTestPair(server, () =>
+      new McpClient({
+        clientInfo: {
+          name: "test-client",
+          version: "1.0.0",
+        },
+      })
+    );
+
+    try {
+      const result = await client.callTool({
+        name: "caesar_cipher_encrypt",
+        arguments: { text: "hello" },
+      });
+
+      expect(result).toEqual({
+        content: [{ type: "text", text: "khoor" }],
+      });
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("returns the expected text for word_of_the_day", async () => {
+    const server = createTestServer();
+    const { client, cleanup } = await createTestPair(server, () =>
+      new McpClient({
+        clientInfo: {
+          name: "test-client",
+          version: "1.0.0",
+        },
+      })
+    );
+
+    try {
+      const result = await client.callTool({
+        name: "word_of_the_day",
+        arguments: {},
+      });
+
+      expect(result).toEqual({
+        content: [{ type: "text", text: "Bumfuzzle - to confuse or fluster someone" }],
+      });
+    } finally {
+      await cleanup();
+    }
+  });
+});

package/node_modules/tiny-mcp-client/src/mcp-lifecycle-types.compile-check.ts

@@ -0,0 +1,65 @@
+import type {
+  ClientCapabilities,
+  Implementation,
+  InitializeParams,
+  InitializeResult,
+  ServerCapabilities,
+} from "./index.js";
+
+const implementation: Implementation = {
+  name: "tiny-mcp-client",
+  version: "0.1.0",
+};
+
+const clientCapabilities: ClientCapabilities = {
+  roots: {},
+  sampling: {},
+  experimental: {
+    supportsFastPath: true,
+  },
+};
+
+const serverCapabilities: ServerCapabilities = {
+  prompts: {},
+  resources: {},
+  tools: {},
+  logging: {},
+  completions: {},
+  experimental: {
+    rollout: "beta",
+  },
+};
+
+const initializeParams: InitializeParams = {
+  protocolVersion: "2025-03-26",
+  capabilities: clientCapabilities,
+  clientInfo: implementation,
+};
+
+const initializeResult: InitializeResult = {
+  protocolVersion: "2025-03-26",
+  capabilities: serverCapabilities,
+  serverInfo: implementation,
+  instructions: "Do not execute destructive tools without confirmation.",
+};
+
+// @ts-expect-error Implementation.version is required.
+const implementationMissingVersion: Implementation = { name: "tiny-mcp-client" };
+
+// @ts-expect-error InitializeParams.protocolVersion is required.
+const initializeParamsMissingProtocolVersion: InitializeParams = {
+  capabilities: clientCapabilities,
+  clientInfo: implementation,
+};
+
+// @ts-expect-error InitializeResult.capabilities is required.
+const initializeResultMissingCapabilities: InitializeResult = {
+  protocolVersion: "2025-03-26",
+  serverInfo: implementation,
+};
+
+void implementationMissingVersion;
+void initializeParamsMissingProtocolVersion;
+void initializeResultMissingCapabilities;
+void initializeParams;
+void initializeResult;

package/node_modules/tiny-mcp-client/src/mcp-prompt-types.compile-check.ts

@@ -0,0 +1,66 @@
+import type {
+  ContentItem,
+  GetPromptResult,
+  Prompt,
+  PromptArgument,
+  PromptMessage,
+} from "./index.js";
+
+const promptArgument: PromptArgument = {
+  name: "topic",
+  description: "Topic to generate a prompt for",
+  required: true,
+};
+
+const prompt: Prompt = {
+  name: "summarize",
+  description: "Summarize provided text",
+  arguments: [promptArgument],
+};
+
+const promptMessage: PromptMessage = {
+  role: "user",
+  content: {
+    type: "text",
+    text: "Summarize this text.",
+  },
+};
+
+const promptResult: GetPromptResult = {
+  description: "Prompt for summarizing text",
+  messages: [promptMessage],
+};
+
+const contentItems: ContentItem[] = [promptMessage.content];
+
+// @ts-expect-error Prompt.name is required.
+const promptMissingName: Prompt = {
+  description: "missing name",
+};
+
+// @ts-expect-error PromptArgument.name is required.
+const promptArgumentMissingName: PromptArgument = {
+  description: "missing name",
+};
+
+const invalidPromptMessageRole: PromptMessage = {
+  // @ts-expect-error PromptMessage.role must be "user" | "assistant".
+  role: "system",
+  content: {
+    type: "text",
+    text: "nope",
+  },
+};
+
+// @ts-expect-error GetPromptResult.messages is required.
+const promptResultMissingMessages: GetPromptResult = {
+  description: "missing messages",
+};
+
+void contentItems;
+void prompt;
+void promptResult;
+void promptMissingName;
+void promptArgumentMissingName;
+void invalidPromptMessageRole;
+void promptResultMissingMessages;

package/node_modules/tiny-mcp-client/src/mcp-resource-types.compile-check.ts

@@ -0,0 +1,70 @@
+import type {
+  BlobResourceContents,
+  PaginatedParams,
+  PaginatedResult,
+  Resource,
+  ResourceContents,
+  ResourceTemplate,
+  TextResourceContents,
+} from "./index.js";
+
+const resource: Resource = {
+  uri: "file:///tmp/readme.md",
+  name: "README",
+  description: "Project readme",
+  mimeType: "text/markdown",
+  size: 1024,
+};
+
+const resourceTemplate: ResourceTemplate = {
+  uriTemplate: "file:///tmp/{filename}",
+  name: "Project file",
+  description: "Template for project files",
+  mimeType: "text/plain",
+};
+
+const paginatedParams: PaginatedParams = {
+  cursor: "next-page",
+};
+
+const paginatedResult: PaginatedResult = {
+  nextCursor: "cursor-2",
+};
+
+const textResourceContents: TextResourceContents = {
+  uri: resource.uri,
+  mimeType: "text/plain",
+  text: "hello",
+};
+
+const blobResourceContents: BlobResourceContents = {
+  uri: resource.uri,
+  mimeType: "application/octet-stream",
+  blob: "aGVsbG8=",
+};
+
+const resourceContentsItems: ResourceContents[] = [textResourceContents, blobResourceContents];
+
+// @ts-expect-error Resource.uri is required.
+const resourceMissingUri: Resource = {
+  name: "README",
+};
+
+// @ts-expect-error ResourceTemplate.uriTemplate is required.
+const resourceTemplateMissingUriTemplate: ResourceTemplate = {
+  name: "Project file",
+};
+
+// @ts-expect-error ResourceContents must include text or blob.
+const invalidResourceContents: ResourceContents = {
+  uri: resource.uri,
+  mimeType: "text/plain",
+};
+
+void resourceMissingUri;
+void resourceTemplateMissingUriTemplate;
+void invalidResourceContents;
+void resourceContentsItems;
+void paginatedParams;
+void paginatedResult;
+void resourceTemplate;

package/node_modules/tiny-mcp-client/src/mcp-tool-types.compile-check.ts

@@ -0,0 +1,117 @@
+import type {
+  AudioContent,
+  CallToolParams,
+  CallToolResult,
+  ContentItem,
+  EmbeddedResource,
+  ImageContent,
+  ResourceContents,
+  TextContent,
+  Tool,
+  ToolAnnotations,
+} from "./index.js";
+
+const annotations: ToolAnnotations = {
+  title: "Word of the day",
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false,
+};
+
+const tool: Tool = {
+  name: "word_of_the_day",
+  description: "Returns a random word.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      locale: { type: "string" },
+    },
+  },
+  annotations,
+};
+
+const callToolParams: CallToolParams = {
+  name: tool.name,
+  arguments: {
+    locale: "en-US",
+  },
+};
+
+const resourceContents: ResourceContents = {
+  uri: "file:///tmp/word.txt",
+  text: "quotidian",
+};
+
+const textContent: TextContent = {
+  type: "text",
+  text: "quotidian",
+};
+
+const imageContent: ImageContent = {
+  type: "image",
+  data: "YmFzZTY0",
+  mimeType: "image/png",
+};
+
+const audioContent: AudioContent = {
+  type: "audio",
+  data: "YmFzZTY0",
+  mimeType: "audio/wav",
+};
+
+const embeddedResource: EmbeddedResource = {
+  type: "resource",
+  resource: resourceContents,
+};
+
+const contentItems: ContentItem[] = [
+  textContent,
+  imageContent,
+  audioContent,
+  embeddedResource,
+];
+
+const callToolResult: CallToolResult = {
+  content: contentItems,
+};
+
+const callToolErrorResult: CallToolResult = {
+  content: [textContent],
+  isError: true,
+};
+
+// @ts-expect-error Tool.name is required.
+const toolMissingName: Tool = {
+  inputSchema: {},
+};
+
+// @ts-expect-error Tool.inputSchema is required.
+const toolMissingInputSchema: Tool = {
+  name: "word_of_the_day",
+};
+
+// @ts-expect-error CallToolParams.name is required.
+const callToolParamsMissingName: CallToolParams = {
+  arguments: {},
+};
+
+const invalidTextContent: TextContent = {
+  // @ts-expect-error TextContent.type must be "text".
+  type: "image",
+  text: "oops",
+};
+
+// @ts-expect-error EmbeddedResource.resource is required.
+const embeddedResourceMissingResource: EmbeddedResource = {
+  type: "resource",
+};
+
+void toolMissingName;
+void toolMissingInputSchema;
+void callToolParamsMissingName;
+void invalidTextContent;
+void embeddedResourceMissingResource;
+void callToolParams;
+void callToolResult;
+void callToolErrorResult;

package/node_modules/tiny-mcp-client/src/mcp-transport-types.compile-check.ts

@@ -0,0 +1,75 @@
+import type { Readable, Writable } from "node:stream";
+
+import {
+  HttpTransport,
+  type HttpTransportFetch,
+  type OAuthClientProvider,
+  type OAuthClientProviderOptions,
+  type OAuthDiscoveryCache,
+  type OAuthDiscoveryResult,
+} from "./index.js";
+import type { McpTransport, McpTransportClosedEvent } from "./index.js";
+
+declare const readable: Readable;
+declare const writable: Writable;
+
+const closedEvent: McpTransportClosedEvent = {
+  reason: new Error("transport closed"),
+};
+
+const transport: McpTransport = {
+  readable,
+  writable,
+  closed: Promise.resolve(closedEvent),
+  dispose(reason?: Error): void {
+    void reason;
+  },
+};
+
+const closed: Promise<McpTransportClosedEvent> = transport.closed;
+const customFetch: HttpTransportFetch = async () => new Response(null, { status: 202 });
+const oauthProvider: OAuthClientProvider = {
+  authorizeRequest: async () => {},
+  handleUnauthorized: async () => ({ action: "retry" }),
+};
+const oauthOptions: OAuthClientProviderOptions = {
+  provider: oauthProvider,
+};
+const oauthDiscoveryResult: OAuthDiscoveryResult = {
+  resource: "https://example.com/mcp",
+  resourceMetadataUrl: "https://example.com/.well-known/oauth-protected-resource/mcp",
+  resourceMetadata: {
+    resource: "https://example.com/mcp",
+    authorization_servers: ["https://auth.example.com"],
+  },
+  authorizationServer: "https://auth.example.com",
+  authorizationServerMetadataUrl:
+    "https://auth.example.com/.well-known/oauth-authorization-server",
+  authorizationServerMetadata: {
+    issuer: "https://auth.example.com",
+    authorization_endpoint: "https://auth.example.com/authorize",
+    token_endpoint: "https://auth.example.com/token",
+    response_types_supported: ["code"],
+    code_challenge_methods_supported: ["S256"],
+  },
+};
+const oauthDiscoveryCache: OAuthDiscoveryCache = {
+  get: () => oauthDiscoveryResult,
+  set: () => {},
+};
+const httpTransport: McpTransport = new HttpTransport({
+  url: "https://example.com/mcp",
+  headers: {
+    Authorization: "Bearer test",
+  },
+  fetch: customFetch,
+  oauth: oauthOptions,
+  oauthDiscoveryCache,
+});
+
+// @ts-expect-error reason must be an Error.
+const invalidClosedEvent: McpTransportClosedEvent = { reason: "closed" };
+
+void closed;
+void httpTransport;
+void invalidClosedEvent;

package/node_modules/tiny-mcp-client/src/mcp-utility-types.compile-check.ts

@@ -0,0 +1,181 @@
+import type {
+  CompleteParams,
+  CompleteResult,
+  CreateMessageParams,
+  CreateMessageResult,
+  LogLevel,
+  LogMessage,
+  ModelPreferences,
+  ProgressParams,
+  PromptReference,
+  ResourceReference,
+  Root,
+  SamplingMessage,
+} from "./index.js";
+
+const root: Root = {
+  uri: "file:///workspace",
+  name: "workspace",
+};
+
+const logLevel: LogLevel = "info";
+
+const logMessage: LogMessage = {
+  level: logLevel,
+  logger: "tiny-mcp-client",
+  data: {
+    message: "connected",
+  },
+};
+
+const progress: ProgressParams = {
+  progressToken: "request-1",
+  progress: 40,
+  total: 100,
+  message: "Processing",
+};
+
+const samplingMessage: SamplingMessage = {
+  role: "user",
+  content: {
+    type: "text",
+    text: "Generate a summary.",
+  },
+};
+
+const modelPreferences: ModelPreferences = {
+  hints: [{ name: "claude" }],
+  costPriority: 0.5,
+  speedPriority: 0.6,
+  intelligencePriority: 0.9,
+};
+
+const createMessageParams: CreateMessageParams = {
+  messages: [samplingMessage],
+  modelPreferences,
+  systemPrompt: "Be concise.",
+  includeContext: "none",
+  temperature: 0.3,
+  maxTokens: 512,
+  stopSequences: ["\n\n"],
+  metadata: {
+    traceId: "trace-1",
+  },
+};
+
+const createMessageResult: CreateMessageResult = {
+  model: "claude-sonnet-4.5",
+  role: "assistant",
+  content: {
+    type: "text",
+    text: "Here is the summary.",
+  },
+  stopReason: "endTurn",
+};
+
+const promptReference: PromptReference = {
+  type: "ref/prompt",
+  name: "summarize",
+};
+
+const resourceReference: ResourceReference = {
+  type: "ref/resource",
+  uri: "file:///workspace/{path}",
+};
+
+const completePromptParams: CompleteParams = {
+  ref: promptReference,
+  argument: {
+    name: "topic",
+    value: "machine learning",
+  },
+};
+
+const completeResourceParams: CompleteParams = {
+  ref: resourceReference,
+  argument: {
+    name: "path",
+    value: "docs/",
+  },
+};
+
+const completeResult: CompleteResult = {
+  completion: {
+    values: ["docs/guide.md", "docs/api.md"],
+    hasMore: true,
+    total: 10,
+  },
+};
+
+// @ts-expect-error Root.uri is required.
+const rootMissingUri: Root = {
+  name: "workspace",
+};
+
+// @ts-expect-error LogLevel must be one of syslog severities.
+const invalidLogLevel: LogLevel = "trace";
+
+// @ts-expect-error LogMessage.data is required.
+const logMessageMissingData: LogMessage = {
+  level: "info",
+};
+
+// @ts-expect-error ProgressParams.progressToken is required.
+const progressMissingToken: ProgressParams = {
+  progress: 1,
+};
+
+// @ts-expect-error CreateMessageParams.maxTokens is required.
+const createMessageParamsMissingMaxTokens: CreateMessageParams = {
+  messages: [samplingMessage],
+};
+
+const invalidSamplingRole: SamplingMessage = {
+  // @ts-expect-error SamplingMessage.role must be "user" | "assistant".
+  role: "system",
+  content: {
+    type: "text",
+    text: "invalid",
+  },
+};
+
+// @ts-expect-error CreateMessageResult.model is required.
+const createMessageResultMissingModel: CreateMessageResult = {
+  role: "assistant",
+  content: {
+    type: "text",
+    text: "missing model",
+  },
+  stopReason: "endTurn",
+};
+
+const invalidCompleteParams: CompleteParams = {
+  ref:
+    // @ts-expect-error CompleteParams.ref.type must be "ref/prompt" | "ref/resource".
+    { type: "prompt", name: "summarize" },
+  argument: {
+    name: "topic",
+    value: "a",
+  },
+};
+
+// @ts-expect-error CompleteResult.completion is required.
+const completeResultMissingCompletion: CompleteResult = {};
+
+void rootMissingUri;
+void invalidLogLevel;
+void logMessageMissingData;
+void progressMissingToken;
+void createMessageParamsMissingMaxTokens;
+void invalidSamplingRole;
+void createMessageResultMissingModel;
+void invalidCompleteParams;
+void completeResultMissingCompletion;
+void root;
+void logMessage;
+void progress;
+void createMessageParams;
+void createMessageResult;
+void completePromptParams;
+void completeResourceParams;
+void completeResult;