@cogcoin/client 1.1.1 → 1.1.3

package/dist/wallet/mining/sentences.js

@@ -18,6 +18,14 @@ function createBuiltInProviderNotFoundError(options) {
         : `${providerLabel} returned HTTP 404 for model "${options.model}". The configured model override may be invalid. Rerun \`cogcoin mine setup\` to clear or correct it.`;
     return new MiningProviderRequestError("not-found", message);
 }
+function createBuiltInProviderTimeoutError(options) {
+    const providerName = options.provider === "anthropic" ? "Anthropic" : "OpenAI";
+    const seconds = Number.isInteger(options.timeoutMs / 1_000)
+        ? String(options.timeoutMs / 1_000)
+        : (options.timeoutMs / 1_000).toFixed(1);
+    const unit = seconds === "1" ? "second" : "seconds";
+    return new MiningProviderRequestError("unavailable", `The built-in ${providerName} mining provider timed out after ${seconds} ${unit}.`);
+}
 function buildSystemPrompt(extraPrompt) {
     const lines = [
         "You are helping generate candidate Cogcoin mining sentences.",
@@ -57,25 +65,89 @@ function annotateProviderCandidates(options) {
         },
     }));
 }
-function parseProviderJsonResponse(options) {
-    const response = parseStrictJsonValue(stripMarkdownCodeFence(options.raw), `${options.providerLabel} returned invalid JSON.`);
+const ANTHROPIC_MINING_RESPONSE_TOOL_NAME = "return_mining_candidates";
+const ANTHROPIC_MINING_RESPONSE_TOOL = {
+    name: ANTHROPIC_MINING_RESPONSE_TOOL_NAME,
+    description: [
+        "Return the Cogcoin mining sentence generation result in structured form.",
+        "Use this tool exactly once instead of writing prose, markdown, or code fences.",
+        "Set schemaVersion to 1, copy the requestId exactly, and include only candidates for domainId values from rootDomains.",
+        "Each candidate sentence must be a single natural-language sentence with no surrounding commentary.",
+    ].join(" "),
+    input_schema: {
+        type: "object",
+        properties: {
+            schemaVersion: { type: "integer" },
+            requestId: { type: "string" },
+            candidates: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        domainId: { type: "integer" },
+                        sentence: { type: "string" },
+                    },
+                    required: ["domainId", "sentence"],
+                    additionalProperties: false,
+                },
+            },
+        },
+        required: ["schemaVersion", "requestId", "candidates"],
+        additionalProperties: false,
+    },
+};
+function normalizeProviderCandidateResponse(options) {
     try {
         return normalizeMiningSentenceResponse({
             request: options.request,
-            response,
+            response: options.response,
         }).candidates;
     }
     catch (error) {
         throw new Error(error instanceof Error ? error.message : `${options.providerLabel} returned an invalid response.`);
     }
 }
+function parseProviderJsonResponse(options) {
+    return normalizeProviderCandidateResponse({
+        response: parseStrictJsonValue(stripMarkdownCodeFence(options.raw), `${options.providerLabel} returned invalid JSON.`),
+        request: options.request,
+        providerLabel: options.providerLabel,
+    });
+}
 function createProviderSignal(signal, timeoutMs) {
-    const timeoutSignal = AbortSignal.timeout(timeoutMs);
-    return signal === undefined ? timeoutSignal : AbortSignal.any([signal, timeoutSignal]);
+    const controller = new AbortController();
+    let didTimeout = false;
+    const timer = setTimeout(() => {
+        didTimeout = true;
+        controller.abort(new DOMException("The operation was aborted due to timeout", "TimeoutError"));
+    }, timeoutMs);
+    timer.unref?.();
+    const handleAbort = () => {
+        controller.abort(signal?.reason);
+    };
+    if (signal !== undefined) {
+        if (signal.aborted) {
+            handleAbort();
+        }
+        else {
+            signal.addEventListener("abort", handleAbort, { once: true });
+        }
+    }
+    return {
+        signal: controller.signal,
+        didTimeout() {
+            return didTimeout;
+        },
+        dispose() {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", handleAbort);
+        },
+    };
 }
 async function requestBuiltInSentences(options) {
     const fetchImpl = options.fetchImpl ?? fetch;
-    const providerSignal = createProviderSignal(options.signal, Math.min(MINING_BUILTIN_TIMEOUT_MS, options.request.limits.timeoutMs));
+    const timeoutMs = Math.min(MINING_BUILTIN_TIMEOUT_MS, options.request.limits.timeoutMs);
+    const providerSignal = createProviderSignal(options.signal, timeoutMs);
     try {
         if (options.provider === "openai") {
             const { effectiveModel: model, usingDefaultModel } = resolveBuiltInProviderModel(options.provider, options.modelOverride);
@@ -98,7 +170,7 @@ async function requestBuiltInSentences(options) {
                         },
                     ],
                 }),
-                signal: providerSignal,
+                signal: providerSignal.signal,
             });
             if (response.status === 401 || response.status === 403) {
                 throw new MiningProviderRequestError("auth-error", "The built-in OpenAI mining provider rejected the configured API key.");
@@ -144,8 +216,13 @@ async function requestBuiltInSentences(options) {
                         content: buildUserPrompt(options.request),
                     },
                 ],
