@wiro-ai/wiro-mcp 1.3.4 → 1.4.1

package/dist/tools/apply-agent-skills.js

@@ -0,0 +1,601 @@
+import { z } from 'zod';
+import { asString, errorResult, errorText, isPlainObject, requireApiSuccess, toNumber, unixToIso, } from '../utils/api.js';
+import { agentStatusLabel, agentStatusOf, checkSkillSet, credentialsNeededFor, describeSkillsApplyError, diffSkills, enabledSkillNames, estimateProratedUsd, formatUsd, isAgentRunning, loadSkillRegistry, newSkillChangeKey, parseSkillChangeKey, planBilling, planSkillChanges, readUserAgent, restartNote, skillChangeDigest, skillPriceTag, workspaceHint, } from '../utils/agent-config.js';
+import { asTier, outcomeUnknown, toTierPricing } from '../utils/user-agent.js';
+import { DEFAULT_WAIT_SECONDS } from '../utils/poll.js';
+import { isPlainTeamMember, teamAgentBillingRefused } from '../utils/workspace.js';
+import { nextActionSchema } from './schemas.js';
+const pricingSchema = z.object({
+    currentMonthlyUsd: z.number().nullable(),
+    newMonthlyUsd: z.number().nullable(),
+    deltaMonthlyUsd: z.number().nullable(),
+    currentMonthlyCredits: z.number().nullable(),
+    newMonthlyCredits: z.number().nullable(),
+    deltaMonthlyCredits: z.number().nullable(),
+    note: z.string().optional(),
+});
+const outputSchema = {
+    agentGuid: z.string(),
+    status: z.enum(['quote', 'applied', 'no_change', 'refused']),
+    idempotencyKey: z.string().optional(),
+    priceChanged: z.boolean().optional(),
+    changes: z.object({
+        enable: z.array(z.string()),
+        disable: z.array(z.string()),
+        addedDependencies: z.array(z.string()),
+        alreadySet: z.array(z.string()),
+    }),
+    tier: z.object({
+        current: z.string().nullable(),
+        next: z.string().nullable(),
+    }),
+    pricing: pricingSchema.optional(),
+    billing: z.object({
+        plan: z.enum(['prepaid', 'card', 'none']),
+        subscriptionStatus: z.string().nullable(),
+        wallet: z.enum(['team', 'personal']),
+        estimatedChargeNowUsd: z.number().nullable().optional(),
+        chargedNowUsd: z.number().nullable().optional(),
+        note: z.string(),
+    }),
+    enabledSkills: z.array(z.string()).optional(),
+    credentialsNeeded: z.array(z.object({
+        skill: z.string(),
+        credentials: z.array(z.string()),
+    })),
+    agentStatus: z.string(),
+    restart: z.string(),
+    error: z.object({
+        code: z.number().nullable(),
+        message: z.string(),
+        deps: z.array(z.object({ skill: z.string(), requires: z.string() })).optional(),
+        conflicts: z.array(z.object({ a: z.string(), b: z.string() })).optional(),
+        requiredUsd: z.number().nullable().optional(),
+        availableUsd: z.number().nullable().optional(),
+    }).optional(),
+    nextAction: nextActionSchema.optional(),
+};
+const UNCHANGED_RESTART = 'Nothing changed, so the agent does not restart.';
+// A credit for skills turned off goes to the wallet with an end date: it can be
+// spent until the plan's current period ends.
+const CREDIT_SPEND_BY = 'It can be spent until this period ends.';
+function difference(next, current) {
+    return next === null || current === null ? null : Math.round((next - current) * 100) / 100;
+}
+/**
+ * A skill change prices the plan at today's prices for all its skills, so a
+ * plan that started at other prices also changes for the skills it already
+ * has, and so do its monthly credits. The agent's tiers carry today's prices
+ * and credits for those skills. An agent without a plan has no price of its
+ * own to move from, and a move to Pro prices the whole plan at today's Pro
+ * prices, which the quote already shows.
+ */
+function todayPriceNote(row, billing, currentPrice, currentCredits, tierChange) {
+    if (tierChange)
+        return null;
+    const tier = asTier(row.tier);
+    const tiers = toTierPricing(isPlainObject(row.agent) ? row.agent.tiers : undefined);
+    const today = tier && tiers ? tiers[tier] : null;
+    if (billing.plan === 'none' || currentPrice === null || today === null || !difference(today.priceUsd, currentPrice))
+        return null;
+    const credits = currentCredits !== null && today.monthlyCredits !== currentCredits
+        ? `, and its monthly credits from ${currentCredits} to ${today.monthlyCredits}`
+        : '';
+    return `The change also moves the plan from its current ${formatUsd(currentPrice)} a month to ${formatUsd(today.priceUsd)} a month, today's ${tier === 'pro' ? 'Pro' : 'Starter'} price for the skills it already has${credits}.`;
+}
+/**
+ * The wallet of the agent's workspace, which Wiro charges or credits for a
+ * skill change: the team's for a team agent, else its owner's personal wallet.
+ * Only the owner can change a personal agent's skills, so that wallet is the
+ * caller's own.
+ */
+function walletName(billing) {
+    return billing.wallet === 'team' ? 'the team wallet' : 'your personal wallet';
+}
+/** For a cancelled plan, a skill change only covers the days left: nothing renews at the new price. */
+function cancelledNote(billing) {
+    const end = billing.periodEnd !== null ? unixToIso(billing.periodEnd) : undefined;
+    if (billing.plan === 'card') {
+        return `The plan is set to end${end ? ` after ${end}` : ' with this period'} and does not renew.`;
+    }
+    return `The plan is cancelled and ends about a day after ${end ?? 'the end of this period'}, so this covers only the days left and the new price is not renewed. Undo the cancellation with manage_agent_billing (renew) to keep the plan.`;
+}
+function quoteBillingNote(billing, delta, estimate, nextPrice) {
+    // A card plan whose renewal is not known gets the new price without a renewal claim.
+    const after = billing.cancelAtPeriodEnd === true
+        ? ` ${cancelledNote(billing)}`
+        : nextPrice === null
+            ? ''
+            : billing.cancelAtPeriodEnd === false
+                ? ` The plan then renews at ${formatUsd(nextPrice)} a month.`
+                : ` The new monthly price is ${formatUsd(nextPrice)}.`;
+    if (billing.plan === 'none') {
+        return 'The agent has no subscription yet, so nothing is charged now. The new monthly price applies once it is subscribed.';
+    }
+    if (billing.status !== 'active') {
+        return `The subscription is ${billing.status ?? 'not active'}. Skills can only change on an active subscription, so renew it with manage_agent_billing first.`;
+    }
+    if (delta === null) {
+        return billing.plan === 'prepaid'
+            ? `The difference for the rest of this period is taken from, or credited to, ${walletName(billing)} when the change is applied. A credit can be spent until this period ends.${after}`
+            : `Any prorated difference appears on the next invoice.${after}`;
+    }
+    if (Math.abs(delta) < 0.005)
+        return 'The monthly price does not change, so nothing is charged.';
+    if (billing.plan === 'card') {
+        return `Nothing is charged now. The card subscription is updated and the prorated difference appears on the next invoice.${after}`;
+    }
+    const days = billing.daysRemaining !== null ? ` for the ${billing.daysRemaining} days left in this period` : ' for the rest of this period';
+    if (delta > 0) {
+        return `About ${formatUsd(estimate ?? 0)} is taken from ${walletName(billing)} now${days}.${after}`;
+    }
+    return `About ${formatUsd(Math.abs(estimate ?? 0))} is credited back to ${walletName(billing)} now${days}. ${CREDIT_SPEND_BY}${after}`;
+}
+function chargeNote(billing, body) {
+    const charged = toNumber(body.prepaidWalletDelta);
+    const cancelled = billing.cancelAtPeriodEnd === true && billing.status === 'active' ? ` ${cancelledNote(billing)}` : '';
+    if (charged !== null && charged > 0) {
+        return { charged, note: `${formatUsd(charged)} was taken from ${walletName(billing)} for the rest of this period.${cancelled}` };
+    }
+    if (charged !== null && charged < 0) {
+        return { charged, note: `${formatUsd(Math.abs(charged))} was credited to ${walletName(billing)}. ${CREDIT_SPEND_BY}${cancelled}` };
+    }
+    if (body.stripeProrationApplied === true) {
+        return { charged: null, note: `The card subscription was updated; any prorated difference appears on the next invoice.${cancelled}` };
+    }
+    if (billing.plan === 'none') {
+        return { charged: null, note: 'Nothing was charged: the agent has no subscription yet.' };
+    }
+    return { charged: null, note: `Nothing was charged now.${cancelled}` };
+}
+/** What the change charged, then any notes Wiro adds about its billing, as Wiro wrote them. */
+function appliedBillingNote(billing, body) {
+    const result = chargeNote(billing, body);
+    const warnings = (Array.isArray(body.warnings) ? body.warnings : [])
+        .map(warning => asString(warning)?.trim())
+        .filter((warning) => Boolean(warning));
+    return warnings.length > 0 ? { ...result, note: [result.note, ...warnings].join(' ') } : result;
+}
+function listLine(label, names) {
+    return names.length > 0 ? `**${label}:** ${names.join(', ')}` : null;
+}
+/** Whether the agent's live skills and tier are what this change asked for; null when that cannot be read. */
+async function changeHolds(client, agentGuid, requested, tier, signal) {
+    let live;
+    try {
+        live = await readUserAgent(client, agentGuid, signal);
+    }
+    catch {
+        return null;
+    }
+    const enabled = new Set(enabledSkillNames(live));
+    const skillsHold = Object.entries(requested).every(([name, on]) => enabled.has(name) === on);
+    return skillsHold && (!tier || asString(live.tier) === tier);
+}
+export function registerApplyAgentSkills(server, client) {
+    server.registerTool('apply_agent_skills', {
+        title: 'Change an agent\'s skills',
+        description: 'Turn registry skills on or off for a deployed agent, and optionally move it '
+            + 'from Starter to Pro, as one billed change. Skills set the agent\'s monthly price and monthly credits. '
+            + 'On a team agent only a team admin or the person who deployed the agent can change its skills; other '
+            + 'members are refused and nothing is charged. '
+            + 'Steps: 1) call without confirm. The tool checks the names, adds the skills they '
+            + 'depend on, and returns the current and new monthly price, an estimate of what is '
+            + 'charged now and an idempotency_key. Nothing changes yet. 2) Show the price to the '
+            + 'user. 3) After they approve, call again with confirm: true and that idempotency_key. '
+            + 'The key is tied to the quoted prices: if the price changed since the quote, nothing '
+            + 'is applied and a new quote with a new key comes back. Reusing the key after a timeout '
+            + 'is safe, the change is applied once. Billing: on a prepaid plan the monthly difference '
+            + 'for the days left in the period is taken from the wallet at once, or credited to it '
+            + 'when the price drops, and that credit can be spent until the period ends; on a card '
+            + 'plan it is added to the next invoice. A running agent '
+            + 'restarts once to load the skills. Newly enabled skills may still need credentials '
+            + '(set_agent_credentials, connect_agent_oauth) and do not create scheduled tasks '
+            + '(manage_agent_custom_skill does). Find skill names with list_agent_skills and the '
+            + 'agent\'s current skills with get_my_agent. The agents playbook (get_playbook) has the '
+            + 'full setup walkthrough.',
+        inputSchema: {
+            agent_guid: z.string().min(1).describe('The deployed agent\'s guid, from list_my_agents.'),
+            skills: z.record(z.string(), z.boolean())
+                .describe('Skills to change, as name: true to turn on or name: false to turn off, for example {"int-instagram-post": true}. Registry names only (list_agent_skills). Custom skills and scheduled tasks (cs-...) are managed with manage_agent_custom_skill; channels such as Telegram turn on through set_agent_credentials.'),
+            tier: z.enum(['starter', 'pro']).optional()
+                .describe('Optional: also move from Starter to Pro in this billed change. To upgrade without a skill change, use manage_agent_billing (upgrade_to_pro).'),
+            add_dependencies: z.boolean().default(true)
+                .describe('Also turn on the skills that the enabled skills depend on (default true). Without them the change is refused.'),
+            confirm: z.boolean().default(false)
+                .describe('false (default) only returns the quote. true applies the change and charges it; it needs the idempotency_key from the quote.'),
+            idempotency_key: z.string().min(8).max(128).optional()
+                .describe('With confirm: true, the key from the quote the user approved. It ties the approval to the quoted prices, and repeating the call with it after a timeout never applies the change twice. Omit it to get a quote.'),
+        },
+        outputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async ({ agent_guid, skills, tier, add_dependencies, confirm, idempotency_key }, extra) => {
+        try {
+            if (Object.keys(skills).length === 0 && !tier) {
+                return errorResult(new Error('Nothing to change: pass at least one skill or a tier.'));
+            }
+            const registry = await loadSkillRegistry(client, extra.signal);
+            const plan = planSkillChanges(skills, registry, add_dependencies);
+            if (plan.errors.length > 0) {
+                return errorResult(new Error(`The change was not sent:\n\n- ${plan.errors.join('\n- ')}`));
+            }
+            const row = await readUserAgent(client, agent_guid, extra.signal);
+            const status = agentStatusOf(row);
+            const currentTier = asString(row.tier) ?? null;
+            if (tier === 'starter' && currentTier === 'pro') {
+                return errorResult(new Error('A Pro plan cannot be moved back to Starter here. Cancel the plan with manage_agent_billing and subscribe again at Starter once it ends.'));
+            }
+            const tierChange = tier && tier !== currentTier ? tier : undefined;
+            const digest = skillChangeDigest(agent_guid, plan.requested, tier);
+            const givenKey = idempotency_key ? parseSkillChangeKey(idempotency_key) : null;
+            if (givenKey && givenKey.digest !== digest) {
+                return errorResult(new Error('This idempotency_key belongs to a different skill change. Omit idempotency_key to start a new change, or repeat the exact change it was issued for.'));
+            }
+            const enabledNow = enabledSkillNames(row);
+            const diff = diffSkills(plan.requested, enabledNow);
+            const check = checkSkillSet(enabledNow, diff.changes, registry);
+            if (check.deps.length > 0 || check.conflicts.length > 0) {
+                const problems = [
+                    ...check.deps.map(dep => (diff.disable.includes(dep.requires)
+                        ? `${dep.skill} needs ${dep.requires}. Keep ${dep.requires} on, or also turn off ${dep.skill}.`
+                        : `${dep.skill} needs ${dep.requires}, which is off. Turn ${dep.requires} on in the same change.`)),
+                    ...check.conflicts.map(pair => `${pair.a} and ${pair.b} cannot be on together. Keep only one.`),
+                ];
+                return errorResult(new Error(`The change was not sent:\n\n- ${[...new Set(problems)].join('\n- ')}`));
+            }
+            const billing = planBilling(row);
+            const running = isAgentRunning(status);
+            const changes = {
+                enable: diff.enable,
+                disable: diff.disable,
+                addedDependencies: plan.addedDependencies.filter(name => diff.enable.includes(name)),
+                alreadySet: diff.alreadySet.filter(name => !plan.addedDependencies.includes(name)),
+            };
+            const credentialsNeeded = credentialsNeededFor(diff.enable, registry, row);
+            const nothingToDo = Object.keys(diff.changes).length === 0 && !tierChange;
+            const base = {
+                agentGuid: agent_guid,
+                changes,
+                tier: { current: currentTier, next: tierChange ?? currentTier },
+                credentialsNeeded,
+                agentStatus: agentStatusLabel(status),
+            };
+            const billingBase = { plan: billing.plan, subscriptionStatus: billing.status, wallet: billing.wallet };
+            // An empty change cannot charge anything. With a key issued for this
+            // same change it is still sent, so a repeated confirm gets the result
+            // of the earlier call with that key.
+            if (nothingToDo && !(confirm && givenKey)) {
+                return {
+                    content: [{ type: 'text', text: `## No change needed\n\nThe skills${tier ? ' and tier' : ''} are already as requested on agent \`${agent_guid}\`.` }],
+                    structuredContent: {
+                        ...base,
+                        status: 'no_change',
+                        billing: { ...billingBase, note: 'Nothing is charged.' },
+                        restart: UNCHANGED_RESTART,
+                    },
+                };
+            }
+            const currentPrice = toNumber(row.monthlypriceusd);
+            const currentCredits = toNumber(row.monthlycredits);
+            const key = idempotency_key?.trim() ?? '';
+            // Every team member can read a team agent and price a change, but only a
+            // team admin or the person who deployed it can apply one. The credit
+            // history check refuses the other members up front; the organization's
+            // owner passes it and gets Wiro's answer on confirm.
+            if (!nothingToDo && await isPlainTeamMember(client, row, extra.signal)
+                && await teamAgentBillingRefused(client, agent_guid, extra.signal)) {
+                const message = 'Only a team admin or the person who deployed this agent can change its skills, and this '
+                    + 'connection acts as a team member without those rights. Nothing was quoted, changed or charged. Ask a '
+                    + 'team admin or the person who deployed the agent to make the change.';
+                return {
+                    content: [{ type: 'text', text: `## Skill change not possible\n\n${message}` }],
+                    structuredContent: {
+                        ...base,
+                        status: 'refused',
+                        billing: { ...billingBase, note: message },
+                        restart: UNCHANGED_RESTART,
+                        error: { code: 97, message },
+                    },
+                    isError: true,
+                };
+            }
+            if (!nothingToDo) {
+                const preview = requireApiSuccess(await client.post('/UserAgent/PricingPreview', {
+                    useragentguid: agent_guid,
+                    skillOverrides: diff.changes,
+                    ...(tierChange ? { tier: tierChange } : {}),
+                }, extra.signal), 'Could not price this change.');
+                const newPrice = toNumber(preview.totalPriceUsd);
+                if (newPrice === null) {
+                    throw new Error('Wiro did not return the new monthly price of this change, so it cannot be quoted. Try again later.');
+                }
+                const priceTag = skillPriceTag(currentPrice, newPrice);
+                const approved = confirm && givenKey !== null && givenKey.priceTag === priceTag;
+                if (!approved) {
+                    const newCredits = toNumber(preview.totalMonthlyCredits);
+                    const delta = difference(newPrice, currentPrice);
+                    const estimate = billing.plan === 'prepaid' && billing.status === 'active' && delta !== null
+                        ? estimateProratedUsd(delta, billing.periodEnd)
+                        : null;
+                    const note = quoteBillingNote(billing, delta, estimate, newPrice);
+                    const quoteKey = givenKey?.priceTag === priceTag ? key : newSkillChangeKey(digest, priceTag);
+                    const priceChanged = confirm && givenKey !== null;
+                    const blocked = billing.plan !== 'none' && billing.status !== 'active';
+                    const restart = restartNote(status, 'skill change');
+                    const priceNote = todayPriceNote(row, billing, currentPrice, currentCredits, tierChange);
+                    const pricing = {
+                        currentMonthlyUsd: currentPrice,
+                        newMonthlyUsd: newPrice,
+                        deltaMonthlyUsd: delta,
+                        currentMonthlyCredits: currentCredits,
+                        newMonthlyCredits: newCredits,
+                        deltaMonthlyCredits: difference(newCredits, currentCredits),
+                        ...(priceNote ? { note: priceNote } : {}),
+                    };
+                    const nextAction = blocked
+                        ? {
+                            tool: 'manage_agent_billing',
+                            arguments: { agent_guid, action: 'renew' },
+                            reason: 'The subscription must be active before skills can change.',
+                        }
+                        : {
+                            tool: 'apply_agent_skills',
+                            arguments: {
+                                agent_guid,
+                                skills,
+                                ...(tier ? { tier } : {}),
+                                add_dependencies,
+                                confirm: true,
+                                idempotency_key: quoteKey,
+                            },
+                            reason: delta === null || delta > 0
+                                ? 'Ask the user to approve this charge first.'
+                                : 'Ask the user to confirm this change first.',
+                        };
+                    const lead = !confirm
+                        ? null
+                        : priceChanged
+                            ? 'The price changed since the quote, so nothing was applied or charged. This is the new quote with a new idempotency_key; show it to the user and ask again.'
+                            : 'Nothing was applied: confirming needs the idempotency_key of a quote, which ties the approval to the price. This is the quote; show it to the user first.';
+                    const lines = [
+                        '## Skill change quote',
+                        '',
+                        ...(lead ? [lead, ''] : []),
+                        `**Agent:** \`${agent_guid}\` (${agentStatusLabel(status)})`,
+                        listLine('Turn on', changes.enable),
+                        listLine('Added because other skills need them', changes.addedDependencies),
+                        listLine('Turn off', changes.disable),
+                        listLine('Already as requested', changes.alreadySet),
+                        tierChange ? `**Plan:** ${currentTier ?? 'unknown'} to ${tierChange}` : null,
+                        `**Monthly price:** ${currentPrice !== null ? formatUsd(currentPrice) : 'unknown'} now, ${formatUsd(newPrice)} after the change${delta !== null ? ` (${delta >= 0 ? '+' : ''}${formatUsd(delta)})` : ''}`,
+                        priceNote ? `**Price update:** ${priceNote}` : null,
+                        newCredits !== null ? `**Monthly credits:** ${currentCredits ?? 'unknown'} now, ${newCredits} after the change` : null,
+                        `**Billing:** ${note}`,
+                        `**Restart:** ${restart}`,
+                        credentialsNeeded.length > 0
+                            ? `**Credentials the new skills need:** ${credentialsNeeded.map(entry => `${entry.skill} (${entry.credentials.join(', ')})`).join('; ')}`
+                            : null,
+                        '',
+                        blocked
+                            ? 'Renew the subscription with manage_agent_billing before applying this change.'
+                            : `Nothing has changed yet. After the user approves, call apply_agent_skills again with confirm: true and idempotency_key \`${quoteKey}\`.`,
+                    ].filter((line) => line !== null);
+                    return {
+                        content: [{ type: 'text', text: lines.join('\n') }],
+                        structuredContent: {
+                            ...base,
+                            status: 'quote',
+                            idempotencyKey: quoteKey,
+                            ...(priceChanged ? { priceChanged: true } : {}),
+                            pricing,
+                            billing: { ...billingBase, estimatedChargeNowUsd: estimate, note },
+                            ...(Array.isArray(preview.enabledSkills) ? { enabledSkills: preview.enabledSkills.map(String) } : {}),
+                            restart,
+                            nextAction,
+                        },
+                    };
+                }
+            }
+            const sentEmpty = nothingToDo;
+            let applied;
+            try {
+                applied = requireApiSuccess(await client.post('/UserAgent/SkillsApply', {
+                    useragentguid: agent_guid,
+                    skills: diff.changes,
+                    idempotencyKey: key,
+                    ...(tierChange ? { tier: tierChange } : {}),
+                }, extra.signal), 'The skill change was refused.');
+            }
+            catch (error) {
+                if (extra.signal.aborted)
+                    throw error;
+                if (!outcomeUnknown(error)) {
+                    const failure = describeSkillsApplyError(error, billing.plan);
+                    const text = [
+                        '## Skill change not applied',
+                        '',
+                        failure.message,
+                        failure.guidance ? `\n${failure.guidance}` : '',
+                        failure.retrySameKey ? `\nidempotency_key: \`${key}\`` : '',
+                    ].join('\n').trim();
+                    return {
+                        content: [{ type: 'text', text }],
+                        structuredContent: {
+                            ...base,
+                            status: 'refused',
+                            idempotencyKey: key,
+                            billing: { ...billingBase, note: failure.guidance || failure.message },
+                            restart: UNCHANGED_RESTART,
+                            error: {
+                                code: failure.code,
+                                message: failure.message,
+                                ...(failure.deps ? { deps: failure.deps } : {}),
+                                ...(failure.conflicts ? { conflicts: failure.conflicts } : {}),
+                                ...(failure.requiredUsd !== undefined ? { requiredUsd: failure.requiredUsd } : {}),
+                                ...(failure.availableUsd !== undefined ? { availableUsd: failure.availableUsd } : {}),
+                            },
+                        },
+                        isError: true,
+                    };
+                }
+                const message = errorText(error);
+                if (sentEmpty) {
+                    const note = 'The agent\'s skills already match the request, so the change is in place. Do not repeat it. '
+                        + 'What the earlier call with this idempotency_key charged is not shown here; get_agent_activity with kind usage shows it.';
+                    return {
+                        content: [{ type: 'text', text: `## No change needed\n\n${note}` }],
+                        structuredContent: {
+                            ...base,
+                            status: 'no_change',
+                            idempotencyKey: key,
+                            billing: { ...billingBase, note },
+                            restart: UNCHANGED_RESTART,
+                        },
+                    };
+                }
+                // The agent is read again to see whether the change is in place
+                // before anything is reported.
+                const holds = await changeHolds(client, agent_guid, plan.requested, tierChange, extra.signal);
+                if (holds === true) {
+                    const note = `The agent's skills now match the request, so the change is in place. Do not repeat it. ${billing.plan === 'prepaid' && billing.status === 'active' ? `The difference for the rest of this period was probably taken from, or credited to, ${walletName(billing)}, and a credit can be spent until this period ends; get_agent_activity with kind usage and get_account show it.` : 'Any price difference follows the plan\'s usual billing.'}`;
+                    return {
+                        content: [{ type: 'text', text: [
+                                    '## Skills updated',
+                                    '',
+                                    `**Agent:** \`${agent_guid}\``,
+                                    listLine('Turned on', changes.enable),
+                                    listLine('Turned off', changes.disable),
+                                    `**Billing:** ${note}`,
+                                    `**Restart:** ${restartNote(status, 'skill change')}`,
+                                ].filter((line) => line !== null).join('\n') }],
+                        structuredContent: {
+                            ...base,
+                            status: 'applied',
+                            idempotencyKey: key,
+                            billing: { ...billingBase, chargedNowUsd: null, note },
+                            restart: restartNote(status, 'skill change'),
+                        },
+                    };
+                }
+                const unverified = holds === null;
+                const note = unverified
+                    ? `The change could not be confirmed (${message}). Check get_my_agent to see whether the skills match the request before trying again; repeating this call with the same idempotency_key never applies the change twice.`
+                    : `The agent's skills are unchanged, so the change was not applied (${message}). Repeating this call with the same idempotency_key is safe.`;
+                return {
+                    content: [{ type: 'text', text: `## Skill change ${unverified ? 'not confirmed' : 'not applied'}\n\n${note}\n\nidempotency_key: \`${key}\`` }],
+                    structuredContent: {
+                        ...base,
+                        status: 'refused',
+                        idempotencyKey: key,
+                        billing: { ...billingBase, note },
+                        restart: unverified ? 'The agent restarts if the change was saved.' : UNCHANGED_RESTART,
+                        error: { code: null, message },
+                    },
+                    isError: true,
+                };
+            }
+            // The live agent is checked against this change before it is reported
+            // as applied.
+            const holds = await changeHolds(client, agent_guid, plan.requested, tierChange, extra.signal);
+            if (holds === false) {
+                const note = 'The agent\'s skills do not match this change, so it is not in place. Check get_my_agent; if they '
+                    + 'still do not match the request, call apply_agent_skills again without idempotency_key to get a new quote.';
+                return {
+                    content: [{ type: 'text', text: `## Skill change not applied\n\n${note}` }],
+                    structuredContent: {
+                        ...base,
+                        status: 'refused',
+                        idempotencyKey: key,
+                        billing: { ...billingBase, note },
+                        restart: UNCHANGED_RESTART,
+                        error: { code: null, message: note },
+                        nextAction: {
+                            tool: 'apply_agent_skills',
+                            arguments: { agent_guid, skills, ...(tier ? { tier } : {}), add_dependencies },
+                            reason: 'Get a new quote for this change.',
+                        },
+                    },
+                    isError: true,
+                };
+            }
+            // An empty request that comes back as a real change is the saved
+            // result of the earlier call with this key, not a new charge.
+            const replayed = sentEmpty && !applied.noOp;
+            const serverPricing = applied.pricing ?? {};
+            const pricing = applied.noOp
+                ? undefined
+                : {
+                    currentMonthlyUsd: toNumber(serverPricing.previousPriceUsd),
+                    newMonthlyUsd: toNumber(serverPricing.newPriceUsd),
+                    deltaMonthlyUsd: toNumber(serverPricing.deltaUsd),
+                    currentMonthlyCredits: toNumber(serverPricing.previousMonthlyCredits),
+                    newMonthlyCredits: toNumber(serverPricing.newMonthlyCredits),
+                    deltaMonthlyCredits: toNumber(serverPricing.deltaCredits),
+                };
+            const charge = appliedBillingNote(billing, applied);
+            const billingNote = replayed
+                ? `This change was already applied by an earlier call with this idempotency_key, and nothing new was charged now. That call's billing: ${charge.note}`
+                : charge.note;
+            const restart = applied.noOp || replayed
+                ? UNCHANGED_RESTART
+                : restartNote(status, 'skill change');
+            const firstCredential = credentialsNeeded[0]?.credentials[0];
+            const nextAction = applied.noOp || replayed
+                ? undefined
+                : firstCredential
+                    ? {
+                        tool: 'set_agent_credentials',
+                        arguments: { agent_guid, credential: firstCredential },
+                        reason: `See what ${firstCredential} needs before asking the user for it.`,
+                    }
+                    : running
+                        ? {
+                            tool: 'get_my_agent',
+                            arguments: { agent_guid, wait_seconds: DEFAULT_WAIT_SECONDS },
+                            reason: 'Check that the agent is running again with the new skills.',
+                        }
+                        : undefined;
+            const lines = [
+                applied.noOp ? '## No change needed' : replayed ? '## Already applied' : '## Skills updated',
+                '',
+                `**Agent:** \`${agent_guid}\``,
+                listLine('Turned on', changes.enable),
+                listLine('Turned off', changes.disable),
+                applied.noOp || replayed ? listLine('Already as requested', changes.alreadySet) : null,
+                tierChange && !applied.noOp ? `**Plan:** now ${asString(applied.tier) ?? tierChange}` : null,
+                pricing?.newMonthlyUsd !== undefined && pricing.newMonthlyUsd !== null
+                    ? `**Monthly price:** ${formatUsd(pricing.newMonthlyUsd)}${pricing.currentMonthlyUsd !== null ? ` (was ${formatUsd(pricing.currentMonthlyUsd)})` : ''}`
+                    : null,
+                `**Billing:** ${billingNote}`,
+                `**Restart:** ${restart}`,
+                holds === null ? 'The agent could not be read afterwards to confirm the new skills; get_my_agent shows them.' : null,
+                credentialsNeeded.length > 0
+                    ? `**Still needed:** credentials for ${credentialsNeeded.map(entry => `${entry.skill} (${entry.credentials.join(', ')})`).join('; ')}. Set them with set_agent_credentials or connect_agent_oauth.`
+                    : null,
+            ].filter((line) => line !== null);
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }],
+                structuredContent: {
+                    ...base,
+                    status: applied.noOp ? 'no_change' : 'applied',
+                    idempotencyKey: key,
+                    ...(pricing ? { pricing } : {}),
+                    billing: { ...billingBase, chargedNowUsd: charge.charged, note: billingNote },
+                    ...(Array.isArray(serverPricing.enabledSkills) ? { enabledSkills: serverPricing.enabledSkills.map(String) } : {}),
+                    restart,
+                    ...(nextAction ? { nextAction } : {}),
+                },
+            };
+        }
+        catch (error) {
+            const hint = error instanceof Error ? workspaceHint(error.message) : undefined;
+            return errorResult(hint && error instanceof Error ? new Error(`${error.message} ${hint}`) : error);
+        }
+    });
+}
+//# sourceMappingURL=apply-agent-skills.js.map