@agentwonderland/mcp 0.1.23 → 0.1.24

package/src/tools/agent-info.ts

@@ -21,6 +21,15 @@ export function registerAgentInfoTools(server: McpServer): void {
       const s = (a.stats ?? {}) as Record<string, unknown>;
       const payment = (a.payment ?? {}) as Record<string, unknown>;
       const _pricing = (payment.pricing ?? {}) as Record<string, unknown>;
+      const creditPacks = payment.credit_packs as {
+        unit_type?: string;
+        packs?: Array<{
+          key?: string;
+          name?: string;
+          included_units?: number;
+          price_usd?: string;
+        }>;
+      } | null | undefined;
 
       const lines = [
         `${a.name}`,
@@ -41,6 +50,20 @@ export function registerAgentInfoTools(server: McpServer): void {
           const hint = outputTypeHint(a.tags as string[]);
           return hint ? [`Output: ${hint}`] : [];
         })(),
+        ...(() => {
+          if (!creditPacks?.packs?.length) return [];
+          const packLines = [
+            "",
+            `Discounted credit packs: ${creditPacks.unit_type ?? "run"}s`,
+          ];
+          for (const pack of creditPacks.packs) {
+            packLines.push(
+              `  ${pack.name ?? pack.key}: ${pack.included_units ?? 0} units for $${pack.price_usd ?? "0.00"}`,
+            );
+          }
+          packLines.push("  Use buy_agent_credit_pack to purchase one.");
+          return packLines;
+        })(),
       ];
 
       // Feedback summary (rating + tips)

package/src/tools/index.ts

@@ -7,3 +7,4 @@ export { registerRateTools } from "./rate.js";
 export { registerWalletTools } from "./wallet.js";
 export { registerFavoriteTools } from "./favorites.js";
 export { registerTipTools } from "./tip.js";
+export { registerPassTools } from "./passes.js";

package/src/tools/passes.ts

