@kamilio/wire 0.1.9 → 0.1.11

package/node_modules/toolcraft/node_modules/tiny-mcp-client/package.json

@@ -1,12 +1,17 @@
 {
-  "name": "tiny-mcp-client",
-  "version": "0.1.0",
   "private": true,
+  "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "node ../../scripts/guard-package-dist.mjs && tsc"
+    "build": "node scripts/build.mjs",
+    "typecheck:contracts": "node scripts/check-http-headers-type-contract.mjs",
+    "test:unit": "cd ../.. && vitest run packages/tiny-mcp-client/src",
+    "test:slow": "cd ../.. && vitest run packages/tiny-mcp-client/tests"
   },
   "repository": {
     "type": "git",
@@ -15,6 +20,40 @@
   },
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "mcp-oauth": "*",
     "tiny-stdio-mcp-server": "*"
+  },
+  "poeCode": {
+    "inlinedDependencies": [
+      "mcp-oauth",
+      "tiny-stdio-mcp-server"
+    ]
+  },
+  "exports": {
+    ".": {
+      "types": {
+        "workerd": "./dist/index.browser.d.ts",
+        "browser": "./dist/index.browser.d.ts",
+        "default": "./dist/index.d.ts"
+      },
+      "workerd": "./dist/index.browser.js",
+      "browser": "./dist/index.browser.js",
+      "import": "./dist/index.js"
+    }
+  },
+  "imports": {
+    "#tiny-mcp-stream": {
+      "types": "./src/stream.node.ts",
+      "workerd": "./src/stream.browser.ts",
+      "browser": "./src/stream.browser.ts",
+      "default": "./src/stream.node.ts"
+    },
+    "#tiny-mcp-spawn": {
+      "types": "./src/spawn.node.ts",
+      "workerd": "./src/spawn.browser.ts",
+      "browser": "./src/spawn.browser.ts",
+      "worker": "./src/spawn.browser.ts",
+      "default": "./src/spawn.node.ts"
+    }
   }
 }

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+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/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/README.md

