@adminforth/completion-adapter-anthropic-messages 1.0.0

package/.woodpecker/buildRelease.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+pnpm run build 2>&1 | tee build.log
+build_status=${PIPESTATUS[0]}
+
+if [ $build_status -ne 0 ]; then
+  echo "Build failed. Exiting with status code $build_status"
+  exit $build_status
+fi

package/.woodpecker/buildSlackNotify.sh

@@ -0,0 +1,44 @@
+#!/bin/sh
+
+set -x
+
+COMMIT_SHORT_SHA=$(echo $CI_COMMIT_SHA | cut -c1-8)
+
+STATUS=${1}
+
+if [ "$STATUS" = "success" ]; then
+  MESSAGE="Did a build without issues on \`$CI_REPO_NAME/$CI_COMMIT_BRANCH\`. Commit: _${CI_COMMIT_MESSAGE}_ (<$CI_COMMIT_URL|$COMMIT_SHORT_SHA>)"
+
+  curl  -s -X POST -H "Content-Type: application/json" -d '{
+    "username": "'"$CI_COMMIT_AUTHOR"'",
+    "icon_url": "'"$CI_COMMIT_AUTHOR_AVATAR"'",
+    "attachments": [
+      {
+          "mrkdwn_in": ["text", "pretext"],
+          "color": "#36a64f",
+          "text": "'"$MESSAGE"'"
+      }
+    ]
+  }' "$DEVELOPERS_SLACK_WEBHOOK"
+  exit 0
+fi
+export BUILD_LOG=$(cat ./build.log)
+
+BUILD_LOG=$(echo $BUILD_LOG | sed 's/"/\\"/g')
+
+MESSAGE="Broke \`$CI_REPO_NAME/$CI_COMMIT_BRANCH\` with commit _${CI_COMMIT_MESSAGE}_ (<$CI_COMMIT_URL|$COMMIT_SHORT_SHA>)"
+CODE_BLOCK="\`\`\`$BUILD_LOG\n\`\`\`"
+
+echo "Sending slack message to developers $MESSAGE"
+curl -sS -X POST -H "Content-Type: application/json" -d '{
+  "username": "'"$CI_COMMIT_AUTHOR"'",
+  "icon_url": "'"$CI_COMMIT_AUTHOR_AVATAR"'",
+  "attachments": [
+    {
+        "mrkdwn_in": ["text", "pretext"],
+        "color": "#8A1C12",
+        "text": "'"$CODE_BLOCK"'",
+        "pretext": "'"$MESSAGE"'"
+    }
+  ]
+}' "$DEVELOPERS_SLACK_WEBHOOK" 2>&1

package/.woodpecker/release.yml

