opencrowd 0.6.0 → 0.6.1

package/bundle/opencrowd.js

@@ -16114,6 +16114,41 @@ var init_spending = __esm({
   }
 });
 
+// ../../packages/protocol/dist/financial-state.js
+var usdc, FinancialStateSchema;
+var init_financial_state = __esm({
+  "../../packages/protocol/dist/financial-state.js"() {
+    "use strict";
+    init_zod();
+    usdc = external_exports.string().regex(/^\d+\.\d{6}$/);
+    FinancialStateSchema = external_exports.discriminatedUnion("status", [
+      external_exports.object({
+        status: external_exports.literal("available"),
+        run_id: external_exports.string().uuid(),
+        observed_at: external_exports.string().datetime(),
+        currency: external_exports.literal("USDC"),
+        wallet: external_exports.object({
+          balance_status: external_exports.enum(["available", "unavailable"]),
+          balance_usdc: usdc.nullable(),
+          reserved_usdc: usdc,
+          available_usdc: usdc.nullable()
+        }),
+        current_run: external_exports.object({
+          inference_spent_usdc: usdc,
+          service_spent_usdc: usdc,
+          total_spent_usdc: usdc,
+          reserved_usdc: usdc,
+          budget_limit_usdc: usdc,
+          remaining_budget_usdc: usdc,
+          per_call_approval_threshold_usdc: usdc,
+          approval_mode: external_exports.enum(["auto", "ask", "off"])
+        })
+      }),
+      external_exports.object({ status: external_exports.literal("unavailable"), reason: external_exports.string() })
+    ]);
+  }
+});
+
 // ../../packages/protocol/dist/index.js
 var init_dist = __esm({
   "../../packages/protocol/dist/index.js"() {
@@ -16129,6 +16164,7 @@ var init_dist = __esm({
     init_codec();
     init_context();
     init_spending();
+    init_financial_state();
   }
 });
 
@@ -34182,6 +34218,7 @@ var init_gateway = __esm({
         if (outcome === "unknown") {
           const missingReceipt = result.ambiguityReason === "missing_receipt";
           const unsupportedReceipt = result.ambiguityReason === "unsupported_receipt";
+          const timedOut = result.ambiguityReason === "timeout";
           return {
             ok: false,
             error: missingReceipt ? [
@@ -34190,6 +34227,9 @@ var init_gateway = __esm({
             ].join(" ") : unsupportedReceipt ? [
               `the call to ${endpoint} returned a settlement receipt on an unsupported payment rail (recorded as purchase ${purchaseId}).`,
               "It was NOT retried and must not be retried automatically; reconcile the payment manually before continuing."
+            ].join(" ") : timedOut ? [
+              `the call to ${endpoint} did not answer within the wait limit and its payment state is unknown (recorded as purchase ${purchaseId}).`,
+              "The stored purchase was checked once without a final result. It was NOT retried and must not be retried automatically; the owner can reconcile it from the payment ledger."
             ].join(" ") : [
               `the call to ${endpoint} failed in transport and its payment state is unknown (recorded as purchase ${purchaseId}).`,
               "It was NOT retried and must not be retried automatically; verify the service state before calling again."
@@ -80049,12 +80089,15 @@ function economyTools(economy, options = {}) {
     execute: async (name, args, operationId) => {
       if (options.resuming && name === "call_paid_service")
         await economy.execute("inspect_paid_service", { url: args.url, method: args.method, sample_body: args.body });
-      return economy.execute(name, args, operationId);
+      const result = await economy.execute(name, args, operationId);
+      if (name === "request_service" && result.ok)
+        reflected = true;
+      return result;
     },
-    completionGate: async () => {
+    completionGate: async (alreadyNudged = false) => {
       const pending = await economy.hasPendingRequiredReviews();
       const review = pending ? "A paid purchase still needs its required review; submit it with review_paid_service." : "";
-      if (reflected || !supportsReflection)
+      if (reflected || alreadyNudged || !supportsReflection)
         return review || void 0;
       reflected = true;
       const status = await economy.execute("crowdcode_status", {});
@@ -80174,7 +80217,7 @@ import { isAbsolute as isAbsolute3 } from "node:path";
 function createHostedProvider(options) {
   if (!isAbsolute3(options.socketPath))
     throw new Error("Hosted bridge socket must be absolute");
-  const tools = [...OPEN_CROWD_TOOLS.filter((tool) => !["spawn_subagent", "check_subagents"].includes(tool.name)), ...options.extraTools ?? []];
+  const tools = [...OPEN_CROWD_TOOLS.filter((tool) => !["spawn_subagent", "check_subagents"].includes(tool.name)).map((tool) => tool.name === "get_budget_status" ? { ...tool, description: "Read authoritative hosted finances: live USDC wallet balance, settled inference and service spending, pending holds, and remaining authorized budget for this run." } : tool), ...options.extraTools ?? []];
   return {
     async complete(messages, context) {
       const operationId = context?.operationId;
@@ -80254,6 +80297,16 @@ function rejectedRequest(status, text) {
     return void 0;
   }
 }
+async function readHostedFinancialState(options) {
+  try {
+    const reply = await postHostedTool(options, "economy.balance", {}, { timeoutMs: 1e4 });
+    const parsed = FinancialStateSchema.safeParse(reply.data?.financial_state);
+    if (reply.ok && parsed.success && parsed.data.status === "available" && parsed.data.run_id === options.runId)
+      return parsed.data;
+  } catch {
+  }
+  return { status: "unavailable", reason: "Hosted financial state could not be read. Do not infer balance or spending from the local session budget." };
+}
 async function postHostedTool(options, name, args, settings = {}) {
   if (!isAbsolute3(options.socketPath))
     throw new Error("Hosted bridge socket must be absolute");
@@ -80288,7 +80341,8 @@ async function postHostedTool(options, name, args, settings = {}) {
         }
       });
     });
-    req.setTimeout(settings.timeoutMs ?? SERVICE_BRIDGE_TIMEOUT_MS, () => req.destroy(new Error("Hosted tool timed out")));
+    const timeoutMs = settings.timeoutMs ?? SERVICE_BRIDGE_TIMEOUT_MS;
+    req.setTimeout(timeoutMs, () => req.destroy(new HostedToolTimeout(name, timeoutMs)));
     req.on("error", reject);
     req.end(body);
   });
@@ -80322,7 +80376,7 @@ function createHostedToolExecutor(options) {
     }
   };
 }
-var HostedRequestError, HOSTED_TOOL_REQUEST_BYTES;
+var HostedRequestError, HOSTED_TOOL_REQUEST_BYTES, HostedToolTimeout;
 var init_hosted_provider = __esm({
   "../../packages/agent-runtime/dist/hosted-provider.js"() {
     "use strict";
@@ -80340,6 +80394,15 @@ var init_hosted_provider = __esm({
       }
     };
     HOSTED_TOOL_REQUEST_BYTES = 1024 * 1024;
+    HostedToolTimeout = class extends Error {
+      timeoutMs;
+      code = "hosted_tool_timeout";
+      constructor(name, timeoutMs) {
+        super(`Hosted tool ${name} timed out after ${Math.round(timeoutMs / 1e3)}s`);
+        this.timeoutMs = timeoutMs;
+        this.name = "HostedToolTimeout";
+      }
+    };
   }
 });
 
@@ -80352,7 +80415,7 @@ function createHostedEconomy(options) {
   const directory = new ServiceDirectory(fetcher, (options.crowdcodeBase ?? DEFAULT_CROWDCODE_BASE).replace(/\/+$/, ""));
   return new EconomyGateway({
     session: options.session,
-    agentcash: new HostedAgentCashAdapter(directory, socket, fetcher),
+    agentcash: new HostedAgentCashAdapter(directory, socket, fetcher, options.reconcileDelayMs),
     crowdcode: new HostedCrowdCodeAdapter(directory, socket),
     approvalMode: "auto",
     hostedSpending: true,
@@ -80362,7 +80425,8 @@ function createHostedEconomy(options) {
   });
 }
 function hostedDynamicTools(economy) {
-  return economyTools(economy, { hidden: HIDDEN_HOSTED_TOOLS });
+  const tools = economyTools(economy, { hidden: HIDDEN_HOSTED_TOOLS });
+  return { ...tools, definitions: tools.definitions.map((tool) => tool.name === "get_wallet_status" ? { ...tool, description: "Read this hosted agent's USDC wallet balance and authoritative current-run inference spending, service spending, payment holds and authorized budget. Read-only." } : tool) };
 }
 function parseListedService(raw) {
   const row = objectValue4(raw);
@@ -80426,7 +80490,7 @@ function numberValue6(value) {
   }
   return void 0;
 }
-var DEFAULT_CROWDCODE_BASE, LIST_CACHE_MS, PAY_TIMEOUT_MS, FREE_FETCH_TIMEOUT_MS, USDC_ATOMIC_PER_USD, HIDDEN_HOSTED_TOOLS, ServiceDirectory, HostedAgentCashAdapter, HostedCrowdCodeAdapter;
+var DEFAULT_CROWDCODE_BASE, LIST_CACHE_MS, PAY_TIMEOUT_MS, RECONCILE_DELAY_MS, NOT_SENT_CODES, FREE_FETCH_TIMEOUT_MS, USDC_ATOMIC_PER_USD, HIDDEN_HOSTED_TOOLS, ServiceDirectory, HostedAgentCashAdapter, HostedCrowdCodeAdapter;
 var init_hosted_economy = __esm({
   "../../packages/agent-runtime/dist/hosted-economy.js"() {
     "use strict";
@@ -80434,14 +80498,17 @@ var init_hosted_economy = __esm({
     init_worker();
     init_dist2();
     init_dist4();
+    init_dist();
     init_hosted_provider();
     init_economy_tools();
     DEFAULT_CROWDCODE_BASE = "https://crowdcode-backend.onrender.com";
     LIST_CACHE_MS = 6e4;
-    PAY_TIMEOUT_MS = 12e4;
+    PAY_TIMEOUT_MS = SERVICE_GATEWAY_TIMEOUT_MS + 3e4;
+    RECONCILE_DELAY_MS = 2e3;
+    NOT_SENT_CODES = /* @__PURE__ */ new Set(["ENOENT", "ECONNREFUSED", "EACCES", "ENOTDIR"]);
     FREE_FETCH_TIMEOUT_MS = 3e4;
     USDC_ATOMIC_PER_USD = 1e6;
-    HIDDEN_HOSTED_TOOLS = /* @__PURE__ */ new Set(["bridge_usdc", "get_wallet_status"]);
+    HIDDEN_HOSTED_TOOLS = /* @__PURE__ */ new Set(["bridge_usdc"]);
     ServiceDirectory = class {
       fetcher;
       base;
@@ -80488,12 +80555,14 @@ var init_hosted_economy = __esm({
       directory;
       socket;
       fetcher;
+      reconcileDelayMs;
       /** Rails observed by inspection; `fetch` refuses anything but Base x402 regardless of the caller's rail. */
       inspectedRails = /* @__PURE__ */ new Map();
-      constructor(directory, socket, fetcher) {
+      constructor(directory, socket, fetcher, reconcileDelayMs = RECONCILE_DELAY_MS) {
         this.directory = directory;
         this.socket = socket;
         this.fetcher = fetcher;
+        this.reconcileDelayMs = reconcileDelayMs;
         this.discovery = new BaseServiceDiscovery(async (query, options) => {
           const reply = await postHostedTool(this.socket, "economy.read", {
             url: "https://agentcash.dev/api/search",
@@ -80549,24 +80618,31 @@ var init_hosted_economy = __esm({
         const body = request2.body === void 0 ? void 0 : typeof request2.body === "string" ? request2.body : JSON.stringify(request2.body);
         const hash5 = request2.operationId ? createHash4("sha256").update(`${this.socket.runId}:${request2.operationId}`).digest("hex") : void 0;
         const purchaseId = hash5 ? `${hash5.slice(0, 8)}-${hash5.slice(8, 12)}-4${hash5.slice(13, 16)}-8${hash5.slice(17, 20)}-${hash5.slice(20, 32)}` : randomUUID7();
-        let reply;
+        const payArgs = {
+          purchase_request_id: purchaseId,
+          service_id: serviceId,
+          url: request2.url,
+          method,
+          body,
+          max_cost_cents: Math.ceil(request2.maxAmountUsd * 100)
+        };
+        const timeoutMs = Math.min(request2.timeoutMs ?? PAY_TIMEOUT_MS, PAY_TIMEOUT_MS);
+        let reply, timedOut = false;
         try {
-          reply = await postHostedTool(this.socket, "economy.pay", {
-            purchase_request_id: purchaseId,
-            service_id: serviceId,
-            url: request2.url,
-            method,
-            body,
-            max_cost_cents: Math.ceil(request2.maxAmountUsd * 100)
-          }, { timeoutMs: request2.timeoutMs ?? PAY_TIMEOUT_MS });
+          reply = await postHostedTool(this.socket, "economy.pay", payArgs, { timeoutMs });
         } catch (error53) {
-          return {
-            ok: false,
-            ambiguous: true,
-            ambiguityReason: "transport",
-            data: void 0,
-            error: `payment request to the supervisor failed in transport: ${error53.message}`
-          };
+          timedOut = error53 instanceof HostedToolTimeout;
+          const recovered = await this.reconcile(error53, payArgs, timeoutMs);
+          if (!recovered) {
+            return {
+              ok: false,
+              ambiguous: true,
+              ambiguityReason: timedOut ? "timeout" : "transport",
+              data: void 0,
+              error: timedOut ? `the paid call did not answer within ${Math.round(timeoutMs / 1e3)}s and its stored purchase has no final result yet` : `payment request to the supervisor failed in transport: ${error53.message}`
+            };
+          }
+          reply = recovered;
         }
         if (reply.ok) {
           const data = objectValue4(reply.data) ?? {};
@@ -80599,13 +80675,29 @@ var init_hosted_economy = __esm({
           return {
             ok: false,
             ambiguous: true,
-            ambiguityReason: "transport",
+            ambiguityReason: timedOut ? "timeout" : "transport",
             data: void 0,
-            error: reply.error ?? "the supervisor could not determine whether the payment settled"
+            error: timedOut ? `the paid call did not answer within ${Math.round(timeoutMs / 1e3)}s and its stored purchase has no final result yet` : reply.error ?? "the supervisor could not determine whether the payment settled"
           };
         }
         return refuse(reply.code ? `${reply.error ?? "payment refused"} (${reply.code})` : reply.error ?? "payment refused");
       }
+      /**
+       * Re-post the same purchase once. A finished attempt replays from the ledger;
+       * an attempt still in flight answers payment_unknown; a request that never
+       * reached the supervisor is not reconciled because nothing was started.
+       */
+      async reconcile(error53, payArgs, timeoutMs) {
+        const code = error53?.code;
+        if (typeof code === "string" && NOT_SENT_CODES.has(code))
+          return void 0;
+        await new Promise((resolve9) => setTimeout(resolve9, this.reconcileDelayMs));
+        try {
+          return await postHostedTool(this.socket, "economy.pay", payArgs, { timeoutMs });
+        } catch {
+          return void 0;
+        }
+      }
       /** The supervisor found no 402: the endpoint is free, so the worker fetches it itself. */
       async fetchUnpaid(url3, method, body, headers) {
         try {
@@ -80948,6 +81040,15 @@ var init_worker = __esm({
           const hosted = this.options.hostedTools?.(run.start, session);
           const economy = this.options.economy?.(run.start, session);
           const dynamicTools = economy ? hostedDynamicTools(economy) : void 0;
+          let latestFinancialState = { status: "unavailable", reason: "Hosted financial state has not been read." };
+          const financialState = this.options.financialState ? async () => {
+            try {
+              latestFinancialState = await this.options.financialState(run.start, session);
+            } catch {
+              latestFinancialState = { status: "unavailable", reason: "Hosted financial state could not be read; do not use local budget figures." };
+            }
+            return latestFinancialState;
+          } : void 0;
           const record3 = async (name, args, invoke) => {
             const call2 = run.checkpoint?.response?.toolCalls.find((c) => c.name === name && !run.checkpoint?.completedTools[c.id]);
             const id = `${run.checkpoint?.turn ?? 0}:${call2?.id ?? randomUUID8()}`;
@@ -80971,6 +81072,10 @@ var init_worker = __esm({
               if (saved?.approvalPending && name === "call_paid_service" && economy)
                 await economy.execute("inspect_paid_service", { url: args.url, method: args.method, sample_body: args.body });
               output3 = await invoke();
+              if (financialState && name === "get_budget_status")
+                output3 = { ok: true, data: latestFinancialState };
+              if (financialState && name === "complete_session" && output3.ok && output3.data && typeof output3.data === "object")
+                output3 = { ...output3, data: { ...output3.data, budget: latestFinancialState } };
             } catch (error53) {
               if (error53 instanceof RuntimePause && error53.outcome === "waiting_for_approval")
                 await this.mutate(() => {
@@ -81066,10 +81171,11 @@ var init_worker = __esm({
             contextWindowTokens: run.start.payload.modelPolicy.contextWindowTokens,
             maxOutputTokens: run.start.payload.modelPolicy.maxOutputTokens,
             provider,
+            financialState,
             history: run.checkpoint ? void 0 : await this.history(session),
             ...dynamicTools ? {
               dynamicTools: { definitions: dynamicTools.definitions, execute: (name, args) => record3(name, args, () => dynamicTools.execute(name, args, `${run.checkpoint?.turn ?? 0}:${run.checkpoint?.response?.toolCalls.find((c) => c.name === name && !run.checkpoint?.completedTools[c.id])?.id}`)) },
-              completionGate: () => dynamicTools.completionGate(),
+              completionGate: (alreadyNudged) => dynamicTools.completionGate(alreadyNudged),
               knowledge: await this.knowledgeOption(session)
             } : {},
             onCheckpoint: async (checkpoint) => {
@@ -81392,6 +81498,8 @@ async function runAgentTaskDetailed(session, task, options = {}) {
     "Try to solve the user's task completely. Use local files and bash when they are sufficient, but remember they are bounded by the user's installed tools, credentials, network, open ports, and process lifetime.",
     "Before repeatedly fighting the local environment, decide whether the task needs external capability such as hosting, persistent infrastructure, remote compute, specialized APIs, live data, or access the user's device does not have."
   ];
+  if (options.hosted)
+    systemPromptParts.push("You operate this service for its owner. Inference and paid tools debit its USDC wallet. When authorized to build or sell a service, take concrete steps within the owner's configured scope and budget. Ask only for missing information or permissions that materially block progress. Report actual costs and outcomes. Financial sustainability is the owner's business objective; respect their stop controls.", "Financial state: the current hosted financial snapshot is authoritative; historical local session budget figures are not wallet balances and may omit inference spending. Wallet balance, pending payment holds, settled inference spend, settled service spend, and remaining run budget are separate. Spending totals cover only the identified current run. A budget limit does not supply funds. An unavailable balance is unknown, not zero. The snapshot before a model call excludes that call's eventual charge; never claim a response was free or that you spent nothing merely because no paid tool ran. Use get_budget_status or get_wallet_status for refreshed financial state. Respect approval mode and per-call limits; over-limit requests require the owner's approval.");
   if (options.dynamicTools) {
     systemPromptParts.push("When the local computer is not the right environment, or after one clear local capability failure, buy external capability: find_paid_service to discover, inspect_paid_service to see the exact schema/price/reputation, call_paid_service to execute through the enforced purchase lifecycle, and review_paid_service for the required review after every confirmed paid call (success or failure). The same review tool accepts unpaid experiences; review relevant free results or failed attempts without inventing payment evidence. Distinguish provider faults from local errors and uncertain failures.", ...options.hosted ? ["Discover services through AgentCash search and provider catalogs. You can use new services without prior CrowdCode reviews. Only x402 USDC on Base is payable, within the user's configured limits; over-limit quotes request approval. Use read_service for authenticated job polling and never resubmit a pending generation job."] : [], capabilityIndex ?? DEFAULT_CAPABILITY_INDEX, "When a task needs current web facts, search results, or unfamiliar page content, make one paid web search your FIRST move \u2014 do not serially guess URLs with curl; one paid search replaces minutes of blind fetching and costs less than the LLM turns it saves.", "Approval, budget, reputation, and payment rails are enforced in code \u2014 you cannot bypass them, so state costs plainly and never invent payment details.", "When the user says CrowdCode on/off, call set_crowdcode_enabled; default to session scope unless they ask for a persistent default. Use list_my_reviews and delete_my_review for user-directed review management, including while off. Before finishing a substantive task, consider concrete paid services that would fix real shortcomings and submit qualifying demand with request_service, unless CrowdCode is off. Never invent a purchase or demand.", "Each tool result includes the budget before and after that tool call. Never ask for wallet private keys or secrets.", ...options.promptSections ?? []);
   } else {
@@ -81413,11 +81521,24 @@ async function runAgentTaskDetailed(session, task, options = {}) {
     ...options.history ?? [],
     { role: "user", content: task }
   ];
+  let financial = { status: "unavailable", reason: "Hosted financial state has not been read." };
+  const refreshFinancialState = async () => {
+    if (!options.financialState)
+      return;
+    try {
+      financial = FinancialStateSchema.parse(await options.financialState());
+    } catch {
+      financial = { status: "unavailable", reason: "Hosted financial state could not be read; do not use local budget figures." };
+    }
+  };
+  const currentBudget = () => options.financialState ? financial : budgetStatus(session);
+  const financialPrefix = "Current hosted financial snapshot: ";
   if (!options.resume)
     await options.onMessage?.({ role: "user", content: task });
   const maxTurns = options.maxTurns ?? 100;
   const repeatedFailures = new Map(options.resume?.repeatedFailures);
   let completionNudges = options.resume?.completionNudges ?? 0;
+  let pendingFinalMessage = options.resume?.pendingFinalMessage;
   let outputContinuationNudges = options.resume?.outputContinuationNudges ?? 0;
   let outputContinuationPrefix = options.resume?.outputContinuationPrefix ?? "";
   let serviceCallFailures = options.resume?.serviceCallFailures ?? 0;
@@ -81431,6 +81552,7 @@ async function runAgentTaskDetailed(session, task, options = {}) {
       context: contextState,
       deliveredMessageIds: [...deliveredMessageIds],
       completionNudges,
+      pendingFinalMessage,
       outputContinuationNudges,
       outputContinuationPrefix,
       serviceCallFailures,
@@ -81444,8 +81566,11 @@ async function runAgentTaskDetailed(session, task, options = {}) {
       messages.push({ role: "user", content: message.prompt });
       deliveredMessageIds.add(message.id);
     }
-    if (fresh.length)
+    if (fresh.length) {
+      pendingFinalMessage = void 0;
+      outputContinuationPrefix = "";
       await checkpoint(turn);
+    }
     for (const message of fresh)
       await options.onMessage?.({ role: "user", content: message.prompt });
     if (pending.length)
@@ -81473,6 +81598,15 @@ async function runAgentTaskDetailed(session, task, options = {}) {
     options.onProgress?.({ type: "calling_llm", message: `Calling LLM provider (turn ${turn + 1}/${maxTurns})` });
     let response;
     try {
+      if (options.financialState && !restored?.response && !contextState.prepared) {
+        await refreshFinancialState();
+        const snapshot = { role: "system", content: financialPrefix + JSON.stringify(financial) };
+        const index2 = messages.findIndex((m) => m.role === "system" && m.content.startsWith(financialPrefix));
+        if (index2 === -1)
+          messages.splice(1, 0, snapshot);
+        else
+          messages[index2] = snapshot;
+      }
       response = restored?.response ?? await completeWithContext(session, messages, {
         provider: provider instanceof MockLlmProvider ? { complete: (input2) => completeMockLlmCall(session, provider, input2, turn + 1) } : provider,
         tools: wireToolDefinitions(enabledTools, dynamicDefinitions),
@@ -81489,6 +81623,7 @@ async function runAgentTaskDetailed(session, task, options = {}) {
         }
       });
       options.signal?.throwIfAborted();
+      await refreshFinancialState();
     } catch (error53) {
       if (error53 instanceof BudgetExhaustedError) {
         const summary2 = await completeSession(session, `Stopped: the session budget is exhausted (${error53.message}).`);
@@ -81522,7 +81657,10 @@ ${outputContinuationPrefix}`);
     if (response.toolCalls.length === 0) {
       if (await injectMessages(turn + 1))
         continue;
-      const blocker = await options.completionGate?.();
+      const finalMessage = response.content.trim() ? outputContinuationPrefix + response.content : pendingFinalMessage ?? outputContinuationPrefix;
+      if (finalMessage.trim())
+        pendingFinalMessage = finalMessage;
+      const blocker = await options.completionGate?.(completionNudges > 0);
       if (blocker) {
         if (completionNudges >= 1) {
           const summary3 = await completeSession(session, `Stopped: ${blocker}`);
@@ -81532,9 +81670,12 @@ ${outputContinuationPrefix}`);
         const nudge = { role: "user", content: `You cannot finish yet: ${blocker}` };
         messages.push(nudge);
         await options.onMessage?.(nudge);
+        await checkpoint(turn + 1);
         continue;
       }
-      const summary2 = await completeSession(session, outputContinuationPrefix + (response.content || "Session completed."));
+      if (!pendingFinalMessage?.trim())
+        throw new Error("The model ended without an answer.");
+      const summary2 = await completeSession(session, pendingFinalMessage);
       return { outcome: "completed", summary: summary2, turns: turn + 1 };
     }
     const spawnedThisTurn = /* @__PURE__ */ new Map();
@@ -81577,7 +81718,7 @@ ${outputContinuationPrefix}`);
         message: `Tool call: ${summarizeToolCall(call2)}`,
         data: { tool: call2.name, arguments: call2.arguments }
       });
-      const budgetBeforeToolCall = budgetStatus(session);
+      const budgetBeforeToolCall = currentBudget();
       const callArguments = call2.name === "complete_session" && outputContinuationPrefix ? {
         ...call2.arguments,
         final_message: outputContinuationPrefix + (typeof call2.arguments.final_message === "string" ? call2.arguments.final_message : "")
@@ -81615,7 +81756,13 @@ ${outputContinuationPrefix}`);
       } else {
         result = { ok: false, error: `unknown tool: ${call2.name}` };
       }
-      const budgetAfterToolCall = budgetStatus(session);
+      await refreshFinancialState();
+      const budgetAfterToolCall = currentBudget();
+      if (options.financialState && call2.name === "get_budget_status")
+        result = { ok: true, data: financial };
+      if (options.financialState && call2.name === "complete_session" && result.ok && result.data && typeof result.data === "object") {
+        result = { ...result, data: { ...result.data, budget: financial } };
+      }
       options.onProgress?.({
         type: "tool_result",
         message: `Tool result: ${summarizeToolResult(call2.name, result)}`,
@@ -81636,6 +81783,8 @@ ${outputContinuationPrefix}`);
         await checkpoint(turn, response, completedTools);
         await options.onMessage?.(toolMessage);
       }
+      if (call2.name === "call_paid_service" && result.ok)
+        serviceCallFailures = 0;
       if (!result.ok) {
         if (call2.name === "call_paid_service") {
           serviceCallFailures += 1;
@@ -81659,7 +81808,12 @@ ${outputContinuationPrefix}`);
       const result = completedTools[call2.id];
       if (await injectMessages(turn + 1))
         continue;
-      const blocker = await options.completionGate?.();
+      if (!result.ok)
+        continue;
+      const finalMessage = result.data && typeof result.data === "object" ? result.data.final_message : void 0;
+      if (typeof finalMessage === "string" && finalMessage.trim())
+        pendingFinalMessage = finalMessage;
+      const blocker = await options.completionGate?.(completionNudges > 0);
       if (blocker) {
         if (completionNudges >= 1) {
           const summary3 = await completeSession(session, `Stopped: ${blocker}`);
@@ -81667,23 +81821,25 @@ ${outputContinuationPrefix}`);
         }
         completionNudges += 1;
         const gateMessage = {
-          role: "tool",
-          toolCallId: call2.id,
-          content: JSON.stringify({ result: { ok: false, error: `cannot complete yet: ${blocker}` } })
+          role: "user",
+          content: `You cannot finish yet: ${blocker}`
         };
         messages.push(gateMessage);
         await options.onMessage?.(gateMessage);
+        await checkpoint(turn + 1);
         continue;
       }
+      if (!pendingFinalMessage?.trim())
+        throw new Error("The model ended without an answer.");
       const backgroundResults = backgroundSubagents.size > 0 ? await drainBackground() : void 0;
-      if (result.ok && result.data && typeof result.data === "object") {
-        const summary3 = { ...result.data };
+      if (result.data && typeof result.data === "object") {
+        const summary3 = { ...result.data, final_message: pendingFinalMessage };
         if (backgroundResults) {
           summary3.background_subagents = backgroundResults;
         }
         return { outcome: "completed", summary: summary3, turns: turn + 1 };
       }
-      const summary2 = await completeSession(session, outputContinuationPrefix + (response.content || result.error || "Session completed."));
+      const summary2 = await completeSession(session, pendingFinalMessage);
       if (backgroundResults) {
         summary2.background_subagents = backgroundResults;
       }
@@ -82175,6 +82331,8 @@ function summarizeToolResult(name, result) {
     return `call_paid_service ${String(data.outcome ?? "?")} HTTP ${String(data.status ?? "?")}, charged ${formatCents(Number(data.charged_cost_cents ?? 0))}${data.artifact_path ? `, saved ${String(data.artifact_path)}` : ""}`;
   }
   if (name === "get_budget_status" && result.data && typeof result.data === "object") {
+    if ("status" in result.data)
+      return `hosted finances: ${String(result.data.status)}`;
     const data = result.data;
     return `remaining ${formatCents(Number(data.remaining_cents ?? 0))}`;
   }
@@ -82629,6 +82787,7 @@ async function workerCommand(args) {
     provider: (run, session, extraTools) => socketPath ? createHostedProvider({ socketPath, runId: run.runId, sessionId: session.sessionId, extraTools }) : createWorkerDemoProvider(),
     hostedTools: socketPath ? (run, session) => createHostedToolExecutor({ socketPath, runId: run.runId, sessionId: session.sessionId }) : void 0,
     economy: socketPath ? (run, session) => createHostedEconomy({ socketPath, runId: run.runId, sessionId: session.sessionId, session }) : void 0,
+    financialState: socketPath ? (run, session) => readHostedFinancialState({ socketPath, runId: run.runId, sessionId: session.sessionId }) : void 0,
     output: (line) => {
       process.stdout.write(line);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencrowd",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "A CLI agent with its own wallet — discovers x402 services, pays in USDC, and completes tasks under a local budget",
   "type": "module",
   "license": "MIT",