@nooticr/mcp 1.26.59 → 1.26.61

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
+102 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
@@ -103,6 +103,8 @@ them caps that fan-out with an argument.
 | `catch_up_watchlist` | 2 per creator | What everyone you watch has posted since your last catch-up. Compares against the snapshot taken last time and moves it forward, so it answers "what is new" rather than "what exists". |
 | `create_brand_watch` | free to call | Schedule a recurring sweep and get emailed only what is new. `kind: "mentions"` (default) is a recurring `search_mentions` sweep for `term`/`platforms`; `kind: "competitor"` is a recurring `get_user_posts` check on one creator (`handle`/`platform`), mailing only what beats their own recent median; `kind: "report"` runs `job: {tool, args}` — `niche_report` (mailed as written every run) or `discover_social_posts` (only unseen posts) — on the schedule; `kind: "portfolio"` sweeps up to 25 `terms` (your brand, products, competitors) across the same networks under one budget and mails one digest with each term's share of voice. Two calls by design: the first returns the quote (cost per run, cadence, cost per day) and a `confirmationToken`; nothing is created or charged until you call it again with `confirm: true` and that token. Each run then bills the same as calling the matching tool yourself — 2 credits per network (5 for Xiaohongshu) for mentions, a flat 2 credits for competitor, the job tool's own price for a report (3 for `niche_report`), and a mentions sweep per term for a portfolio — whose budget is split evenly and trims networks, never terms, and which refunds any term whose sweep fails. |
 | `list_brand_watches` | free | Every watch you have scheduled: term, networks, cadence, cost per run, credits spent so far, runs made, and when the next one is due. |
+| `creative_assets_list` | free | The creative assets (voice-overs, sound effects, music, images, videos, composites) generated in your workspace, newest first, with url, kind, dimensions or duration, and provenance. Filter by `appId`, `kind`, `briefId` or `since`; page with `nextCursor`. |
+| `creative_job_status` | free | Where an asynchronous creative job stands by `jobId`: queued, running, done, failed or canceled, with the finished assets and the credits quoted, charged and refunded. Poll after `pollAfterSeconds`. |
 | `mention_trend` | free | **What a watch has seen over time**, which nothing else here answers — every other read is about now. One point per run: when it ran, how many mentions it found, how many were new, and both counts per network, so "which network is growing" and "did it go quiet or did we stop looking" come apart. On a competitor watch each point carries the median that run measured, which turns "they beat their own median" into "and that median has doubled". Plus the mentions more than one run has seen. Free because the sweeps were billed when they ran; charging again to read what was already paid for is the thing it fixes. |
 | `update_watch_portfolio` | free | Add or remove a portfolio watch's terms by `watchId`. No new confirmation, because the per-run budget you agreed to does not move — more terms split it more ways, and the reply names any network a run no longer reaches. |
 | `stop_brand_watch` | free | Stop a watch by `watchId` or `term`. Immediate — the next run does not happen and nothing more is charged. |
@@ -182,6 +184,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/creative.js