@@ -0,0 +1,296 @@
+# tiny-stdio-mcp-server
+
+Minimal [Model Context Protocol](https://modelcontextprotocol.io) server for Node.js. Type-safe tool definitions, rich content helpers for images/audio/files.
+
+## Install
+
+```sh
+npm install tiny-stdio-mcp-server
+```
+
+## Quick start
+
+```ts
+import { createServer, defineSchema } from "tiny-stdio-mcp-server";
+
+const schema = defineSchema({
+  text: { type: "string", description: "Text to reverse" }
+});
+
+createServer({ name: "my-server", version: "1.0.0" })
+  .tool("reverse", "Reverse a string", schema, ({ text }) => {
+    return text.split("").reverse().join("");
+  })
+  .listen();
+```
+
+Run it:
+
+```sh
+node my-server.js
+```
+
+Any MCP client (Claude Code, Codex, etc.) can connect to it over stdio.
+
+## API
+
+### `createServer(options)`
+
+Creates a new MCP server.
+
+```ts
+const server = createServer({ name: "my-server", version: "1.0.0" });
+```
+
+### `.tool(name, description, schema, handler, outputSchema?)`
+
+Register a tool. The handler receives typed args matching the schema and returns a string, content helper, array of content, or a typed object when `outputSchema` is supplied.
+
+```ts
+const schema = defineSchema({
+  query: { type: "string", description: "Search query" },
+  limit: { type: "number", description: "Max results", optional: true }
+});
+
+server.tool("search", "Search for things", schema, async ({ query, limit }) => {
+  // `query` is string, `limit` is number | undefined
+  return `Found results for: ${query}`;
+});
+```
+
+For structured-data tools, pass a root-object output schema. The server advertises it as MCP `Tool.outputSchema`, validates successful handler results, and returns them as `CallToolResult.structuredContent`. Plain object returns receive a JSON text backstop in `content[]` for older clients. Explicit `CallToolResult` values keep their handler-supplied content blocks; the JSON text backstop is added only when `content` is empty.
+
+```ts
+const input = defineSchema({
+  query: { type: "string" }
+});
+const output = defineSchema({
+  items: {
+    type: "array",
+    items: {
+      type: "object",
+      properties: {
+        title: { type: "string" },
+        score: { type: "number" }
+      },
+      required: ["title", "score"]
+    }
+  }
+});
+
+server.tool(
+  "search",
+  "Search",
+  input,
+  async ({ query }) => ({
+    items: [{ title: query, score: 1 }]
+  }),
+  output
+);
+```
+
+Object output schemas work across MCP versions; modern MCP also supports other JSON output types. Otherwise, supported JSON Schema keywords are accepted, including composition keywords, nullable type unions, and local `$defs`/`$ref` references. Input and output schemas compile synchronously during `.tool()` or `.registerTool()` registration, so malformed schemas throw immediately instead of failing on the first tool call.
+
+Successful structured results must satisfy `outputSchema`. Validation failures use JSON-RPC `-32602` for inputs and `-32603` for outputs, with formatted validation details in the message and the issue array in `error.data`. Explicit handler results with `isError: true` are passed through unchanged and are exempt from structured-content and output-schema validation.
+
+Tools whose natural result is prose, images, audio, files, or other content blocks should omit `outputSchema` and keep returning content.
+
+Handlers can throw `ToolError` to return a JSON-RPC tool error with a specific code, message, and optional structured `data` payload. The server forwards that `data` field in the JSON-RPC error response so clients can inspect machine-readable failure details.
+
+### Standard schemas, including Zod
+
+Pass schemas implementing Standard Schema v1 and Standard JSON Schema v1
+straight to `.tool()` or `.registerTool()`. Toolcraft schemas and Zod 4.5.4
+support both interfaces. Existing `defineSchema` and raw JSON Schema inputs
+continue to work on the same server.
+
+```ts
+import { z } from "zod"; // Your application's existing dependency
+import { createServer } from "tiny-stdio-mcp-server";
+
+createServer({ name: "search", version: "1" }).tool(
+  "search",
+  "Search",
+  z.object({ query: z.string(), limit: z.number().default(10) }),
+  ({ query, limit }) => `${query}: ${limit}`
+);
+```
+
+Tiny MCP has no Zod dependency, peer dependency, imports, or adapter setup.
+Detection uses the standard interfaces. Older libraries exposing validation
+without JSON Schema conversion fail clearly during registration.
+
+Discovery uses the schema's input JSON Schema and, when supplied, its output
+JSON Schema. Runtime parsing uses the original library, preserving defaults,
+coercions, transforms, refinements, and asynchronous validation. Handler arguments
+are inferred from parsed output; a handler's return value is checked against the
+output schema's accepted input. Output parsing runs once before structured content
+and fallback text are produced. Explicit error results skip output parsing.
+
+Input wire schemas must describe objects. Output schemas may describe any JSON
+value for modern MCP; older clients receive object structured content or text
+fallbacks for other values. Conversion failures occur at registration. Custom
+refinements remain runtime checks and cannot always appear in discovery JSON
+Schema. Async parsing shares the tool timeout and concurrency limits.
+`validateToolArguments: false` disables input parsing, including defaults and
+transforms; handlers then receive the original arguments.
+
+### `.listen()`
+
+Start listening on stdin/stdout (standard MCP stdio transport).
+
+```ts
+await server.listen();
+```
+
+### `.connect(transport)`
+
+Connect to a custom readable/writable stream pair.
+
+```ts
+await server.connect({ readable: process.stdin, writable: process.stdout });
+```
+
+### `.connectSDK(transport)`
+
+Connect using an SDK-compatible in-memory transport (for testing).
+
+```ts
+await server.connectSDK(sdkTransport);
+```
+
+### `.removeTool(name)` / `.notifyToolsChanged()`
+
+Dynamically add/remove tools at runtime and notify connected clients.
+
+## Configuration Options
+
+- `createServer({ name, version, toolCallTimeoutMs? })`: server identity plus an optional positive-integer tool timeout in milliseconds. Timed-out calls return JSON-RPC error `-32603`; handlers continue running in the background.
+- `.tool(name, description, schema, handler, outputSchema?)`: tool metadata, input schema, handler, and optional structured output schema.
+- `.connect({ readable, writable })`: custom stream transport for tests or embedded hosts.
+
+## `defineSchema(definition)`
+
+Type-safe schema builder. Returns a JSON Schema object with inferred TypeScript types.
+
+```ts
+const schema = defineSchema({
+  name: { type: "string", description: "User name" },
+  age: { type: "number", description: "User age", optional: true }
+});
+// Handler receives: { name: string; age?: number }
+```
+
+## Environment Variables
+
+This package does not read public environment variables.
+
+Supported types: `string`, `number`, `boolean`, `object`, `array`.
+
+## Content helpers
+
+Tool handlers can return rich content beyond plain text.
+
+### Images
+
+```ts
+import { Image } from "tiny-stdio-mcp-server";
+
+server.tool("screenshot", "Take a screenshot", schema, async () => {
+  return Image.fromBase64(base64Data, "image/png");
+  // or: await Image.fromUrl("https://example.com/image.png", { maxBytes: 2 * 1024 * 1024 })
+  // or: Image.fromBytes(uint8Array)
+});
+```
+
+Supported formats: PNG, JPEG, GIF, WebP.
+
+### Audio
+
+```ts
+import { Audio } from "tiny-stdio-mcp-server";
+
+server.tool("speak", "Text to speech", schema, async () => {
+  return Audio.fromBase64(base64Data, "audio/mpeg");
+  // or: await Audio.fromUrl("https://example.com/audio.mp3", { maxBytes: 2 * 1024 * 1024 })
+  // or: Audio.fromBytes(uint8Array, "mp3")
+});
+```
+
+Supported formats: MP3, WAV, OGG, M4A.
+
+Remote helpers (`Image.fromUrl`, `Audio.fromUrl`, and `File.fromUrl`) cap downloads at
+`DEFAULT_FROM_URL_MAX_BYTES` (5 MiB). Pass `{ maxBytes }` to set a positive integer byte limit per
+call; responses that exceed the limit are rejected before being converted to content blocks.
+
+### Files
+
+```ts
+import { File } from "tiny-stdio-mcp-server";
+
+server.tool("export", "Export data", schema, async () => {
+  return File.fromText(csvContent, "text/csv");
+  // or: File.fromBytes(uint8Array, "application/pdf")
+  // or: await File.fromUrl("https://example.com/report.pdf", { maxBytes: 2 * 1024 * 1024 })
+});
+```
+
+### Mixed content
+
+Return arrays to send multiple content blocks:
+
+```ts
+server.tool("analyze", "Analyze image", schema, async () => {
+  const image = await Image.fromUrl(url);
+  return [image, "Analysis complete: found 3 objects"];
+});
+```
+
+## Testing
+
+Use `createTestPair` with the official MCP SDK for in-memory testing:
+
+```ts
+import { createTestPair } from "tiny-stdio-mcp-server/testing";
+
+const server = createServer({ name: "test", version: "1.0.0" }).tool(
+  "ping",
+  "Ping",
+  defineSchema({}),
+  () => "pong"
+);
+
+const { client, cleanup } = await createTestPair(server);
+
+const result = await client.callTool({ name: "ping", arguments: {} });
+// result.content === [{ type: "text", text: "pong" }]
+
+await cleanup();
+```
+
+Requires `@modelcontextprotocol/sdk` as a dev dependency.
+
+## Environment variables
+
+This package exposes no environment variables. Remote content helpers use the runtime `fetch`
+implementation and do not read package-level configuration.
+
+## Configuration
+
+There are no package-level config files. Configure each server in code with `createServer(options)`,
+per-tool schemas, and per-call content helper options such as `maxBytes` for remote files.
+
+## License
+
+MIT
+
+## Protocol-only hosts
+
+Import `createProtocolServer` and `defineSchema` from
+`tiny-stdio-mcp-server/core` when your host supplies its own transport. This
+entry point loads no Node stdio modules. Use `createMessageSession()` for an
+isolated request lifecycle and close it when the transport completes. The
+`handleMessage` context accepts `localContext` for host-owned state; tool
+handlers receive it separately from client parameters and metadata. Use the
+ordinary root `createServer` export for `listen()` or `connect()`; the core
+entry point does not provide a stdio runtime.

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/base64.d.ts

@@ -0,0 +1 @@
+export declare function isBase64(value: string): boolean;

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/base64.js

@@ -0,0 +1,10 @@
+export function isBase64(value) {
+    if (value.length % 4 !== 0)
+        return false;
+    try {
+        return btoa(atob(value)) === value;
+    }
+    catch {
+        return false;
+    }
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/composition.json

@@ -0,0 +1,15 @@
+{
+  "schemaVersion": 1,
+  "packages": [
+    {
+      "name": "tiny-stdio-mcp-server",
+      "version": "0.1.29",
+      "license": "MIT"
+    },
+    {
+      "name": "toolcraft-schema",
+      "version": "0.0.893",
+      "license": "MIT"
+    }
+  ]
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/content/audio.d.ts

@@ -0,0 +1,18 @@
+import type { ContentAnnotations } from "../types.js";
+import { type FromUrlOptions } from "./remote.js";
+export interface AudioContent {
+    type: "audio";
+    annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
+    data: string;
+    mimeType: string;
+}
+export declare class Audio {
+    private readonly base64Data;
+    private readonly mimeType;
+    private constructor();
+    static fromUrl(url: string, options?: FromUrlOptions): Promise<Audio>;
+    static fromBytes(data: Uint8Array, format?: string): Audio;
+    static fromBase64(base64: string, mimeType: string): Audio;
+    toContentBlock(): AudioContent;
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/content/audio.js

@@ -0,0 +1,84 @@
+import { assertBase64, fileTypeFromBuffer, parseContentType, safeRemoteLabel } from "./mime.js";
+import { readRemoteBytes } from "./remote.js";
+const SUPPORTED_AUDIO_MIMES = new Set([
+    "audio/mpeg",
+    "audio/wav",
+    "audio/ogg",
+    "audio/mp4",
+]);
+const AUDIO_FORMAT_MAP = {
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    ogg: "audio/ogg",
+    m4a: "audio/mp4",
+    mpeg: "audio/mpeg",
+};
+export class Audio {
+    base64Data;
+    mimeType;
+    constructor(base64Data, mimeType) {
+        this.base64Data = base64Data;
+        this.mimeType = mimeType;
+    }
+    static async fromUrl(url, options) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch audio from ${safeRemoteLabel(url)}: ${response.status} ${response.statusText}`);
+        }
+        const data = await readRemoteBytes(response, "audio", url, options);
+        const detected = fileTypeFromBuffer(data);
+        let mimeType;
+        if (detected && SUPPORTED_AUDIO_MIMES.has(detected.mime)) {
+            mimeType = detected.mime;
+        }
+        else {
+            const contentType = parseContentType(response.headers.get("content-type")).mimeType;
+            if (contentType && SUPPORTED_AUDIO_MIMES.has(contentType)) {
+                mimeType = contentType;
+            }
+            else {
+                throw new Error(`Unable to detect audio MIME type from ${safeRemoteLabel(url)}`);
+            }
+        }
+        const base64 = Buffer.from(data).toString("base64");
+        return new Audio(base64, mimeType);
+    }
+    static fromBytes(data, format) {
+        let mimeType;
+        if (format) {
+            if (format.includes("/")) {
+                mimeType = format.toLowerCase();
+            }
+            else {
+                mimeType = AUDIO_FORMAT_MAP[format.toLowerCase()] || `audio/${format}`;
+            }
+            if (!SUPPORTED_AUDIO_MIMES.has(mimeType)) {
+                throw new Error(`Unsupported audio MIME type: ${mimeType}`);
+            }
+        }
+        else {
+            const detected = fileTypeFromBuffer(data);
+            if (!detected || !SUPPORTED_AUDIO_MIMES.has(detected.mime)) {
+                throw new Error("Unable to detect audio MIME type from bytes");
+            }
+            mimeType = detected.mime;
+        }
+        const base64 = Buffer.from(data).toString("base64");
+        return new Audio(base64, mimeType);
+    }
+    static fromBase64(base64, mimeType) {
+        assertBase64(base64);
+        const normalizedMimeType = mimeType.toLowerCase();
+        if (!SUPPORTED_AUDIO_MIMES.has(normalizedMimeType)) {
+            throw new Error(`Unsupported audio MIME type: ${normalizedMimeType}`);
+        }
+        return new Audio(base64, normalizedMimeType);
+    }
+    toContentBlock() {
+        return {
+            type: "audio",
+            data: this.base64Data,
+            mimeType: this.mimeType,
+        };
+    }
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/content/convert.d.ts

@@ -0,0 +1,20 @@
+import type { ContentAnnotations } from "../types.js";
+import { Image, type ImageContent } from "./image.js";
+import { Audio, type AudioContent } from "./audio.js";
+import { File, type EmbeddedResource } from "./file.js";
+import type { ResourceLink } from "../types.js";
+export interface TextContent {
+    type: "text";
+    annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
+    text: string;
+}
+export type ContentBlock = TextContent | ImageContent | AudioContent | EmbeddedResource | ResourceLink;
+type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type ToolReturn = undefined | JsonPrimitive | JsonObject | Image | Audio | File | ContentBlock | Array<undefined | JsonPrimitive | JsonObject | Image | Audio | File | ContentBlock>;
+export declare function toContentBlocks(result: ToolReturn): ContentBlock[];
+export {};

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/content/convert.js

@@ -0,0 +1,96 @@
+import { Image } from "./image.js";
+import { Audio } from "./audio.js";
+import { File } from "./file.js";
+import { isJsonValue } from "toolcraft-schema";
+function convertSingleValue(value) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return { type: "text", text: String(value) };
+    }
+    if (value === null) {
+        return { type: "text", text: "null" };
+    }
+    if (value instanceof Image) {
+        return value.toContentBlock();
+    }
+    if (value instanceof Audio) {
+        return value.toContentBlock();
+    }
+    if (value instanceof File) {
+        return value.toContentBlock();
+    }
+    if (!isJsonValue(value)) {
+        const content = Object.create(null, Object.getOwnPropertyDescriptors(value));
+        if (isJsonValue(content) && isContentBlock(content))
+            return content;
+        throw new TypeError("Tool return must be a JSON value or supported content helper");
+    }
+    if (isContentBlock(value)) {
+        return value;
+    }
+    return { type: "text", text: JSON.stringify(value) };
+}
+export function toContentBlocks(result) {
+    const ancestors = new Set();
+    const frames = [{ value: result, index: 0 }];
+    const blocks = [];
+    while (frames.length > 0) {
+        const frame = frames[frames.length - 1];
+        const value = frame.value;
+        if (value === undefined) {
+            frames.pop();
+            continue;
+        }
+        if (!Array.isArray(value)) {
+            frames.pop();
+            blocks.push(convertSingleValue(value));
+            continue;
+        }
+        if (frame.index === 0) {
+            if (ancestors.has(value))
+                throw new TypeError("Cyclic tool result array");
+            ancestors.add(value);
+        }
+        if (frame.index >= value.length) {
+            ancestors.delete(value);
+            frames.pop();
+            continue;
+        }
+        const entry = Object.getOwnPropertyDescriptor(value, String(frame.index++));
+        if (entry === undefined || !("value" in entry))
+            throw new TypeError("Tool result arrays must contain own data entries");
+        frames.push({ value: entry.value, index: 0 });
+    }
+    return blocks;
+}
+function isContentBlock(value) {
+    if (!hasOwnProperty(value, "type") || typeof value.type !== "string") {
+        return false;
+    }
+    if (value.type === "text") {
+        return hasOwnProperty(value, "text") && typeof value.text === "string";
+    }
+    if (value.type === "image" || value.type === "audio") {
+        return hasOwnProperty(value, "data")
+            && typeof value.data === "string"
+            && hasOwnProperty(value, "mimeType")
+            && typeof value.mimeType === "string";
+    }
+    if (value.type === "resource_link") {
+        return hasOwnProperty(value, "name") && typeof value.name === "string"
+            && hasOwnProperty(value, "uri") && typeof value.uri === "string";
+    }
+    if (value.type !== "resource" || !hasOwnProperty(value, "resource")) {
+        return false;
+    }
+    const resource = value.resource;
+    return typeof resource === "object"
+        && resource !== null
+        && hasOwnProperty(resource, "uri")
+        && typeof resource.uri === "string"
+        && (!hasOwnProperty(resource, "mimeType") || typeof resource.mimeType === "string")
+        && ((hasOwnProperty(resource, "text") && typeof resource.text === "string")
+            || (hasOwnProperty(resource, "blob") && typeof resource.blob === "string"));
+}
+function hasOwnProperty(value, name) {
+    return Object.prototype.hasOwnProperty.call(value, name);
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/content/file-type.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Minimal magic bytes detection for common media types.
+ * This can be replaced with `file-type` package (https://npm.im/file-type)
+ * if more comprehensive detection is needed. The API is designed to be
+ * compatible: fileTypeFromBuffer(data) returns { mime: string, ext: string } | undefined
+ */
+export interface FileTypeResult {
+    mime: string;
+    ext: string;
+}
+export declare function fileTypeFromBuffer(data: Uint8Array): FileTypeResult | undefined;