@@ -0,0 +1,234 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { apiGet, apiPostWithPayment } from "../core/api-client.js";
+import {
+  formatCreditPack,
+  formatCreditPackOffer,
+  getCreditPackProgram,
+} from "../core/passes.js";
+import {
+  getCompatiblePaymentMethods,
+  getConfiguredMethods,
+  hasWalletConfigured,
+  normalizePaymentMethod,
+} from "../core/payments.js";
+import { requiresSpendConfirmation } from "../core/config.js";
+import { ensureConsumerPrincipal } from "../core/principal.js";
+import { getOrCreatePendingCardSetup, formatCardSetupBlocks } from "../core/card-setup.js";
+import {
+  formatPaymentChoicePrompt,
+  formatPaymentLabel,
+  resolveConfirmationMethod,
+} from "./_payment-confirmation.js";
+import type { AgentRecord } from "../core/types.js";
+import type { CreditPackInventory, CreditPackOffer, CreditPackRecord } from "../core/passes.js";
+
+const pendingCreditPackPurchases = new Map<string, {
+  agentId: string;
+  agentName: string;
+  offer: CreditPackOffer;
+  method?: string;
+}>();
+
+function text(t: string) {
+  return { content: [{ type: "text" as const, text: t }] };
+}
+
+function multiText(...blocks: string[]) {
+  return { content: blocks.map((t) => ({ type: "text" as const, text: t })) };
+}
+
+async function getAgent(agentId: string): Promise<AgentRecord> {
+  return apiGet<AgentRecord>(`/agents/${agentId}`);
+}
+
+function findOffer(agent: AgentRecord, packId: string): CreditPackOffer | null {
+  const program = getCreditPackProgram(agent);
+  const pack = program?.packs?.find((candidate) => candidate.key === packId);
+  if (!pack) return null;
+
+  const price = Number(pack.price_usd ?? "0");
+  const units = pack.included_units ?? 0;
+  return {
+    pack_id: packId,
+    label: pack.name ?? pack.key ?? "Credit Pack",
+    included_units: units,
+    price_usd: price.toFixed(2),
+    effective_price_per_unit_usd: units > 0 ? (price / units).toFixed(6) : undefined,
+  };
+}
+
+export function registerPassTools(server: McpServer): void {
+  server.tool(
+    "buy_agent_credit_pack",
+    "Purchase a discounted prepaid credit pack for an agent. Credit packs are agent-specific and automatically cover future runs until the included units run out.",
+    {
+      agent_id: z.string().describe("Agent ID (UUID, slug, or name)"),
+      pack_id: z.string().optional().describe("Specific pack key to buy, like 'starter' or 'growth'. If omitted and only one pack exists, it is selected automatically."),
+      pay_with: z.string().optional().describe("Payment method — wallet ID, chain name, or 'card'. Auto-detected if omitted."),
+      confirmed: z.boolean().optional().describe("Set to true to confirm the purchase after seeing the quote."),
+    },
+    async ({ agent_id, pack_id, pay_with, confirmed }) => {
+      if (!hasWalletConfigured()) {
+        try {
+          const { url } = await getOrCreatePendingCardSetup();
+          return multiText(...formatCardSetupBlocks(url));
+        } catch {
+          return text(
+            "No payment method configured.\n\n" +
+            "To add a credit card: wallet_setup({ action: \"add-card\" })\n" +
+            "To use crypto: wallet_setup({ action: \"create\" })",
+          );
+        }
+      }
+
+      const agent = await getAgent(agent_id);
+      const agentName = agent.name ?? agent_id;
+      const principal = await ensureConsumerPrincipal();
+      const program = getCreditPackProgram(agent);
+      const offers = (program?.packs ?? [])
+        .map((pack) => findOffer(agent, pack.key ?? ""))
+        .filter((offer): offer is CreditPackOffer => !!offer);
+
+      if (offers.length === 0) {
+        return text(`${agentName} does not currently offer discounted credit packs.`);
+      }
+
+      const configuredMethods = getConfiguredMethods();
+      const compatibleMethods = getCompatiblePaymentMethods(agent, configuredMethods);
+      const pending = pendingCreditPackPurchases.get(agent.id);
+      const requestedMethod = pay_with ?? pending?.method;
+      const normalizedRequestedMethod = requestedMethod ? normalizePaymentMethod(requestedMethod) : null;
+
+      if (requestedMethod && !normalizedRequestedMethod) {
+        return text(
+          `Payment method "${requestedMethod}" is not configured.\n\n` +
+          "Use wallet_status to review your current payment methods.",
+        );
+      }
+
+      if (normalizedRequestedMethod && !compatibleMethods.includes(normalizedRequestedMethod)) {
+        return text(
+          `This agent cannot be paid with "${requestedMethod}".\n\n` +
+          `Available payment methods for this agent: ${compatibleMethods.join(", ") || "none"}.`,
+        );
+      }
+
+      if (!requestedMethod && compatibleMethods.length === 0) {
+        return text(
+          `No compatible payment methods are configured for ${agentName}.\n\n` +
+          `Your configured methods: ${configuredMethods.join(", ") || "none"}`,
+        );
+      }
+
+      if (!requestedMethod && compatibleMethods.length > 1) {
+        return text(
+          formatPaymentChoicePrompt(
+            `${agentName} credit-pack purchase`,
+            compatibleMethods,
+            compatibleMethods.map((method) => `  buy_agent_credit_pack({ agent_id: "${agent.id}"${pack_id ? `, pack_id: "${pack_id}"` : ""}, pay_with: "${method}" })`),
+          ),
+        );
+      }
+
+      let resolvedOffer: CreditPackOffer;
+      if (pack_id) {
+        const offer = offers.find((candidate) => candidate.pack_id === pack_id);
+        if (!offer) {
+          return text(
+            `Unknown credit pack "${pack_id}" for ${agentName}.\n\n` +
+            `Available packs:\n${offers.map((offer) => `  ${formatCreditPackOffer(offer)}`).join("\n")}`,
+          );
+        }
+        resolvedOffer = offer;
+      } else if (offers.length === 1) {
+        resolvedOffer = offers[0]!;
+      } else {
+        return text([
+          `Multiple credit packs are available for ${agentName}.`,
+          "",
+          ...offers.map((offer) => `  ${offer.pack_id}: ${formatCreditPackOffer(offer)}`),
+          "",
+          "Choose one by calling:",
+          `  buy_agent_credit_pack({ agent_id: "${agent.id}", pack_id: "${offers[0]!.pack_id}" })`,
+        ].join("\n"));
+      }
+
+      const method = resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
+
+      if (requiresSpendConfirmation() && !confirmed) {
+        pendingCreditPackPurchases.set(agent.id, {
+          agentId: agent.id,
+          agentName,
+          offer: resolvedOffer,
+          method,
+        });
+
+        return text([
+          `Ready to buy a credit pack for ${agentName}`,
+          "",
+          formatCreditPackOffer(resolvedOffer),
+          `Payment: ${formatPaymentLabel(method)}`,
+          `Consumer principal: ${principal}`,
+          "",
+          "To proceed, call:",
+          `  buy_agent_credit_pack({ agent_id: "${agent.id}", pack_id: "${resolvedOffer.pack_id}", pay_with: "${method}", confirmed: true })`,
+          "",
+          "To cancel, do nothing.",
+        ].join("\n"));
+      }
+
+      const result = await apiPostWithPayment<{
+        consumer_principal: string;
+        offer: CreditPackOffer;
+        credit_pack: CreditPackRecord;
+      }>(
+        `/agents/${agent.id}/credit-packs/purchase`,
+        { pack_id: resolvedOffer.pack_id },
+        method,
+        { ensureConsumerPrincipal: true },
+      );
+
+      pendingCreditPackPurchases.delete(agent.id);
+
+      return text([
+        `Credit pack purchased for ${agentName}`,
+        "",
+        formatCreditPackOffer(result.offer),
+        formatCreditPack(result.credit_pack),
+        `Consumer principal: ${result.consumer_principal}`,
+        "",
+        "Future runs through run_agent will automatically use this credit pack while units remain.",
+      ].join("\n"));
+    },
+  );
+
+  server.tool(
+    "list_agent_credit_packs",
+    "Show discounted credit-pack offers for an agent plus any balances available under the current consumer principal.",
+    {
+      agent_id: z.string().describe("Agent ID (UUID, slug, or name)"),
+    },
+    async ({ agent_id }) => {
+      const agent = await getAgent(agent_id);
+      const result = await apiGet<CreditPackInventory>(`/agents/${agent.id}/credit-packs`, { ensureConsumerPrincipal: true });
+
+      const lines = [
+        `Credit packs for ${agent.name}`,
+        ...(result.consumer_principal ? [`Consumer principal: ${result.consumer_principal}`] : []),
+      ];
+
+      if (result.offers.length > 0) {
+        lines.push("", "Available packs:", ...result.offers.map((offer) => `  ${offer.pack_id}: ${formatCreditPackOffer(offer)}`));
+      }
+
+      if (result.balances.length > 0) {
+        lines.push("", "Your balances:", ...result.balances.map((pack) => `  ${formatCreditPack(pack)}`));
+      } else {
+        lines.push("", "No purchased credit packs found for this agent.");
+      }
+
+      return text(lines.join("\n"));
+    },
+  );
+}