+                tools: [ANTHROPIC_MINING_RESPONSE_TOOL],
+                tool_choice: {
+                    type: "tool",
+                    name: ANTHROPIC_MINING_RESPONSE_TOOL_NAME,
+                },
             }),
-            signal: providerSignal,
+            signal: providerSignal.signal,
         });
         if (response.status === 401 || response.status === 403) {
             throw new MiningProviderRequestError("auth-error", "The built-in Anthropic mining provider rejected the configured API key.");
@@ -164,8 +241,8 @@ async function requestBuiltInSentences(options) {
             throw new MiningProviderRequestError("unavailable", `The built-in Anthropic mining provider returned HTTP ${response.status}.`);
         }
         return annotateProviderCandidates({
-            candidates: parseProviderJsonResponse({
-                raw: extractAnthropicText(await response.json()),
+            candidates: normalizeProviderCandidateResponse({
+                response: extractAnthropicResponsePayload(await response.json()),
                 request: options.request,
                 providerLabel: "The built-in Anthropic mining provider",
             }),
@@ -177,11 +254,21 @@ async function requestBuiltInSentences(options) {
         if (error instanceof MiningProviderRequestError) {
             throw error;
         }
-        if (error instanceof Error && error.name === "AbortError") {
-            throw new MiningProviderRequestError("unavailable", "Mining sentence generation was aborted.");
+        if (providerSignal.didTimeout()) {
+            throw createBuiltInProviderTimeoutError({
+                provider: options.provider,
+                timeoutMs,
+            });
+        }
+        if (error instanceof Error
+            && (error.name === "AbortError" || error.name === "TimeoutError")) {
+            throw error;
         }
         throw new MiningProviderRequestError("unavailable", error instanceof Error ? error.message : String(error));
     }
+    finally {
+        providerSignal.dispose();
+    }
 }
 function extractOpenAiText(payload) {
     if (payload !== null && typeof payload === "object") {
@@ -235,6 +322,24 @@ function extractAnthropicText(payload) {
     }
     throw new Error("The built-in Anthropic mining provider returned an empty response.");
 }
+function extractAnthropicResponsePayload(payload) {
+    if (payload !== null && typeof payload === "object") {
+        const content = payload.content;
+        if (Array.isArray(content)) {
+            for (const entry of content) {
+                if (entry === null || typeof entry !== "object") {
+                    continue;
+                }
+                const typedEntry = entry;
+                if (typedEntry.type === "tool_use"
+                    && typedEntry.name === ANTHROPIC_MINING_RESPONSE_TOOL_NAME) {
+                    return typedEntry.input;
+                }
+            }
+        }
+    }
+    return parseStrictJsonValue(stripMarkdownCodeFence(extractAnthropicText(payload)), "The built-in Anthropic mining provider returned invalid JSON.");
+}
 export async function generateMiningSentences(request, options) {
     const config = await loadClientConfig({
         path: options.paths.clientConfigPath,

package/dist/wallet/mining/visualizer.d.ts

@@ -30,6 +30,7 @@ export interface MiningFollowVisualizerState {
     settledBoardEntries: MiningSentenceBoardEntry[];
     provisionalRequiredWords: readonly string[];
     provisionalEntry: MiningProvisionalSentenceEntry;
+    provisionalBroadcastTxid: string | null;
     latestSentence: string | null;
     latestTxid: string | null;
     recentWin: MiningRecentWinSummary | null;

package/dist/wallet/mining/visualizer.js

@@ -133,6 +133,16 @@ function formatRequiredWordsLine(words) {
     }
     return `Required words: ${words.map((word) => word.toUpperCase()).join(", ")}`;
 }
+function formatProvisionalTxLinkLine(entry, txid) {
+    if (entry.domainName === null || entry.sentence === null || txid === null) {
+        return "";
+    }
+    const normalizedTxid = normalizeInlineText(txid);
+    if (normalizedTxid.length === 0) {
+        return "";
+    }
+    return `View at: https://mempool.space/tx/${normalizedTxid}`;
+}
 function formatProvisionalSentenceRow(entry, requiredWords) {
     if (entry.domainName === null || entry.sentence === null) {
         return ["", "", ""];
@@ -151,6 +161,7 @@ export function createEmptyMiningFollowVisualizerState() {
             domainName: null,
             sentence: null,
         },
+        provisionalBroadcastTxid: null,
         latestSentence: null,
         latestTxid: null,
         recentWin: null,
@@ -173,6 +184,7 @@ function cloneMiningFollowVisualizerState(state) {
         provisionalEntry: {
             ...state.provisionalEntry,
         },
+        provisionalBroadcastTxid: state.provisionalBroadcastTxid,
         recentWin: state.recentWin === null
             ? null
             : {
@@ -375,6 +387,7 @@ export class MiningFollowVisualizer {
                         : formatSentenceRow(entry);
                 }).flat(),
                 "----------",
+                formatProvisionalTxLinkLine(uiState.provisionalEntry, uiState.provisionalBroadcastTxid),
                 formatRequiredWordsLine(uiState.provisionalRequiredWords),
                 ...formatProvisionalSentenceRow(uiState.provisionalEntry, uiState.provisionalRequiredWords),
             ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogcoin/client",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Store-backed Cogcoin client with wallet flows, SQLite persistence, and managed Bitcoin Core integration.",
   "license": "MIT",
   "type": "module",