@lobsai/mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 noholdplease
+
+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/README.md

@@ -0,0 +1,67 @@
+# @lobsai/mcp
+
+Stdio MCP wrapper for the [lobs](https://noholdplease.com/api) phone-call service. Plug any stdio-based MCP client (Claude Desktop, Cursor, Cline, Continue, NanoClaw, OpenAI Agent SDK, Zed) into a real human operator that makes the actual phone call.
+
+## Install
+
+```jsonc
+// In your MCP client's config
+{
+  "mcpServers": {
+    "lobs": {
+      "command": "npx",
+      "args": ["-y", "@lobsai/mcp"],
+      "env": {
+        "LOBS_USER_ID": "your-stable-id"
+      }
+    }
+  }
+}
+```
+
+That's it. The wrapper exposes three tools — `create_call_task`, `get_task_status`, `cancel_task` — to your agent.
+
+## What is `LOBS_USER_ID`?
+
+A self-asserted identifier that scopes your tasks to a partition. There's no auth on the lobs server today; pick anything stable per user. Common values:
+
+- A phone number (digits only): `16263102445`
+- An email or username: `andy`
+- A UUID per session: `550e8400-e29b-41d4-a716-446655440000`
+
+If you omit it, the wrapper sends `anon`. Tasks then land in a shared `anon` bucket — fine for one-off testing, not for production.
+
+## What lobs does
+
+Your agent calls `create_call_task` with a goal and a target. A human operator picks it up, makes the phone call, and reports back. Your agent learns the result by polling `get_task_status` (or, optionally, by passing `user_phone` for an SMS callback).
+
+Three tools, eight args total. [Full surface docs](https://noholdplease.com/api).
+
+## Limits
+
+A global daily cap of **50 task creations** across all callers (UTC midnight rollover). Above the cap, `create_call_task` returns 429. Other tools are unlimited.
+
+This is real human capacity. Be respectful — each task is a phone call by a real person.
+
+## Configuration
+
+| Env var | Default | Description |
+|---|---|---|
+| `LOBS_USER_ID` | `anon` | Self-asserted user partition id. |
+| `LOBS_MCP_URL` | `https://lobs-ai--lobs-mcp-serve.modal.run/mcp` | Override only for testing against a non-prod lobs deployment. |
+
+## Smoke test
+
+```sh
+LOBS_USER_ID=smoke-test npm run smoke
+```
+
+Spawns the wrapper as a subprocess, connects via stdio, lists tools, asserts the 3 expected names appear.
+
+## Versioning
+
+Surface changes follow the lobs MCP server, not this wrapper. The wrapper is a near-passthrough — when lobs adds tools they automatically appear; when arg shapes change you'll see it in `tools/list`. The version in `package.json` bumps only when this wrapper itself changes (e.g. error handling, retries, defaults).
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@lobsai/mcp",
+  "version": "0.1.0",
+  "description": "Stdio MCP wrapper for the lobs phone-call service. Plug any MCP client into a real human operator.",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "lobs-mcp": "src/index.js"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "smoke": "node tests/smoke.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "phone-calls",
+    "ai-agent",
+    "lobs",
+    "noholdplease"
+  ],
+  "author": "noholdplease",
+  "license": "MIT",
+  "homepage": "https://noholdplease.com/api",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/noholdplease/lobs-ai.git",
+    "directory": "clients/mcp-stdio"
+  },
+  "bugs": {
+    "url": "https://github.com/noholdplease/lobs-ai/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/**
+ * @lobsai/mcp — stdio MCP wrapper for the lobs phone-call service.
+ *
+ * Bridges any stdio-based MCP client (Claude Desktop, Cursor, Cline,
+ * NanoClaw, etc.) to lobs's HTTP MCP server. Forwards tools/list and
+ * tools/call requests to https://lobs-ai--lobs-mcp-serve.modal.run/mcp
+ * and pipes responses back over stdio.
+ *
+ * Set LOBS_USER_ID in env to pick the partition your tasks live under
+ * (the lobs MCP has no auth — the id is self-asserted; defaults to
+ * "anon"). Phone digits are conventional for human users:
+ *
+ *   LOBS_USER_ID=16263102445 npx -y @lobsai/mcp
+ *
+ * Public docs: https://noholdplease.com/api
+ */
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+const ENDPOINT =
+  process.env.LOBS_MCP_URL || "https://lobs-ai--lobs-mcp-serve.modal.run/mcp";
+const USER_ID = (process.env.LOBS_USER_ID || "anon").trim() || "anon";
+
+async function main() {
+  // Outbound: HTTP client → lobs MCP. The SDK's streamable-HTTP
+  // transport handles SSE framing, JSON-RPC envelopes, reconnection.
+  const upstream = new Client(
+    { name: "lobs-stdio-wrapper", version: "0.1.0" },
+    { capabilities: {} },
+  );
+  const httpTransport = new StreamableHTTPClientTransport(new URL(ENDPOINT), {
+    requestInit: {
+      headers: { "X-User-Id": USER_ID },
+    },
+  });
+  await upstream.connect(httpTransport);
+
+  // Inbound: stdio server. Declare the same capabilities the upstream
+  // serves (just tools today). Forward each request type by piping
+  // params to the upstream client and returning its response.
+  const downstream = new Server(
+    { name: "lobs", version: "0.1.0" },
+    { capabilities: { tools: {} } },
+  );
+
+  downstream.setRequestHandler(ListToolsRequestSchema, async () => {
+    return await upstream.listTools();
+  });
+
+  downstream.setRequestHandler(CallToolRequestSchema, async (req) => {
+    return await upstream.callTool(req.params);
+  });
+
+  // Graceful shutdown — close upstream when stdio peer disconnects.
+  const shutdown = async () => {
+    try {
+      await upstream.close();
+    } catch {
+      /* best-effort */
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  await downstream.connect(new StdioServerTransport());
+}
+
+main().catch((err) => {
+  // Stderr only — stdio's stdout is reserved for the MCP protocol.
+  process.stderr.write(`[lobs-mcp] fatal: ${err?.stack || err}\n`);
+  process.exit(1);
+});