package/src/tools/run.ts

@@ -2,18 +2,36 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { apiGet, apiPost, apiPostWithPayment } from "../core/api-client.js";
 import { uploadLocalFiles } from "../core/file-upload.js";
-import { getConfiguredMethods, hasWalletConfigured, getWalletAddress } from "../core/payments.js";
+import {
+  formatCreditPackOffer,
+  getActiveCreditPack,
+  getCreditPackInventory,
+  getCreditPackProgram,
+} from "../core/passes.js";
+import {
+  getCompatiblePaymentMethods,
+  getConfiguredMethods,
+  hasWalletConfigured,
+  getWalletAddress,
+  normalizePaymentMethod,
+} from "../core/payments.js";
 import { requiresSpendConfirmation, getDefaultTipAmount } from "../core/config.js";
 import { formatRunResult } from "../core/formatters.js";
-import { storeFeedbackToken, getFeedbackToken } from "./_token-cache.js";
-import { initiateCardSetup, formatCardSetupBlocks } from "../core/card-setup.js";
+import { storeFeedbackToken } from "./_token-cache.js";
+import { getOrCreatePendingCardSetup, formatCardSetupBlocks } from "../core/card-setup.js";
+import {
+  formatPaymentChoicePrompt,
+  formatPaymentLabel,
+  formatRunConfirmationCommand,
+  resolveConfirmationMethod,
+} from "./_payment-confirmation.js";
+import type { AgentRecord } from "../core/types.js";
 
 const POLL_INTERVAL_MS = 3000;
