@nooticr/mcp 1.26.59 → 1.26.60

package/README.md

@@ -52,7 +52,7 @@ npx @nooticr/mcp login   # one-time sign-in (Google)
 
 ## Tools
 
-93 tools, grouped by what you are trying to do. Prices are in nooticr credits and
+100 tools, grouped by what you are trying to do. Prices are in nooticr credits and
 match what the server actually charges.
 
 The job tools under **Answer a question you actually have** are not
@@ -182,6 +182,13 @@ a `scanId` for the rest.
 | `nooticr_login` | free | Re-link the account when a call fails with an authentication error. |
 | `list_social_connections` | free | What you have connected and what each connection is actually allowed to do — read the account, publish a post, manage comments — as yes, no or **unknown**. "Manage comments" reports the platform's grant; no nooticr tool posts or replies to a comment. Unknown means the grant predates scope recording: treat it as "try it", not as a refusal. Also says which platforms can be linked at all, which is a smaller set than the networks nooticr reads. |
 | `connect_social_account` | free | A link the user opens to connect one account. They approve at the provider in their own browser; nothing is connected until they do, and no credential passes through the tool or the model's context. Each call mints a fresh link — an old one does not work twice. |
+| `hire_employee` | free to call | Hire an AI employee (for example a Social Media Manager) that works on a schedule inside your workspace. Two calls by design: the first creates nothing and returns a quote and a `confirmationToken`; call again with `confirm: true` and that token only after you say yes. Public actions wait for your approval unless autopilot is on. Its runs bill the hiring user, up to the monthly budget. |
+| `list_employees` | free | Your AI employees with status, schedule, next run and budget left; `includeFired: true` adds the ones let go. |
+| `pause_employee` | free | Pause an AI employee (it keeps its memory and thread) or resume it with `resume: true`. Only the person who hired it or a workspace admin can. |
+| `fire_employee` | free | Let an AI employee go for good: runs stop and actions awaiting approval are discarded. The first call only describes what will happen; confirm with `confirm: true`. |
+| `list_pending_actions` | free | What your AI employees are waiting to do until you approve, each with a preview of what will be published, sent or changed. Optionally one `employeeId`. |
+| `approve_action` | free | Approve one pending action by `actionId`. The first call returns the preview and a `confirmationToken` and runs nothing; after you confirm, the stored action runs exactly once. |
+| `reject_action` | free | Reject one pending action, with an optional note the employee can learn from. |
 | `connect_store` | free | A link a workspace owner or admin opens to connect an Amazon seller account or a Shopify shop. They approve at the store; nothing is connected until they do, and no credential passes through the tool. |
 | `list_store_products` | free | Read the connected store's own catalogue: title, description, status, price, and Amazon listing issues. Read-only. |
 | `create_product` | free | Create a product in your own workspace — the row every other own-account tool needs before it has anything to work with. Always creates in the calling session's workspace, never one you could name. `name` and `slug` are required; every other field is snake_case and read by exact key, so a camelCase `websiteUrl` lands nowhere. Writes no brand playbook. |

package/dist/shared/employees.js

