@cogcoin/client 1.1.2 → 1.1.3

package/dist/wallet/mining/sentences.js

@@ -65,18 +65,55 @@ 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 controller = new AbortController();
     let didTimeout = false;
@@ -179,6 +216,11 @@ 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,
         });
@@ -199,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",
             }),
@@ -280,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/package.json

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