@@ -0,0 +1,56 @@
+clone:
+  git:
+    image: woodpeckerci/plugin-git
+    settings:
+      partial: false
+      depth: 5
+
+steps:
+  init-secrets:
+    when:
+      - event: push
+    image: infisical/cli
+    environment:
+      INFISICAL_TOKEN:
+        from_secret: VAULT_TOKEN
+    commands:
+      - infisical export --domain https://vault.devforth.io/api --format=dotenv-export --env="prod" > /woodpecker/deploy.vault.env
+
+  build:
+    image: devforth/node20-pnpm:latest
+    when:
+      - event: push
+    commands:
+      - . /woodpecker/deploy.vault.env
+      - pnpm install
+      - /bin/bash ./.woodpecker/buildRelease.sh
+      - npm audit signatures
+
+  release:
+    image: devforth/node20-pnpm:latest
+    when:
+      - event:
+          - push
+        branch:
+          - main
+    commands:
+      - . /woodpecker/deploy.vault.env
+      - pnpm exec semantic-release
+
+  slack-on-failure:
+    image: curlimages/curl
+    when:
+      - event: push
+        status: [failure]
+    commands:
+      - . /woodpecker/deploy.vault.env
+      - /bin/sh ./.woodpecker/buildSlackNotify.sh failure
+
+  slack-on-success:
+    image: curlimages/curl
+    when:
+      - event: push
+        status: [success]
+    commands:
+      - . /woodpecker/deploy.vault.env
+      - /bin/sh ./.woodpecker/buildSlackNotify.sh success

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Devforth.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# @adminforth/completion-adapter-anthropic-messages
+
+<img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License: MIT" /> <img src="https://woodpecker.devforth.io/api/badges/3848/status.svg" alt="Build Status" /> <a href="https://www.npmjs.com/package/@adminforth/completion-adapter-anthropic-messages"><img src="https://img.shields.io/npm/dm/@adminforth/completion-adapter-anthropic-messages" alt="npm downloads" /></a> <a href="https://www.npmjs.com/package/@adminforth/completion-adapter-anthropic-messages"><img src="https://img.shields.io/npm/v/@adminforth/completion-adapter-anthropic-messages" alt="npm version" /></a>
+
+[![Ask AI](https://tluma.ai/badge)](https://tluma.ai/ask-ai/devforth/adminforth)
+
+AdminForth completion adapter for the Anthropic Messages API.
+
+## Installation
+
+```bash
+pnpm i @adminforth/completion-adapter-anthropic-messages
+```
+
+## Usage
+
+```ts
+import CompletionAdapterAntropicMessages from "@adminforth/completion-adapter-anthropic-messages";
+
+const adapter = new CompletionAdapterAntropicMessages({
+	anthropicApiKey: process.env.ANTHROPIC_API_KEY as string,
+	model: "claude-sonnet-4-5-20250929",
+	extraRequestBodyParameters: {
+		temperature: 0.7,
+	},
+});
+```
+
+The adapter supports:
+
+- regular text completion
+- JSON Schema structured output via the Messages parse helper
+- tool calls
+- streaming output chunks
+- extended thinking when the token budget allows it
+
+## Related links
+
+- [AdminForth website](https://adminforth.dev)
+- [npm package](https://www.npmjs.com/package/@adminforth/completion-adapter-anthropic-messages)
+- [All completion adapters](https://adminforth.dev/docs/tutorial/Adapters/ai-completion-adapters/)
+- [All AdminForth adapters](https://adminforth.dev/docs/tutorial/ListOfAdapters/)
+- [Built by DevForth](https://devforth.io)

package/build.log

@@ -0,0 +1,4 @@
+
+> @adminforth/completion-adapter-anthropic-messages@2.0.0 build /woodpecker/src/github.com/devforth/adminforth-completion-adapter-anthropic-messages
+> tsc
+

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+import type { AdapterOptions } from "./types.js";
+import type { CompletionAdapter, CompletionStreamEvent, CompletionTool } from "adminforth";
+import { ChatAnthropic } from "@langchain/anthropic";
+export type { AdapterOptions } from "./types.js";
+type StreamChunkCallback = (chunk: string, event?: CompletionStreamEvent) => void | Promise<void>;
+type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+type AgentModelPurpose = "primary" | "summary";
+type CompletionRequestInput = {
+    content: string;
+    maxTokens?: number;
+    outputSchema?: any;
+    reasoningEffort?: ReasoningEffort;
+    tools?: CompletionTool[];
+    onChunk?: StreamChunkCallback;
+};
+type LangChainMessageLike = {
+    content?: unknown;
+    text?: string;
+    type?: string;
+    getType?: () => string;
+    _getType?: () => string;
+};
+type LangChainModelCallRequest = {
+    systemMessage: LangChainMessageLike & {
+        concat: (content: string) => LangChainMessageLike;
+    };
+    messages: LangChainMessageLike[];
+};
+export default class CompletionAdapterAnthropicMessages implements CompletionAdapter {
+    options: AdapterOptions;
+    private client?;
+    constructor(options: AdapterOptions);
+    private getClient;
+    validate(): void;
+    measureTokensCount(content: string): Promise<number>;
+    getLangChainAgentSpec(params: {
+        maxTokens: number;
+        purpose: AgentModelPurpose;
+    }): {
+        model: ChatAnthropic;
+        middleware: {
+            name: string;
+            wrapModelCall(request: LangChainModelCallRequest, handler: (request: LangChainModelCallRequest) => unknown): Promise<unknown>;
+        }[];
+    };
+    complete: (requestOrContent: CompletionRequestInput | string, maxTokens?: number, outputSchema?: any, reasoningEffort?: ReasoningEffort, toolsOrOnChunk?: CompletionTool[] | StreamChunkCallback, onChunk?: StreamChunkCallback) => Promise<{
+        content?: string;
+        finishReason?: string;
+        error?: string;
+    }>;
+}

package/dist/index.js

@@ -0,0 +1,410 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { ChatAnthropic } from "@langchain/anthropic";
+import Anthropic from "@anthropic-ai/sdk";
+import { jsonSchemaOutputFormat } from "@anthropic-ai/sdk/helpers/json-schema";
+function getApiKey(options) {
+    return options.anthropicApiKey || options.antropicApiKey;
+}
+function getErrorMessage(error) {
+    if (error instanceof Error && error.message)
+        return error.message;
+    return String(error || "Unknown error");
+}
+function normalizeOutputSchema(outputSchema) {
+    if (!outputSchema || typeof outputSchema !== "object")
+        return undefined;
+    const candidate = outputSchema.schema || outputSchema.json_schema || outputSchema;
+    if (!candidate || typeof candidate !== "object") {
+        return undefined;
+    }
+    if (candidate.type !== "object") {
+        return undefined;
+    }
+    return candidate;
+}
+function extractOutputText(data) {
+    var _a;
+    let text = "";
+    for (const block of (_a = data.content) !== null && _a !== void 0 ? _a : []) {
+        if ((block === null || block === void 0 ? void 0 : block.type) === "text" && typeof block.text === "string") {
+            text += block.text;
+        }
+    }
+    return text;
+}
+function extractReasoning(data) {
+    var _a;
+    let reasoning = "";
+    for (const block of (_a = data.content) !== null && _a !== void 0 ? _a : []) {
+        if ((block === null || block === void 0 ? void 0 : block.type) === "thinking" && typeof block.thinking === "string") {
+            reasoning += block.thinking;
+        }
+    }
+    return reasoning || undefined;
+}
+function extractToolUse(data) {
+    var _a;
+    for (const block of (_a = data.content) !== null && _a !== void 0 ? _a : []) {
+        if ((block === null || block === void 0 ? void 0 : block.type) === "tool_use") {
+            return block;
+        }
+    }
+    return undefined;
+}
+function stringifyToolResult(toolResult) {
+    if (typeof toolResult === "string")
+        return toolResult;
+    if (typeof toolResult === "undefined")
+        return "";
+    return JSON.stringify(toolResult);
+}
+function executeToolCall(toolCall, tools) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tool = tools === null || tools === void 0 ? void 0 : tools.find((candidate) => candidate.name === toolCall.name);
+        if (!tool) {
+            throw new Error(`Tool "${toolCall.name}" not found`);
+        }
+        const toolResult = yield tool.handler(toolCall.input || {});
+        return stringifyToolResult(toolResult);
+    });
+}
+function mapTools(tools) {
+    if (!(tools === null || tools === void 0 ? void 0 : tools.length))
+        return undefined;
+    return tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.input_schema,
+    }));
+}
+function mapReasoningToThinking(reasoningEffort, maxTokens) {
+    if (reasoningEffort === "none")
+        return undefined;
+    const availableBudget = maxTokens - 128;
+    if (availableBudget < 1024)
+        return undefined;
+    const ratioByEffort = {
+        minimal: 0.25,
+        low: 0.35,
+        medium: 0.5,
+        high: 0.7,
+        xhigh: 0.85,
+    };
+    const targetBudget = Math.floor(maxTokens * ratioByEffort[reasoningEffort]);
+    return {
+        type: "enabled",
+        budget_tokens: Math.max(1024, Math.min(availableBudget, targetBudget)),
+    };
+}
+function getAgentReasoningEffort(purpose) {
+    return purpose === "summary" ? "minimal" : "low";
+}
+function isSystemMessage(message) {
+    var _a, _b;
+    return (((_a = message._getType) === null || _a === void 0 ? void 0 : _a.call(message)) === "system" ||
+        ((_b = message.getType) === null || _b === void 0 ? void 0 : _b.call(message)) === "system" ||
+        message.type === "system");
+}
+function contentToText(content, text) {
+    if (text)
+        return text;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((block) => {
+        var _a;
+        if (typeof block === "string")
+            return block;
+        if (block && typeof block === "object" && "text" in block) {
+            return String((_a = block.text) !== null && _a !== void 0 ? _a : "");
+        }
+        return "";
+    })
+        .join("");
+}
+function normalizeAnthropicSystemMessages(request) {
+    const existingSystemText = contentToText(request.systemMessage.content, request.systemMessage.text);
+    const extraSystemText = request.messages
+        .filter(isSystemMessage)
+        .map((message) => contentToText(message.content, message.text))
+        .filter((text) => text && text !== existingSystemText)
+        .join("\n\n");
+    if (!extraSystemText) {
+        return Object.assign(Object.assign({}, request), { messages: request.messages.filter((message) => !isSystemMessage(message)) });
+    }
+    const systemMessage = request.systemMessage.concat(extraSystemText);
+    return Object.assign(Object.assign({}, request), { systemMessage, messages: request.messages.filter((message) => !isSystemMessage(message)) });
+}
+function createAnthropicSystemMessageMiddleware() {
+    return {
+        name: "AnthropicSystemMessageMiddleware",
+        wrapModelCall(request, handler) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return handler(normalizeAnthropicSystemMessages(request));
+            });
+        },
+    };
+}
+export default class CompletionAdapterAnthropicMessages {
+    constructor(options) {
+        this.complete = (requestOrContent_1, ...args_1) => __awaiter(this, [requestOrContent_1, ...args_1], void 0, function* (requestOrContent, maxTokens = 50, outputSchema, reasoningEffort = "low", toolsOrOnChunk, onChunk) {
+            var _a, e_1, _b, _c;
+            var _d, _e;
+            const request = typeof requestOrContent === "string"
+                ? {
+                    content: requestOrContent,
+                    maxTokens,
+                    outputSchema,
+                    reasoningEffort,
+                    tools: Array.isArray(toolsOrOnChunk) ? toolsOrOnChunk : undefined,
+                    onChunk: typeof toolsOrOnChunk === "function"
+                        ? toolsOrOnChunk
+                        : onChunk,
+                }
+                : requestOrContent;
+            const { content, maxTokens: requestMaxTokens = 50, outputSchema: requestOutputSchema, reasoningEffort: requestReasoningEffort = "low", tools, onChunk: streamChunkCallback, } = request;
+            const model = this.options.model || "claude-sonnet-4-5-20250929";
+            const isStreaming = typeof streamChunkCallback === "function";
+            const normalizedSchema = normalizeOutputSchema(requestOutputSchema);
+            const extra = Object.assign({}, (this.options.extraRequestBodyParameters || {}));
+            const thinking = extra.thinking || mapReasoningToThinking(requestReasoningEffort, requestMaxTokens);
+            const body = Object.assign(Object.assign({ model, max_tokens: requestMaxTokens, messages: [{ role: "user", content }], tools: mapTools(tools) }, (thinking ? { thinking } : {})), extra);
+            try {
+                if (requestOutputSchema && !normalizedSchema) {
+                    return {
+                        error: "Anthropic structured output requires a top-level JSON schema object with type: \"object\"",
+                    };
+                }
+                if (normalizedSchema) {
+                    const parsedMessage = (yield this.getClient().messages.parse(Object.assign(Object.assign({}, body), { output_config: {
+                            format: jsonSchemaOutputFormat(normalizedSchema),
+                        } })));
+                    const parsedOutput = typeof parsedMessage.parsed_output === "undefined"
+                        ? extractOutputText(parsedMessage)
+                        : JSON.stringify(parsedMessage.parsed_output);
+                    const parsedReasoning = extractReasoning(parsedMessage);
+                    if (parsedReasoning && isStreaming) {
+                        yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(parsedReasoning, {
+                            type: "reasoning",
+                            delta: parsedReasoning,
+                            text: parsedReasoning,
+                        }));
+                    }
+                    if (parsedOutput && isStreaming) {
+                        yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(parsedOutput, {
+                            type: "output",
+                            delta: parsedOutput,
+                            text: parsedOutput,
+                        }));
+                    }
+                    const toolUse = extractToolUse(parsedMessage);
+                    if (toolUse) {
+                        try {
+                            const toolResult = yield executeToolCall(toolUse, tools);
+                            if (toolResult && isStreaming) {
+                                yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(toolResult, {
+                                    type: "output",
+                                    delta: toolResult,
+                                    text: toolResult,
+                                }));
+                            }
+                            return {
+                                content: toolResult,
+                                finishReason: "tool_call",
+                            };
+                        }
+                        catch (error) {
+                            return {
+                                error: getErrorMessage(error),
+                                finishReason: "tool_call",
+                            };
+                        }
+                    }
+                    return {
+                        content: parsedOutput || undefined,
+                        finishReason: parsedMessage.stop_reason || undefined,
+                    };
+                }
+                if (!isStreaming) {
+                    const message = (yield this.getClient().messages.create(body));
+                    const toolUse = extractToolUse(message);
+                    if (toolUse) {
+                        try {
+                            const toolResult = yield executeToolCall(toolUse, tools);
+                            return {
+                                content: toolResult,
+                                finishReason: "tool_call",
+                            };
+                        }
+                        catch (error) {
+                            return {
+                                error: getErrorMessage(error),
+                                finishReason: "tool_call",
+                            };
+                        }
+                    }
+                    return {
+                        content: extractOutputText(message) || undefined,
+                        finishReason: message.stop_reason || undefined,
+                    };
+                }
+                const stream = this.getClient().messages.stream(body);
+                let fullContent = "";
+                let fullReasoning = "";
+                try {
+                    for (var _f = true, _g = __asyncValues(stream), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
+                        _c = _h.value;
+                        _f = false;
+                        const event = _c;
+                        if ((event === null || event === void 0 ? void 0 : event.type) !== "content_block_delta")
+                            continue;
+                        if (((_d = event.delta) === null || _d === void 0 ? void 0 : _d.type) === "text_delta" && typeof event.delta.text === "string") {
+                            fullContent += event.delta.text;
+                            yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(event.delta.text, {
+                                type: "output",
+                                delta: event.delta.text,
+                                text: fullContent,
+                            }));
+                            continue;
+                        }
+                        if (((_e = event.delta) === null || _e === void 0 ? void 0 : _e.type) === "thinking_delta" &&
+                            typeof event.delta.thinking === "string") {
+                            fullReasoning += event.delta.thinking;
+                            yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(event.delta.thinking, {
+                                type: "reasoning",
+                                delta: event.delta.thinking,
+                                text: fullReasoning,
+                            }));
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                const message = (yield stream.finalMessage());
+                const finalContent = extractOutputText(message);
+                const finalReasoning = extractReasoning(message) || "";
+                if (finalReasoning && finalReasoning !== fullReasoning) {
+                    const delta = finalReasoning.startsWith(fullReasoning)
+                        ? finalReasoning.slice(fullReasoning.length)
+                        : finalReasoning;
+                    if (delta) {
+                        fullReasoning = finalReasoning;
+                        yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(delta, {
+                            type: "reasoning",
+                            delta,
+                            text: finalReasoning,
+                        }));
+                    }
+                }
+                if (finalContent && finalContent !== fullContent) {
+                    const delta = finalContent.startsWith(fullContent)
+                        ? finalContent.slice(fullContent.length)
+                        : finalContent;
+                    if (delta) {
+                        fullContent = finalContent;
+                        yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(delta, {
+                            type: "output",
+                            delta,
+                            text: finalContent,
+                        }));
+                    }
+                }
+                const toolUse = extractToolUse(message);
+                if (toolUse) {
+                    try {
+                        const toolResult = yield executeToolCall(toolUse, tools);
+                        if (toolResult) {
+                            const delta = toolResult.startsWith(fullContent)
+                                ? toolResult.slice(fullContent.length)
+                                : toolResult;
+                            if (delta) {
+                                yield (streamChunkCallback === null || streamChunkCallback === void 0 ? void 0 : streamChunkCallback(delta, {
+                                    type: "output",
+                                    delta,
+                                    text: toolResult,
+                                }));
+                            }
+                        }
+                        return {
+                            content: toolResult,
+                            finishReason: "tool_call",
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            error: getErrorMessage(error),
+                            content: fullContent || undefined,
+                            finishReason: "tool_call",
+                        };
+                    }
+                }
+                return {
+                    content: fullContent || undefined,
+                    finishReason: message.stop_reason || undefined,
+                };
+            }
+            catch (error) {
+                return {
+                    error: getErrorMessage(error),
+                };
+            }
+        });
+        this.options = options;
+    }
+    getClient() {
+        if (!this.client) {
+            const apiKey = getApiKey(this.options);
+            if (!apiKey) {
+                throw new Error("anthropicApiKey is required");
+            }
+            this.client = new Anthropic({ apiKey });
+        }
+        return this.client;
+    }
+    validate() {
+        if (!getApiKey(this.options)) {
+            throw new Error("anthropicApiKey is required");
+        }
+    }
+    measureTokensCount(content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getClient().messages.countTokens({
+                model: this.options.model || "claude-sonnet-4-5-20250929",
+                messages: [{ role: "user", content }],
+            });
+            return response.input_tokens;
+        });
+    }
+    getLangChainAgentSpec(params) {
+        const extraRequestBodyParameters = Object.assign({}, (this.options.extraRequestBodyParameters || {}));
+        const thinking = extraRequestBodyParameters.thinking ||
+            mapReasoningToThinking(getAgentReasoningEffort(params.purpose), params.maxTokens);
+        delete extraRequestBodyParameters.thinking;
+        return {
+            model: new ChatAnthropic(Object.assign(Object.assign({ model: this.options.model || "claude-sonnet-4-5-20250929", apiKey: getApiKey(this.options), maxTokens: params.maxTokens }, (thinking ? { thinking } : {})), { invocationKwargs: extraRequestBodyParameters })),
+            middleware: [createAnthropicSystemMessageMiddleware()],
+        };
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,20 @@
+export interface AdapterOptions {
+    /**
+     * Anthropic API key. Go to https://console.anthropic.com/settings/keys and create a new key.
+     * Set anthropicApiKey: process.env.ANTHROPIC_API_KEY to access it.
+     */
+    anthropicApiKey?: string;
+    /**
+     * Deprecated alias kept for compatibility with the package name spelling.
+     */
+    antropicApiKey?: string;
+    /**
+     * Model name. See https://docs.anthropic.com/en/docs/about-claude/models for available models.
+     * Default is `claude-sonnet-4-5-20250929`.
+     */
+    model?: string;
+    /**
+     * Additional request body parameters to include in the API request.
+     */
+    extraRequestBodyParameters?: Record<string, unknown>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/index.ts

@@ -0,0 +1,564 @@
+import type { AdapterOptions } from "./types.js";
+import type {
+  CompletionAdapter,
+  CompletionStreamEvent,
+  CompletionTool,
+} from "adminforth";
+import { ChatAnthropic } from "@langchain/anthropic";
+import Anthropic from "@anthropic-ai/sdk";
+import { jsonSchemaOutputFormat } from "@anthropic-ai/sdk/helpers/json-schema";
+
+export type { AdapterOptions } from "./types.js";
+
+type StreamChunkCallback = (
+  chunk: string,
+  event?: CompletionStreamEvent,
+) => void | Promise<void>;
+
+type ReasoningEffort =
+  | "none"
+  | "minimal"
+  | "low"
+  | "medium"
+  | "high"
+  | "xhigh";
+
+type AgentModelPurpose = "primary" | "summary";
+
+type CompletionRequestInput = {
+  content: string;
+  maxTokens?: number;
+  outputSchema?: any;
+  reasoningEffort?: ReasoningEffort;
+  tools?: CompletionTool[];
+  onChunk?: StreamChunkCallback;
+};
+
+type JsonSchemaObject = {
+  type: "object";
+  [key: string]: unknown;
+};
+
+type AnthropicMessageLike = {
+  content?: Array<any>;
+  stop_reason?: string | null;
+  parsed_output?: unknown;
+};
+
+type AnthropicToolUseBlock = {
+  type: "tool_use";
+  id: string;
+  name: string;
+  input: unknown;
+};
+
+type LangChainMessageLike = {
+  content?: unknown;
+  text?: string;
+  type?: string;
+  getType?: () => string;
+  _getType?: () => string;
+};
+
+type LangChainModelCallRequest = {
+  systemMessage: LangChainMessageLike & {
+    concat: (content: string) => LangChainMessageLike;
+  };
+  messages: LangChainMessageLike[];
+};
+
+function getApiKey(options: AdapterOptions): string | undefined {
+  return options.anthropicApiKey || options.antropicApiKey;
+}
+
+function getErrorMessage(error: unknown): string {
+  if (error instanceof Error && error.message) return error.message;
+  return String(error || "Unknown error");
+}
+
+function normalizeOutputSchema(outputSchema: any): JsonSchemaObject | undefined {
+  if (!outputSchema || typeof outputSchema !== "object") return undefined;
+  const candidate = outputSchema.schema || outputSchema.json_schema || outputSchema;
+  if (!candidate || typeof candidate !== "object") {
+    return undefined;
+  }
+  if (candidate.type !== "object") {
+    return undefined;
+  }
+  return candidate as JsonSchemaObject;
+}
+
+function extractOutputText(data: AnthropicMessageLike): string {
+  let text = "";
+
+  for (const block of data.content ?? []) {
+    if (block?.type === "text" && typeof block.text === "string") {
+      text += block.text;
+    }
+  }
+
+  return text;
+}
+
+function extractReasoning(data: AnthropicMessageLike): string | undefined {
+  let reasoning = "";
+
+  for (const block of data.content ?? []) {
+    if (block?.type === "thinking" && typeof block.thinking === "string") {
+      reasoning += block.thinking;
+    }
+  }
+
+  return reasoning || undefined;
+}
+
+function extractToolUse(data: AnthropicMessageLike): AnthropicToolUseBlock | undefined {
+  for (const block of data.content ?? []) {
+    if (block?.type === "tool_use") {
+      return block as AnthropicToolUseBlock;
+    }
+  }
+
+  return undefined;
+}
+
+function stringifyToolResult(toolResult: unknown): string {
+  if (typeof toolResult === "string") return toolResult;
+  if (typeof toolResult === "undefined") return "";
+  return JSON.stringify(toolResult);
+}
+
+async function executeToolCall(
+  toolCall: AnthropicToolUseBlock,
+  tools?: CompletionTool[],
+): Promise<string> {
+  const tool = tools?.find((candidate) => candidate.name === toolCall.name);
+  if (!tool) {
+    throw new Error(`Tool "${toolCall.name}" not found`);
+  }
+
+  const toolResult = await tool.handler(toolCall.input || {});
+  return stringifyToolResult(toolResult);
+}
+
+function mapTools(tools?: CompletionTool[]) {
+  if (!tools?.length) return undefined;
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.input_schema,
+  }));
+}
+
+function mapReasoningToThinking(
+  reasoningEffort: ReasoningEffort,
+  maxTokens: number,
+): { type: "enabled"; budget_tokens: number } | undefined {
+  if (reasoningEffort === "none") return undefined;
+
+  const availableBudget = maxTokens - 128;
+  if (availableBudget < 1024) return undefined;
+
+  const ratioByEffort: Record<Exclude<ReasoningEffort, "none">, number> = {
+    minimal: 0.25,
+    low: 0.35,
+    medium: 0.5,
+    high: 0.7,
+    xhigh: 0.85,
+  };
+  const targetBudget = Math.floor(maxTokens * ratioByEffort[reasoningEffort]);
+
+  return {
+    type: "enabled",
+    budget_tokens: Math.max(1024, Math.min(availableBudget, targetBudget)),
+  };
+}
+
+function getAgentReasoningEffort(
+  purpose: AgentModelPurpose,
+): ReasoningEffort {
+  return purpose === "summary" ? "minimal" : "low";
+}
+
+function isSystemMessage(message: LangChainMessageLike): boolean {
+  return (
+    message._getType?.() === "system" ||
+    message.getType?.() === "system" ||
+    message.type === "system"
+  );
+}
+
+function contentToText(content: unknown, text?: string): string {
+  if (text) return text;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+
+  return content
+    .map((block) => {
+      if (typeof block === "string") return block;
+      if (block && typeof block === "object" && "text" in block) {
+        return String(block.text ?? "");
+      }
+      return "";
+    })
+    .join("");
+}
+
+function normalizeAnthropicSystemMessages<T extends LangChainModelCallRequest>(
+  request: T,
+): T {
+  const existingSystemText = contentToText(
+    request.systemMessage.content,
+    request.systemMessage.text,
+  );
+  const extraSystemText = request.messages
+    .filter(isSystemMessage)
+    .map((message) => contentToText(message.content, message.text))
+    .filter((text) => text && text !== existingSystemText)
+    .join("\n\n");
+
+  if (!extraSystemText) {
+    return {
+      ...request,
+      messages: request.messages.filter((message) => !isSystemMessage(message)),
+    };
+  }
+
+  const systemMessage = request.systemMessage.concat(extraSystemText);
+
+  return {
+    ...request,
+    systemMessage,
+    messages: request.messages.filter((message) => !isSystemMessage(message)),
+  };
+}
+
+function createAnthropicSystemMessageMiddleware() {
+  return {
+    name: "AnthropicSystemMessageMiddleware",
+    async wrapModelCall(
+      request: LangChainModelCallRequest,
+      handler: (request: LangChainModelCallRequest) => unknown,
+    ) {
+      return handler(normalizeAnthropicSystemMessages(request));
+    },
+  };
+}
+
+export default class CompletionAdapterAnthropicMessages
+  implements CompletionAdapter
+{
+  options: AdapterOptions;
+  private client?: Anthropic;
+
+  constructor(options: AdapterOptions) {
+    this.options = options;
+  }
+
+  private getClient(): Anthropic {
+    if (!this.client) {
+      const apiKey = getApiKey(this.options);
+      if (!apiKey) {
+        throw new Error("anthropicApiKey is required");
+      }
+      this.client = new Anthropic({ apiKey });
+    }
+
+    return this.client;
+  }
+
+  validate() {
+    if (!getApiKey(this.options)) {
+      throw new Error("anthropicApiKey is required");
+    }
+  }
+
+  async measureTokensCount(content: string): Promise<number> {
+    const response = await this.getClient().messages.countTokens({
+      model: this.options.model || "claude-sonnet-4-5-20250929",
+      messages: [{ role: "user", content }],
+    });
+
+    return response.input_tokens;
+  }
+
+  getLangChainAgentSpec(params: {
+    maxTokens: number;
+    purpose: AgentModelPurpose;
+  }) {
+    const extraRequestBodyParameters = {
+      ...(this.options.extraRequestBodyParameters || {}),
+    } as Record<string, unknown> & {
+      thinking?: { type: "enabled"; budget_tokens: number };
+    };
+    const thinking =
+      extraRequestBodyParameters.thinking ||
+      mapReasoningToThinking(
+        getAgentReasoningEffort(params.purpose),
+        params.maxTokens,
+      );
+
+    delete extraRequestBodyParameters.thinking;
+
+    return {
+      model: new ChatAnthropic({
+        model: this.options.model || "claude-sonnet-4-5-20250929",
+        apiKey: getApiKey(this.options),
+        maxTokens: params.maxTokens,
+        ...(thinking ? { thinking } : {}),
+        invocationKwargs: extraRequestBodyParameters,
+      } as any),
+      middleware: [createAnthropicSystemMessageMiddleware()],
+    };
+  }
+
+  complete = async (
+    requestOrContent: CompletionRequestInput | string,
+    maxTokens = 50,
+    outputSchema?: any,
+    reasoningEffort: ReasoningEffort = "low",
+    toolsOrOnChunk?: CompletionTool[] | StreamChunkCallback,
+    onChunk?: StreamChunkCallback,
+  ): Promise<{
+    content?: string;
+    finishReason?: string;
+    error?: string;
+  }> => {
+    const request =
+      typeof requestOrContent === "string"
+        ? {
+            content: requestOrContent,
+            maxTokens,
+            outputSchema,
+            reasoningEffort,
+            tools: Array.isArray(toolsOrOnChunk) ? toolsOrOnChunk : undefined,
+            onChunk:
+              typeof toolsOrOnChunk === "function"
+                ? toolsOrOnChunk
+                : onChunk,
+          }
+        : requestOrContent;
+    const {
+      content,
+      maxTokens: requestMaxTokens = 50,
+      outputSchema: requestOutputSchema,
+      reasoningEffort: requestReasoningEffort = "low",
+      tools,
+      onChunk: streamChunkCallback,
+    } = request;
+    const model = this.options.model || "claude-sonnet-4-5-20250929";
+    const isStreaming = typeof streamChunkCallback === "function";
+    const normalizedSchema = normalizeOutputSchema(requestOutputSchema);
+    const extra = {
+      ...(this.options.extraRequestBodyParameters || {}),
+    } as Record<string, unknown>;
+    const thinking = extra.thinking || mapReasoningToThinking(
+      requestReasoningEffort,
+      requestMaxTokens,
+    );
+
+    const body = {
+      model,
+      max_tokens: requestMaxTokens,
+      messages: [{ role: "user", content }],
+      tools: mapTools(tools),
+      ...(thinking ? { thinking } : {}),
+      ...extra,
+    } as Record<string, unknown>;
+
+    try {
+      if (requestOutputSchema && !normalizedSchema) {
+        return {
+          error:
+            "Anthropic structured output requires a top-level JSON schema object with type: \"object\"",
+        };
+      }
+
+      if (normalizedSchema) {
+        const parsedMessage = (await this.getClient().messages.parse({
+          ...(body as any),
+          output_config: {
+            format: jsonSchemaOutputFormat(normalizedSchema),
+          },
+        } as any)) as AnthropicMessageLike;
+        const parsedOutput =
+          typeof parsedMessage.parsed_output === "undefined"
+            ? extractOutputText(parsedMessage)
+            : JSON.stringify(parsedMessage.parsed_output);
+        const parsedReasoning = extractReasoning(parsedMessage);
+
+        if (parsedReasoning && isStreaming) {
+          await streamChunkCallback?.(parsedReasoning, {
+            type: "reasoning",
+            delta: parsedReasoning,
+            text: parsedReasoning,
+          });
+        }
+        if (parsedOutput && isStreaming) {
+          await streamChunkCallback?.(parsedOutput, {
+            type: "output",
+            delta: parsedOutput,
+            text: parsedOutput,
+          });
+        }
+
+        const toolUse = extractToolUse(parsedMessage);
+        if (toolUse) {
+          try {
+            const toolResult = await executeToolCall(toolUse, tools);
+            if (toolResult && isStreaming) {
+              await streamChunkCallback?.(toolResult, {
+                type: "output",
+                delta: toolResult,
+                text: toolResult,
+              });
+            }
+
+            return {
+              content: toolResult,
+              finishReason: "tool_call",
+            };
+          } catch (error) {
+            return {
+              error: getErrorMessage(error),
+              finishReason: "tool_call",
+            };
+          }
+        }
+
+        return {
+          content: parsedOutput || undefined,
+          finishReason: parsedMessage.stop_reason || undefined,
+        };
+      }
+
+      if (!isStreaming) {
+        const message = (await this.getClient().messages.create(
+          body as any,
+        )) as AnthropicMessageLike;
+
+        const toolUse = extractToolUse(message);
+        if (toolUse) {
+          try {
+            const toolResult = await executeToolCall(toolUse, tools);
+            return {
+              content: toolResult,
+              finishReason: "tool_call",
+            };
+          } catch (error) {
+            return {
+              error: getErrorMessage(error),
+              finishReason: "tool_call",
+            };
+          }
+        }
+
+        return {
+          content: extractOutputText(message) || undefined,
+          finishReason: message.stop_reason || undefined,
+        };
+      }
+
+      const stream = this.getClient().messages.stream(body as any);
+      let fullContent = "";
+      let fullReasoning = "";
+
+      for await (const event of stream as any) {
+        if (event?.type !== "content_block_delta") continue;
+
+        if (event.delta?.type === "text_delta" && typeof event.delta.text === "string") {
+          fullContent += event.delta.text;
+          await streamChunkCallback?.(event.delta.text, {
+            type: "output",
+            delta: event.delta.text,
+            text: fullContent,
+          });
+          continue;
+        }
+
+        if (
+          event.delta?.type === "thinking_delta" &&
+          typeof event.delta.thinking === "string"
+        ) {
+          fullReasoning += event.delta.thinking;
+          await streamChunkCallback?.(event.delta.thinking, {
+            type: "reasoning",
+            delta: event.delta.thinking,
+            text: fullReasoning,
+          });
+        }
+      }
+
+      const message = (await stream.finalMessage()) as AnthropicMessageLike;
+      const finalContent = extractOutputText(message);
+      const finalReasoning = extractReasoning(message) || "";
+
+      if (finalReasoning && finalReasoning !== fullReasoning) {
+        const delta = finalReasoning.startsWith(fullReasoning)
+          ? finalReasoning.slice(fullReasoning.length)
+          : finalReasoning;
+        if (delta) {
+          fullReasoning = finalReasoning;
+          await streamChunkCallback?.(delta, {
+            type: "reasoning",
+            delta,
+            text: finalReasoning,
+          });
+        }
+      }
+
+      if (finalContent && finalContent !== fullContent) {
+        const delta = finalContent.startsWith(fullContent)
+          ? finalContent.slice(fullContent.length)
+          : finalContent;
+        if (delta) {
+          fullContent = finalContent;
+          await streamChunkCallback?.(delta, {
+            type: "output",
+            delta,
+            text: finalContent,
+          });
+        }
+      }
+
+      const toolUse = extractToolUse(message);
+      if (toolUse) {
+        try {
+          const toolResult = await executeToolCall(toolUse, tools);
+          if (toolResult) {
+            const delta = toolResult.startsWith(fullContent)
+              ? toolResult.slice(fullContent.length)
+              : toolResult;
+            if (delta) {
+              await streamChunkCallback?.(delta, {
+                type: "output",
+                delta,
+                text: toolResult,
+              });
+            }
+          }
+
+          return {
+            content: toolResult,
+            finishReason: "tool_call",
+          };
+        } catch (error) {
+          return {
+            error: getErrorMessage(error),
+            content: fullContent || undefined,
+            finishReason: "tool_call",
+          };
+        }
+      }
+
+      return {
+        content: fullContent || undefined,
+        finishReason: message.stop_reason || undefined,
+      };
+    } catch (error) {
+      return {
+        error: getErrorMessage(error),
+      };
+    }
+  };
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@adminforth/completion-adapter-anthropic-messages",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "homepage": "https://adminforth.dev/docs/tutorial/Adapters/completion-adapter-anthropic-messages/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/devforth/adminforth-completion-adapter-anthropic-messages.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "adminforth",
+    "anthropic",
+    "claude",
+    "messages api",
+    "ai completion",
+    "completion adapter"
+  ],
+  "author": "DevForth (https://devforth.io)",
+  "license": "MIT",
+  "description": "AdminForth completion adapter for the Anthropic Messages API.",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.90.0",
+    "@langchain/anthropic": "1.3.26"
+  },
+  "peerDependencies": {
+    "adminforth": "^2.24.0"
+  },
+  "devDependencies": {
+    "semantic-release": "^24.2.1",
+    "semantic-release-slack-bot": "^4.0.2",
+    "typescript": "^5.9.3"
+  },
+  "release": {
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      [
+        "semantic-release-slack-bot",
+        {
+          "packageName": "@adminforth/completion-adapter-anthropic-messages",
+          "notifyOnSuccess": true,
+          "notifyOnFail": true,
+          "slackIcon": ":package:",
+          "markdownReleaseNotes": true
+        }
+      ]
+    ],
+    "branches": [
+      "main",
+      {
+        "name": "next",
+        "prerelease": true
+      }
+    ]
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "node16",
+    "outDir": "./dist",
+    "declaration": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": false,
+    "skipLibCheck": true,
+    "strictNullChecks": true
+  },
+  "exclude": ["node_modules", "dist", "custom"]
+}

package/types.ts

@@ -0,0 +1,23 @@
+export interface AdapterOptions {
+  /**
+   * Anthropic API key. Go to https://console.anthropic.com/settings/keys and create a new key.
+   * Set anthropicApiKey: process.env.ANTHROPIC_API_KEY to access it.
+   */
+  anthropicApiKey?: string;
+
+  /**
+   * Deprecated alias kept for compatibility with the package name spelling.
+   */
+  antropicApiKey?: string;
+
+  /**
+   * Model name. See https://docs.anthropic.com/en/docs/about-claude/models for available models.
+   * Default is `claude-sonnet-4-5-20250929`.
+   */
+  model?: string;
+
+  /**
+   * Additional request body parameters to include in the API request.
+   */
+  extraRequestBodyParameters?: Record<string, unknown>;
+}