-const POLL_MAX_MS = 120000; // 2 minutes
+const POLL_MAX_MS = 120000;
 
 async function pollJobUntilDone(
   jobId: string,
-  agentName: string,
 ): Promise<{ status: string; output?: unknown; error_code?: string }> {
   const deadline = Date.now() + POLL_MAX_MS;
   const walletAddress = await getWalletAddress();
@@ -34,9 +52,8 @@ async function pollJobUntilDone(
       if (job.status === "failed") {
         return { status: "failed", output: job.output, error_code: job.error_code };
       }
-      // Still processing — continue polling
     } catch {
-      // Ignore poll errors, keep trying until deadline
+      // Ignore poll errors until timeout.
     }
   }
 
@@ -51,17 +68,35 @@ function multiText(...blocks: string[]) {
   return { content: blocks.map((t) => ({ type: "text" as const, text: t })) };
 }
 
-// Pending confirmations: agent_id → { agent, input, method }
 const pendingRuns = new Map<string, {
   agent: { id: string; name: string; price: number };
   input: Record<string, unknown>;
   method?: string;
 }>();
 
+function buildCreditPackOfferLines(agent: AgentRecord): string[] {
+  const program = getCreditPackProgram(agent);
+  if (!program?.packs?.length) return [];
+
+  return [
+    "Discounted credit packs:",
+    ...program.packs.map((pack) => formatCreditPackOffer({
+      pack_id: pack.key ?? "",
+      label: pack.name ?? pack.key ?? "Credit Pack",
+      included_units: pack.included_units ?? 0,
+      price_usd: pack.price_usd ?? "0.00",
+      effective_price_per_unit_usd: (pack.included_units ?? 0) > 0 && pack.price_usd
+        ? (Number(pack.price_usd) / (pack.included_units ?? 1)).toFixed(6)
+        : undefined,
+    })).map((line) => `  ${line}`),
+    `  Buy one with buy_agent_credit_pack({ agent_id: "${agent.id}", pack_id: "<pack_id>" })`,
+  ];
+}
+
 export function registerRunTools(server: McpServer): void {
   server.tool(
     "run_agent",
-    "Run an AI agent from the marketplace. Pays automatically via configured wallet. Returns the agent's output, cost, and job ID for tracking. If spending confirmation is enabled, first call returns a price quote — call again with confirmed: true to execute. Local file paths in the input (e.g. /Users/.../photo.jpg) are automatically uploaded to temporary storage and replaced with download URLs — just pass the path directly, no base64 encoding needed.",
+    "Run an AI agent from the marketplace. Pays automatically via configured wallet. Returns the agent's output, cost, and job ID for tracking. If spending confirmation is enabled, first call returns a price quote — call again with confirmed: true to execute. Local file paths in the input (e.g. /Users/.../photo.jpg) are automatically uploaded to temporary storage and replaced with download URLs before execution.",
     {
       agent_id: z.string().describe("Agent ID (UUID, slug, or name)"),
       input: z.record(z.unknown()).describe("Input payload for the agent"),
@@ -71,51 +106,102 @@ export function registerRunTools(server: McpServer): void {
     async ({ agent_id, input, pay_with, confirmed }) => {
       if (!hasWalletConfigured()) {
         try {
-          const { qr, url } = await initiateCardSetup();
-          const blocks = formatCardSetupBlocks(qr, url);
-          return multiText(...blocks);
+          const { url } = await getOrCreatePendingCardSetup();
+          return multiText(...formatCardSetupBlocks(url));
         } catch {
           return text(
             "No payment method configured.\n\n" +
             "To add a credit card: wallet_setup({ action: \"add-card\" })\n" +
-            "To use crypto: wallet_setup({ action: \"create\" })"
+            "To use crypto: wallet_setup({ action: \"create\" })",
           );
         }
       }
 
-      // Resolve agent and fetch details
-      let agent: { id: string; name?: string; pricePer1kTokens?: string; successRate?: number };
+      let agent: AgentRecord;
       try {
-        agent = await apiGet<typeof agent>(`/agents/${agent_id}`);
+        agent = await apiGet<AgentRecord>(`/agents/${agent_id}`);
       } catch {
         return text(`Agent "${agent_id}" not found. Use search_agents to find available agents.`);
       }
 
       const price = parseFloat(agent.pricePer1kTokens ?? "0.01");
       const agentName = agent.name ?? agent_id;
+      const creditPackInventory = await getCreditPackInventory(agent.id);
+      const activeCreditPack = getActiveCreditPack(creditPackInventory);
+      const configuredMethods = getConfiguredMethods();
+      const compatibleMethods = getCompatiblePaymentMethods(agent, configuredMethods);
+      const pending = pendingRuns.get(agent.id);
+      const requestedMethod = pay_with ?? pending?.method;
+      const normalizedRequestedMethod = requestedMethod ? normalizePaymentMethod(requestedMethod) : null;
+
+      if (!activeCreditPack && requestedMethod && !normalizedRequestedMethod) {
+        return text(
+          `Payment method "${requestedMethod}" is not configured.\n\n` +
+          "Use wallet_status to review your current payment methods.",
+        );
+      }
+
+      if (!activeCreditPack && normalizedRequestedMethod && !compatibleMethods.includes(normalizedRequestedMethod)) {
+        return text(
+          `This agent cannot be paid with "${requestedMethod}".\n\n` +
+          `Available payment methods for this agent: ${compatibleMethods.join(", ") || "none"}.\n` +
+          "Use get_agent to inspect the agent details or choose another payment method.",
+        );
+      }
+
+      if (!activeCreditPack && !requestedMethod && compatibleMethods.length === 0) {
+        return text(
+          `No compatible payment methods are configured for ${agentName}.\n\n` +
+          `Your configured methods: ${configuredMethods.join(", ") || "none"}\n` +
+          `Agent accepts: ${agent.payment?.accepted_payments?.join(", ") || "unknown"}\n` +
+          "Use wallet_status to review your current setup.",
+        );
+      }
+
+      if (!activeCreditPack && !requestedMethod && compatibleMethods.length > 1) {
+        return text(
+          formatPaymentChoicePrompt(
+            agentName,
+            compatibleMethods,
+            compatibleMethods.map((method) => formatRunConfirmationCommand(agent.id, method).replace(", confirmed: true", "")),
+          ),
+        );
+      }
 
-      // Confirmation step: show price and wait for confirmed: true
-      if (requiresSpendConfirmation() && !confirmed) {
+      const method = activeCreditPack
+        ? undefined
+        : resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
+
+      if (!activeCreditPack && requiresSpendConfirmation() && !confirmed) {
         pendingRuns.set(agent.id, {
           agent: { id: agent.id, name: agentName, price },
           input,
-          method: pay_with,
+          method,
         });
 
-        return text([
+        const quoteLines = [
           `Ready to run ${agentName}`,
           "",
           `  Cost: $${price.toFixed(2)}`,
-          `  Payment: ${pay_with ?? getConfiguredMethods()[0] ?? "auto"}`,
+          `  Payment: ${formatPaymentLabel(method)}`,
+        ];
+
+        const creditPackLines = buildCreditPackOfferLines(agent);
+        if (creditPackLines.length > 0) {
+          quoteLines.push("", ...creditPackLines);
+        }
+
+        quoteLines.push(
           "",
           "To proceed, call:",
-          `  run_agent({ agent_id: "${agent.id}", input: <same>, confirmed: true })`,
+          formatRunConfirmationCommand(agent.id, method),
           "",
           "To cancel, do nothing.",
-        ].join("\n"));
+        );
+
+        return text(quoteLines.join("\n"));
       }
 
-      const method = pay_with;
       let processedInput: Record<string, unknown>;
       let uploadSummary = "";
       try {
@@ -123,30 +209,48 @@ export function registerRunTools(server: McpServer): void {
         processedInput = uploadResult.input;
         if (uploadResult.uploads.length > 0) {
           uploadSummary = uploadResult.uploads
-            .map((u) => `Uploaded ${u.field}: ${u.originalPath} → ${u.url}`)
+            .map((upload) => `Uploaded ${upload.field}: ${upload.originalPath} → ${upload.url}`)
             .join("\n");
         }
       } catch (err) {
         const msg = err instanceof Error ? err.message : "File upload failed";
         return text(`Error: ${msg}`);
       }
+
       let result: Record<string, unknown>;
       try {
-        result = await apiPostWithPayment<Record<string, unknown>>(
-          `/agents/${agent.id}/run`,
-          { input: processedInput },
-          method,
-        );
+        result = activeCreditPack
+          ? await apiPost<Record<string, unknown>>(
+            `/agents/${agent.id}/run`,
+            { input: processedInput },
+            { ensureConsumerPrincipal: true },
+          )
+          : await apiPostWithPayment<Record<string, unknown>>(
+            `/agents/${agent.id}/run`,
+            { input: processedInput },
+            method,
+          );
       } catch (err: unknown) {
         const apiErr = err as { status?: number; message?: string };
+        if (activeCreditPack && apiErr?.status === 402) {
+          return text(
+            `Your available credit packs for ${agentName} could not cover this run.\n\n` +
+            "Use list_agent_credit_packs to inspect your balances, or retry with a payment method.",
+          );
+        }
         if (apiErr?.status === 402) {
           const allMethods = getConfiguredMethods();
           const methodName = method ?? allMethods[0] ?? "auto";
+          const creditPackLines = buildCreditPackOfferLines(agent);
           return text(
-            `Payment failed — "${methodName}" payment was rejected.\n\n` +
-            "Check your payment method and try again.\n" +
-            (allMethods.length > 0 ? `Configured methods: ${allMethods.join(", ")}\n` : "") +
-            "Use wallet_status to check your current payment methods."
+            [
+              `Payment failed — "${methodName}" payment was rejected.`,
+              "",
+              "Check your payment method and try again.",
+              ...(allMethods.length > 0 ? [`Configured methods: ${allMethods.join(", ")}`] : []),
+              "Use wallet_status to check your current payment methods.",
+              ...(creditPackLines.length > 0 ? ["", ...creditPackLines] : []),
+            ].join("\n"),
           );
         }
         const msg = apiErr?.message ?? "Failed to run agent";
@@ -156,7 +260,6 @@ export function registerRunTools(server: McpServer): void {
         return text(`Error: ${msg}`);
       }
 
-      // Clean up pending confirmation
       pendingRuns.delete(agent.id);
 
       const formatted = formatRunResult(result, {
@@ -171,10 +274,10 @@ export function registerRunTools(server: McpServer): void {
 
       const actualCost = result.cost as number | undefined;
       const status = result.status as string;
+      const usedCreditPack = result.consumption_mode === "credit_pack";
 
-      // Async agent — poll until complete
       if (status === "processing") {
-        const pollResult = await pollJobUntilDone(jobId, agentName);
+        const pollResult = await pollJobUntilDone(jobId);
         if (pollResult.status === "completed") {
           const asyncFormatted = formatRunResult({
             ...result,
@@ -182,14 +285,15 @@ export function registerRunTools(server: McpServer): void {
             output: pollResult.output,
           }, { paymentMethod: method ?? getConfiguredMethods()[0] });
 
-          if (result.feedback_token) {
-            storeFeedbackToken(jobId, result.feedback_token as string, resultAgentId);
-          }
+          const asyncSpendLine = usedCreditPack
+            ? "This run used your available credit pack."
+            : actualCost != null
+              ? `Paid $${actualCost.toFixed(actualCost < 0.01 ? 4 : 2)}.`
+              : "This run completed successfully.";
 
-          const asyncCostLine = actualCost != null ? `Paid $${actualCost.toFixed(actualCost < 0.01 ? 4 : 2)}.` : "";
           const asyncFeedbackAsk = [
-            `IMPORTANT: After presenting the result above, you MUST ask the user:`,
-            `"${asyncCostLine} Was this result helpful? I can rate it (1-5 stars) or tip the builder for you."`,
+            "IMPORTANT: After presenting the result above, you MUST ask the user:",
+            `"${asyncSpendLine} Was this result helpful? I can rate it (1-5 stars) or tip the builder for you."`,
             "",
             `If the user wants to rate: rate_agent({ job_id: "${jobId}", rating: <1-5>, comment: "..." })`,
             `If the user wants to tip: tip_agent({ job_id: "${jobId}", agent_id: "${resultAgentId}", amount: 0.25 })`,
@@ -202,7 +306,6 @@ export function registerRunTools(server: McpServer): void {
           );
         }
 
-        // Async agent failed
         const failedFormatted = formatRunResult({
           ...result,
           status: "failed",
@@ -212,11 +315,12 @@ export function registerRunTools(server: McpServer): void {
 
         return multiText(
           uploadSummary ? `${uploadSummary}\n\n${failedFormatted}` : failedFormatted,
-          "The agent execution failed. A refund has been initiated automatically.",
+          usedCreditPack
+            ? "The agent execution failed and your reserved credit-pack unit was released automatically."
+            : "The agent execution failed. A refund has been initiated automatically.",
         );
       }
 
-      // Auto-tip if configured and run succeeded
       const defaultTip = getDefaultTipAmount();
       let tipLine = "";
       if (status === "success" && defaultTip > 0 && result.feedback_token) {
@@ -236,20 +340,24 @@ export function registerRunTools(server: McpServer): void {
       if (status !== "success") {
         return multiText(
           uploadSummary ? `${uploadSummary}\n\n${formatted}` : formatted,
-          "The agent execution failed. A refund has been initiated automatically.",
+          usedCreditPack
+            ? "The agent execution failed and your reserved credit-pack unit was released automatically."
+            : "The agent execution failed. A refund has been initiated automatically.",
         );
       }
 
-      const costLine = actualCost != null ? `Paid $${actualCost.toFixed(actualCost < 0.01 ? 4 : 2)}.` : "";
+      const costLine = usedCreditPack
+        ? ""
+        : actualCost != null
+          ? `Paid $${actualCost.toFixed(actualCost < 0.01 ? 4 : 2)}.`
+          : "";
+      const spendLine = usedCreditPack ? "This run used your available credit pack." : (costLine || "This run completed successfully.");
 
-      // Separate the feedback ask into its own content block so the LLM
-      // surfaces it to the user as a distinct follow-up question, rather than
-      // burying it inside a collapsed tool output.
       const feedbackAsk = [
-        `--- Job ${jobId} | ${agentName} | ${costLine} ---`,
+        `--- Job ${jobId} | ${agentName} | ${usedCreditPack ? "covered by credit pack" : (costLine || "completed")} ---`,
         "",
-        `IMPORTANT: After presenting the result above, you MUST ask the user:`,
-        `"${costLine} Was this result helpful? I can rate it (1-5 stars) or tip the builder for you."`,
+        "IMPORTANT: After presenting the result above, you MUST ask the user:",
+        `"${spendLine} Was this result helpful? I can rate it (1-5 stars) or tip the builder for you."`,
         tipLine,
         "",
         `If the user wants to rate: rate_agent({ job_id: "${jobId}", rating: <1-5>, comment: "..." })`,
@@ -259,7 +367,15 @@ export function registerRunTools(server: McpServer): void {
         `To save for later: favorite_agent({ agent_id: "${resultAgentId}" })`,
       ].join("\n");
 
-      return multiText(uploadSummary ? `${uploadSummary}\n\n${formatted}` : formatted, feedbackAsk);
+      const supplementalLines = !usedCreditPack
+        ? buildCreditPackOfferLines(agent)
+        : [];
+
+      const primaryBlock = uploadSummary ? `${uploadSummary}\n\n${formatted}` : formatted;
+      return multiText(
+        supplementalLines.length > 0 ? `${primaryBlock}\n\n${supplementalLines.join("\n")}` : primaryBlock,
+        feedbackAsk,
+      );
     },
   );
 }