@@ -0,0 +1,153 @@
+/**
+ * AI employees (nooticr-server P1): hire one, see what it is waiting to do,
+ * approve or reject that, pause it, let it go. Every tool here is a passthrough
+ * to the server's `POST /mcp` dispatch; the server owns the quote, the
+ * confirmation token, the permission check (the hiring user or a workspace
+ * admin) and the stored action that approve_action runs exactly once.
+ *
+ * None of these has a view yet: the lists would be drawn as tables and the
+ * quotes as confirmation cards, and the design system has no card for either.
+ */
+import { z } from "zod";
+import { OUTPUT_SCHEMAS } from "./output-schemas.js";
+function toResult(proxy) {
+    const textBlock = proxy.contentBlocks.find((c) => c.type === "text");
+    const structured = proxy.structured;
+    // The backend's text block can be a one-line summary, and the employees,
+    // actions, previews and confirmation tokens are in `structuredContent`, which
+    // a host rendering a view keeps for the widget. Without a view here, the model
+    // must read them from the text, so carry the payload in both.
+    const text = structured ? JSON.stringify(structured) : String(textBlock?.text ?? "");
+    return { content: [{ type: "text", text }], structuredContent: structured };
+}
+function failed(prefix, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+        content: [{ type: "text", text: `${prefix}: ${msg}` }],
+        isError: true,
+    };
+}
+/** The sentence every two-step employee tool carries. A test pins it. */
+export const TWO_STEP_RULE = "The first call changes nothing and returns a preview and a confirmationToken; show it to the " +
+    "user, and call again with confirm: true and the token only after the user explicitly agrees — " +
+    "never confirm on the user's behalf.";
+const confirm = z.boolean().optional();
+export function registerEmployeeTools(server, makeClient) {
+    const passthrough = (name) => async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        try {
+            return toResult(await client.callTool(name, args));
+        }
+        catch (err) {
+            return failed(`${name} failed`, err);
+        }
+    };
+    server.registerTool("hire_employee", {
+        title: "Hire Employee",
+        description: "Hire an AI employee (for example a Social Media Manager) that works on a schedule inside " +
+            "this workspace. Pass `template` and optionally name, instructions, appId, schedule, " +
+            "monthlyBudgetCredits, maxCreditsPerRun, approvalPolicy and notify. " +
+            TWO_STEP_RULE +
+            " Public actions (publish, email, reply, listing or price changes) wait for the user's " +
+            "approval unless autopilot is turned on. The hiring user is billed for runs, up to the " +
+            "monthly budget. No cost to call.",
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+        inputSchema: z
+            .object({
+            template: z.string().describe("Template slug, e.g. social-media-manager."),
+            name: z.string().optional().describe("What to call the employee."),
+            instructions: z.string().optional().describe("Standing instructions from the customer (tone, topics to avoid, ...)."),
+            appId: z.number().int().optional().describe("Focus product id."),
+            schedule: z
+                .object({}).passthrough()
+                .optional()
+                .describe("{kind:'weekly',days:['mon'],times:['09:00'],tz:'Europe/Paris'} | {kind:'interval',minutes:N>=60} | {kind:'manual'}."),
+            monthlyBudgetCredits: z.number().int().min(1).optional(),
+            maxCreditsPerRun: z.number().int().min(1).optional(),
+            approvalPolicy: z.object({}).passthrough().optional().describe("Action type -> 'approval' | 'auto'."),
+            notify: z.object({}).passthrough().optional().describe("{channels:['email'|'slack']}."),
+            model: z.string().optional().describe("Optional model."),
+            effort: z.string().optional().describe("low | medium | high."),
+            confirm,
+            confirmationToken: z.string().optional().describe("Token returned in the quote."),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.hire_employee,
+    }, passthrough("hire_employee"));
+    server.registerTool("list_employees", {
+        title: "List Employees",
+        description: "List this workspace's AI employees with status, schedule, next run and budget left. " +
+            "Pass includeFired: true to include ones that were let go. No cost to call.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: z.object({ includeFired: z.boolean().optional() }).strict(),
+        outputSchema: OUTPUT_SCHEMAS.list_employees,
+    }, passthrough("list_employees"));
+    server.registerTool("pause_employee", {
+        title: "Pause Employee",
+        description: "Pause an AI employee so it stops running (it keeps its memory and thread), or resume it " +
+            "with resume: true. Only the person who hired it or a workspace admin can. No cost to call.",
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: z
+            .object({
+            employeeId: z.string().describe("Employee id."),
+            resume: z.boolean().optional().describe("Resume instead of pausing."),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.pause_employee,
+    }, passthrough("pause_employee"));
+    server.registerTool("fire_employee", {
+        title: "Fire Employee",
+        description: "Let an AI employee go for good: runs stop and actions waiting for approval are discarded; " +
+            "its thread stays readable. The first call only describes what will happen and changes " +
+            "nothing; call again with confirm: true only after the user explicitly agrees — never " +
+            "confirm on the user's behalf. Only the person who hired it or a workspace admin can. " +
+            "No cost to call.",
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+        inputSchema: z.object({ employeeId: z.string().describe("Employee id."), confirm }).strict(),
+        outputSchema: OUTPUT_SCHEMAS.fire_employee,
+    }, passthrough("fire_employee"));
+    server.registerTool("list_pending_actions", {
+        title: "List Pending Actions",
+        description: "List what AI employees are waiting to do until a human approves: each action has a " +
+            "preview of what will be published, sent or changed. Optionally filter by employeeId. " +
+            "No cost to call.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: z
+            .object({
+            employeeId: z.string().optional().describe("Only this employee's actions."),
+            limit: z.number().int().min(1).max(100).optional(),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.list_pending_actions,
+    }, passthrough("list_pending_actions"));
+    server.registerTool("approve_action", {
+        title: "Approve Action",
+        description: "Approve one pending AI-employee action by actionId. " +
+            TWO_STEP_RULE +
+            " The stored action then runs exactly once, and it may publish or send something publicly. " +
+            "Only the hiring user or a workspace admin can. No cost to call.",
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+        inputSchema: z
+            .object({
+            actionId: z.string().describe("Action id from list_pending_actions."),
+            confirm,
+            confirmationToken: z.string().optional().describe("Token from the first call."),
+            note: z.string().optional().describe("Optional note."),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.approve_action,
+    }, passthrough("approve_action"));
+    server.registerTool("reject_action", {
+        title: "Reject Action",
+        description: "Reject one pending AI-employee action by actionId, with an optional note the employee " +
+            "can learn from. Only the hiring user or a workspace admin can. No cost to call.",
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: z
+            .object({
+            actionId: z.string().describe("Action id from list_pending_actions."),
+            note: z.string().optional().describe("Why, so the employee can learn."),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.reject_action,
+    }, passthrough("reject_action"));
+}

package/dist/shared/loading-plans.js

@@ -479,6 +479,14 @@ export const LOADING_PLANS = {
     list_brand_watches: { label: "Reading your watches", kind: "list", n: 3, steps: [], free: true },
     stop_brand_watch: { label: "Stopping the watch", kind: "text", n: 1, steps: [], free: true },
     update_watch_portfolio: { label: "Updating the portfolio", kind: "text", n: 1, steps: [], free: true },
+    // ─── AI employees (employees.ts): managing one is free; its runs are billed when they happen ───
+    hire_employee: { label: "Preparing the hire", kind: "text", n: 1, steps: [], free: true },
+    list_employees: { label: "Reading your employees", kind: "list", n: 3, steps: [], free: true },
+    pause_employee: { label: "Updating the employee", kind: "text", n: 1, steps: [], free: true },
+    fire_employee: { label: "Letting the employee go", kind: "text", n: 1, steps: [], free: true },
+    list_pending_actions: { label: "Reading what awaits approval", kind: "list", n: 3, steps: [], free: true },
+    approve_action: { label: "Approving the action", kind: "text", n: 1, steps: [], free: true },
+    reject_action: { label: "Rejecting the action", kind: "text", n: 1, steps: [], free: true },
     // ─── Store connections (store-read.ts): a link, and a read of the store's own catalogue ───
     connect_store: { label: "Minting a store link", kind: "text", n: 1, steps: [], free: true },
     list_store_products: { label: "Reading your store's catalogue", kind: "list", n: 3, steps: [], free: true },

package/dist/shared/output-schemas.js

@@ -1629,6 +1629,35 @@ export const OUTPUT_SCHEMAS = {
     // the result does not have to know which site it asked.
     scan_marketplace_category: marketplaceScan,
     marketplace_scan_status: marketplaceScan,
+    // AI employees (nooticr-server P1). The quote and employee/action views are
+    // the server's own shapes, so only the stable fields are named.
+    hire_employee: open({
+        created: scalar(),
+        requiresConfirmation: scalar(),
+        confirmationToken: scalar(),
+        message: scalar(),
+        instructions: scalar(),
+        employee: anyObject().nullish(),
+    }),
+    pause_employee: open({ employee: anyObject().nullish() }),
+    fire_employee: open({
+        fired: scalar(),
+        requiresConfirmation: scalar(),
+        pendingActions: scalar(),
+        instructions: scalar(),
+        employee: anyObject().nullish(),
+    }),
+    approve_action: open({
+        executed: scalar(),
+        requiresConfirmation: scalar(),
+        confirmationToken: scalar(),
+        expiresInSeconds: scalar(),
+        instructions: scalar(),
+        action: anyObject().nullish(),
+    }),
+    reject_action: open({ rejected: scalar(), action: anyObject().nullish() }),
+    list_employees: open({ employees: listOf(open({ id: scalar(), name: scalar(), status: scalar() })) }),
+    list_pending_actions: open({ actions: listOf(open({ id: scalar(), employeeId: scalar() })) }),
     // A diff of two stored scans, drawn by no view: the rows are the answer.
     marketplace_changes: open({
         display: scalar(),

package/dist/shared/tools-def.js

@@ -522,6 +522,48 @@ export const TOOL_DEFINITIONS = [
         description: "Pick up a scan_marketplace_category collection that was still running, by scanId and the same marketplace — the products and reviews collected since, with the same rollup and the same instructions for reading them. Free: it is the poll scan_marketplace_category asked for, and charging for the second half of one answer would bill a wait this server chose. Call it when a scan came back incomplete, and keep calling it until it reports complete: true; only then write your read, from the full set. Do not end your turn between polls.",
         inputSchema: z.object({ marketplace: z.string().describe("The same site the scan ran against."), scanId: z.string().describe("The scanId scan_marketplace_category returned."), waitSeconds: z.number().int().optional().describe("How long to wait for more products before answering (default 30, max 55)."), focus: z.string().optional().describe("Same optional steer as scan_marketplace_category.") }).strict(),
     },
+    {
+        name: "hire_employee",
+        title: "Hire Employee",
+        description: "Hire an AI employee (for example a Social Media Manager) that works on a schedule inside this workspace. Pass `template` and optionally name, instructions, appId, schedule, monthlyBudgetCredits, maxCreditsPerRun, approvalPolicy and notify. The first call changes nothing and returns a preview and a confirmationToken; show it to the user, and call again with confirm: true and the token only after the user explicitly agrees — never confirm on the user's behalf. Public actions (publish, email, reply, listing or price changes) wait for the user's approval unless autopilot is turned on. The hiring user is billed for runs, up to the monthly budget. No cost to call.",
+        inputSchema: z.object({ template: z.string().describe("Template slug, e.g. social-media-manager."), name: z.string().optional().describe("What to call the employee."), instructions: z.string().optional().describe("Standing instructions from the customer (tone, topics to avoid, ...)."), appId: z.number().int().optional().describe("Focus product id."), schedule: z.object({}).passthrough().optional().describe("{kind:'weekly',days:['mon'],times:['09:00'],tz:'Europe/Paris'} | {kind:'interval',minutes:N>=60} | {kind:'manual'}."), monthlyBudgetCredits: z.number().int().min(1).optional(), maxCreditsPerRun: z.number().int().min(1).optional(), approvalPolicy: z.object({}).passthrough().optional().describe("Action type -> 'approval' | 'auto'."), notify: z.object({}).passthrough().optional().describe("{channels:['email'|'slack']}."), model: z.string().optional().describe("Optional model."), effort: z.string().optional().describe("low | medium | high."), confirm: z.boolean().optional(), confirmationToken: z.string().optional().describe("Token returned in the quote.") }).strict(),
+    },
+    {
+        name: "list_employees",
+        title: "List Employees",
+        description: "List this workspace's AI employees with status, schedule, next run and budget left. Pass includeFired: true to include ones that were let go. No cost to call.",
+        inputSchema: z.object({ includeFired: z.boolean().optional() }).strict(),
+    },
+    {
+        name: "pause_employee",
+        title: "Pause Employee",
+        description: "Pause an AI employee so it stops running (it keeps its memory and thread), or resume it with resume: true. Only the person who hired it or a workspace admin can. No cost to call.",
+        inputSchema: z.object({ employeeId: z.string().describe("Employee id."), resume: z.boolean().optional().describe("Resume instead of pausing.") }).strict(),
+    },
+    {
+        name: "fire_employee",
+        title: "Fire Employee",
+        description: "Let an AI employee go for good: runs stop and actions waiting for approval are discarded; its thread stays readable. The first call only describes what will happen and changes nothing; call again with confirm: true only after the user explicitly agrees — never confirm on the user's behalf. Only the person who hired it or a workspace admin can. No cost to call.",
+        inputSchema: z.object({ employeeId: z.string().describe("Employee id."), confirm: z.boolean().optional() }).strict(),
+    },
+    {
+        name: "list_pending_actions",
+        title: "List Pending Actions",
+        description: "List what AI employees are waiting to do until a human approves: each action has a preview of what will be published, sent or changed. Optionally filter by employeeId. No cost to call.",
+        inputSchema: z.object({ employeeId: z.string().optional().describe("Only this employee's actions."), limit: z.number().int().min(1).max(100).optional() }).strict(),
+    },
+    {
+        name: "approve_action",
+        title: "Approve Action",
+        description: "Approve one pending AI-employee action by actionId. The first call changes nothing and returns a preview and a confirmationToken; show it to the user, and call again with confirm: true and the token only after the user explicitly agrees — never confirm on the user's behalf. The stored action then runs exactly once, and it may publish or send something publicly. Only the hiring user or a workspace admin can. No cost to call.",
+        inputSchema: z.object({ actionId: z.string().describe("Action id from list_pending_actions."), confirm: z.boolean().optional(), confirmationToken: z.string().optional().describe("Token from the first call."), note: z.string().optional().describe("Optional note.") }).strict(),
+    },
+    {
+        name: "reject_action",
+        title: "Reject Action",
+        description: "Reject one pending AI-employee action by actionId, with an optional note the employee can learn from. Only the hiring user or a workspace admin can. No cost to call.",
+        inputSchema: z.object({ actionId: z.string().describe("Action id from list_pending_actions."), note: z.string().optional().describe("Why, so the employee can learn.") }).strict(),
+    },
     {
         name: "marketplace_changes",
         title: "Marketplace Changes",

package/dist/shared/tools.js

@@ -23,6 +23,7 @@ import { registerJobTools } from "./jobs.js";
 import { registerBrandWatch } from "./brand-watch.js";
 import { registerOwnAccountTools } from "./own-account.js";
 import { registerConnectionTools } from "./connections.js";
+import { registerEmployeeTools } from "./employees.js";
 import { registerStoreReadTools } from "./store-read.js";
 import { registerGettingStarted, SERVER_INSTRUCTIONS } from "./getting-started.js";
 import { loadingPlansJson } from "./loading-plans.js";
@@ -32,7 +33,7 @@ import { registerAmazonTools } from "./amazon.js";
 import { registerMarketplaceTools } from "./marketplace.js";
 import { DEFAULT_NOOTICR_SETTINGS, DEFAULT_SOCIAL_PLATFORMS, MemorySettingsStore, SETTINGS_READ_TOOL, SETTINGS_UPDATE_TOOL, settingsOwnerFromAuth, } from "./settings.js";
 /** Current MCP server version — bumped on every deploy for traceability. */
-export const MCP_SERVER_VERSION = "1.26.59";
+export const MCP_SERVER_VERSION = "1.26.60";
 /** MCP Apps extension identifier */
 const UI_EXTENSION = "io.modelcontextprotocol/ui";
 /** MIME type for MCP Apps HTML resources */
@@ -2887,6 +2888,8 @@ export function createMcpServer(rawMakeClient, opts) {
     registerBrandWatch(server, makeClient);
     registerOwnAccountTools(server, makeClient);
     registerConnectionTools(server, makeClient);
+    // AI employees (employees.ts): hire, list, pause, fire, and approve or reject what they queue.
+    registerEmployeeTools(server, makeClient);
     // Store connections (store-read.ts): the connect link and the catalogue read.
     registerStoreReadTools(server, makeClient);
     registerGettingStarted(server, makeClient, watchStore);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nooticr/mcp",
   "mcpName": "com.nooticr/mcp",
-  "version": "1.26.59",
+  "version": "1.26.60",
   "description": "MCP server for nooticr - fetch, discover and understand TikTok/Instagram/YouTube/X/Reddit/LinkedIn/Weibo posts with AI (media metadata, niche discovery, brand monitoring, hook & viral analysis)",
   "homepage": "https://mcp.nooticr.com",
   "repository": {