@@ -0,0 +1,67 @@
+/**
+ * The free read half of nooticr-server's `creative_*` family (CR1): list the
+ * creative assets generated in the workspace and poll one asynchronous job.
+ * Both are passthroughs to the server's `POST /mcp` dispatch, which owns the
+ * tenancy check (another workspace's id answers "not found").
+ *
+ * The paid creative tools (CR2-CR6) register here when they ship;
+ * `creative_test_render` is a server test fixture and is never registered.
+ * Neither tool has a view yet: the asset list would be a gallery, which the
+ * design system has no card for.
+ */
+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 assets and the job's finished outputs are in `structuredContent`; with no
+    // view here the model reads 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,
+    };
+}
+export const CREATIVE_ASSET_KINDS = ["voiceover", "sfx", "music", "image", "video", "composite"];
+export function registerCreativeTools(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("creative_assets_list", {
+        title: "List Creative Assets",
+        description: "List the creative assets (voice-overs, sound effects, music, images, videos, composites) " +
+            "generated in this workspace, newest first. Optional filters: appId, kind, briefId, since " +
+            "(ISO timestamp). Pass the returned nextCursor as cursor for the next page. No cost to call.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: z
+            .object({
+            appId: z.number().int().optional().describe("Only this product's assets."),
+            kind: z.enum(CREATIVE_ASSET_KINDS).optional(),
+            briefId: z.string().uuid().optional(),
+            since: z.string().datetime({ offset: true }).optional().describe("ISO 8601 timestamp."),
+            limit: z.number().int().min(1).max(100).optional(),
+            cursor: z.string().optional().describe("nextCursor from the previous page."),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.creative_assets_list,
+    }, passthrough("creative_assets_list"));
+    server.registerTool("creative_job_status", {
+        title: "Creative Job Status",
+        description: "Status of an asynchronous creative job by jobId: queued, running, done, failed or " +
+            "canceled, with the finished assets and the credits quoted, charged and refunded. Poll " +
+            "after pollAfterSeconds. No cost to call.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: z.object({ jobId: z.string().uuid().describe("jobId returned when the job was started.") }).strict(),
+        outputSchema: OUTPUT_SCHEMAS.creative_job_status,
+    }, passthrough("creative_job_status"));
+}

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

@@ -476,9 +476,20 @@ export const LOADING_PLANS = {
     // Managing a schedule is not using it: the sweeps a watch makes are billed
     // as search_mentions when the worker runs them, later and elsewhere.
     create_brand_watch: { label: "Setting up the watch", kind: "text", n: 1, steps: [], free: true },
+    // Creative assets (creative.ts): both are free reads.
+    creative_assets_list: { label: "Reading your creative assets", kind: "list", n: 3, steps: [], free: true },
+    creative_job_status: { label: "Checking the creative job", kind: "text", n: 1, steps: [], free: true },
     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

@@ -1254,6 +1254,24 @@ export const OUTPUT_SCHEMAS = {
         billable: scalar(),
         mcpCredits,
     }),
+    // Creative assets (nooticr-server CR1). Assets and jobs are the server's own
+    // shapes, so only the stable fields are named.
+    creative_assets_list: open({
+        assets: listOf(open({ id: scalar(), kind: scalar(), appId: scalar(), url: scalar(), mime: scalar(), createdAt: scalar() })),
+        nextCursor: scalar(),
+    }),
+    creative_job_status: open({
+        jobId: scalar(),
+        tool: scalar(),
+        status: scalar(),
+        assetIds: listOf(oneType(z.string())),
+        assets: listOf(open({ id: scalar(), kind: scalar(), url: scalar() })),
+        creditsQuoted: scalar(),
+        creditsCharged: scalar(),
+        creditsRefunded: scalar(),
+        pollAfterSeconds: scalar(),
+        error: scalar(),
+    }),
     list_brand_watches: open({
         watches: listOf(open({
             watchId: scalar(),
@@ -1629,6 +1647,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

@@ -264,6 +264,18 @@ export const TOOL_DEFINITIONS = [
         description: "Run a sweep on a schedule and email what is new, instead of remembering to ask. kind: \"mentions\" (default) sweeps term across platforms; kind: \"competitor\" sweeps one creator's own posts (handle + platform) and reports only what beats their own recent median; kind: \"report\" runs job {tool, args} (niche_report or discover_social_posts) on the schedule at that tool's own price; kind: \"portfolio\" sweeps several terms across the same platforms under one budget and mails one digest with each term's share of voice. Two calls by design: call it once with no confirmation to get back the cost per run and what it multiplies out to per day, then call it again with confirm: true and the confirmationToken to actually start it. The first call creates nothing and spends nothing. Bills 2 credits per network per run (5 for Xiaohongshu) for a mentions watch, or a flat 2 credits for a competitor watch, trimmed to fit budgetCredits. A run that finds nothing new (or, for a competitor watch, nothing above median) sends no mail. No cost to call.",
         inputSchema: z.object({ kind: z.enum(["mentions", "competitor", "report", "portfolio"]).optional().describe("\"mentions\" (default), \"competitor\", \"report\" or \"portfolio\"."), job: z.object({ tool: z.enum(["niche_report", "discover_social_posts"]), args: z.object({}).passthrough() }).optional().describe("kind: report only — the job each run performs."), terms: z.array(z.string()).optional().describe("kind: portfolio only — the terms to compare (1-25)."), term: z.string().optional().describe("kind: mentions only — what to watch for (max 120 chars)."), platforms: z.array(z.string()).optional().describe("kind: mentions only — networks to sweep (default: every searchable network)."), handle: z.string().optional().describe("kind: competitor only — the creator's handle."), platform: z.string().optional().describe("kind: competitor only — the platform that creator posts on."), cadence: z.enum(["hourly", "every_6_hours", "every_12_hours", "daily", "weekly"]).optional().describe("How often to run (default daily)."), budgetCredits: z.number().int().optional().describe("Hard per-run credit ceiling (default the full sweep's cost)."), deliverTo: z.string().optional().describe("Digest email (default the account's own)."), confirm: z.boolean().optional().describe("Set true only once the user has agreed to the quoted cost."), confirmationToken: z.string().optional().describe("The token the first call returned.") }).strict(),
     },
+    {
+        name: "creative_assets_list",
+        title: "List Creative Assets",
+        description: "List the creative assets (voice-overs, sound effects, music, images, videos, composites) generated in this workspace, newest first. Optional filters: appId, kind, briefId, since (ISO timestamp). Pass the returned nextCursor as cursor for the next page. No cost to call.",
+        inputSchema: z.object({ appId: z.number().int().optional().describe("Only this product's assets."), kind: z.enum(["voiceover", "sfx", "music", "image", "video", "composite"]).optional(), briefId: z.string().optional(), since: z.string().optional().describe("ISO 8601 timestamp."), limit: z.number().int().min(1).max(100).optional(), cursor: z.string().optional().describe("nextCursor from the previous page.") }).strict(),
+    },
+    {
+        name: "creative_job_status",
+        title: "Creative Job Status",
+        description: "Status of an asynchronous creative job by jobId: queued, running, done, failed or canceled, with the finished assets and the credits quoted, charged and refunded. Poll after pollAfterSeconds. No cost to call.",
+        inputSchema: z.object({ jobId: z.string().describe("jobId returned when the job was started.") }).strict(),
+    },
     {
         name: "list_brand_watches",
         title: "List Brand Watches",
@@ -522,6 +534,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

@@ -21,8 +21,10 @@ import { confirmSpend, declinedResult, searchMentionsCost, SEARCH_PLATFORMS, DIS
 import { BackendWatchStore, MemoryWatchStore, registerWatchlist, } from "./watchlist.js";
 import { registerJobTools } from "./jobs.js";
 import { registerBrandWatch } from "./brand-watch.js";
+import { registerCreativeTools } from "./creative.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 +34,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.61";
 /** MCP Apps extension identifier */
 const UI_EXTENSION = "io.modelcontextprotocol/ui";
 /** MIME type for MCP Apps HTML resources */
@@ -2886,7 +2888,11 @@ export function createMcpServer(rawMakeClient, opts) {
     registerJobTools(server, makeClient, watchStore);
     registerBrandWatch(server, makeClient);
     registerOwnAccountTools(server, makeClient);
+    // Creative assets (creative.ts): the free reads of nooticr-server's creative_* family.
+    registerCreativeTools(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.61",
   "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": {