@adminforth/agent 1.0.0

package/.woodpecker/buildRelease.sh

@@ -0,0 +1,13 @@
+
+#!/bin/bash
+
+# write npm run output both to console and to build.log
+npm run build 2>&1 | tee build.log
+build_status=${PIPESTATUS[0]}
+
+# if exist status from the npm run build is not 0
+# then exit with the status code from the npm run build
+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,46 @@
+#!/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"
+# Send the 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,57 @@
+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:
+      - apt update && apt install -y rsync
+      - . /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/agent/middleware/apiBasedTools.ts

@@ -0,0 +1,109 @@
+import { ToolMessage } from "@langchain/core/messages";
+import { createMiddleware } from "langchain";
+import { logger } from "adminforth";
+import type { ApiBasedTool } from "../../apiBasedTools.js";
+import { ALWAYS_AVAILABLE_API_TOOL_NAMES } from "../tools/index.js";
+import { createApiTool } from "../tools/apiTool.js";
+
+function getEnabledApiToolNames(messages: unknown[]) {
+  const enabledToolNames = new Set<string>();
+
+  for (const message of messages) {
+    if (!ToolMessage.isInstance(message) || message.name !== "fetch_tool_schema") {
+      continue;
+    }
+
+    const content =
+      typeof message.content === "string"
+        ? message.content
+        : Array.isArray(message.content)
+          ? message.content
+              .map((block) =>
+                typeof block === "string"
+                  ? block
+                  : "text" in block
+                    ? block.text
+                    : "",
+              )
+              .join("")
+          : "";
+
+    try {
+      const parsed = JSON.parse(content) as { status?: number; name?: string };
+
+      if (parsed.status === 200 && parsed.name) {
+        enabledToolNames.add(parsed.name);
+      }
+    } catch {}
+  }
+
+  return enabledToolNames;
+}
+
+export function createApiBasedToolsMiddleware(
+  apiBasedTools: Record<string, ApiBasedTool>,
+) {
+  const alwaysAvailableApiToolNames = new Set<string>(ALWAYS_AVAILABLE_API_TOOL_NAMES);
+  const dynamicTools = Object.fromEntries(
+    Object.entries(apiBasedTools).map(([toolName, apiBasedTool]) => [
+      toolName,
+      createApiTool(toolName, apiBasedTool),
+    ]),
+  );
+
+  return createMiddleware({
+    name: "ApiBasedToolsMiddleware",
+    async wrapModelCall(request, handler) {
+      const enabledApiToolNames = getEnabledApiToolNames(request.state.messages);
+      const tools = [...enabledApiToolNames]
+        .filter((toolName) => !alwaysAvailableApiToolNames.has(toolName))
+        .map((toolName) => dynamicTools[toolName]);
+
+      return handler({
+        ...request,
+        tools: [...request.tools, ...tools],
+      });
+    },
+    async wrapToolCall(request, handler) {
+      const startedAt = Date.now();
+      const toolInput = JSON.stringify(request.toolCall.args ?? {});
+      logger.info(
+        `Invoking tool "${request.toolCall.name}" with input: ${toolInput}`,
+      );
+
+      try {
+        if (request.tool) {
+          return await handler(request);
+        }
+
+        const enabledApiToolNames = getEnabledApiToolNames(request.state.messages);
+
+        if (enabledApiToolNames.has(request.toolCall.name)) {
+          return await handler({
+            ...request,
+            tool: dynamicTools[request.toolCall.name],
+          });
+        }
+
+        return new ToolMessage({
+          content: `Tool "${request.toolCall.name}" is not loaded. Call fetch_tool_schema first.`,
+          tool_call_id: request.toolCall.id ?? "",
+          name: request.toolCall.name,
+          status: "error",
+        });
+      } catch (error) {
+        const errorDetails =
+          error instanceof Error ? error.stack ?? error.message : String(error);
+
+        logger.error(
+          `Tool "${request.toolCall.name}" failed after ${Date.now() - startedAt}ms with input: ${toolInput}\n${errorDetails}`,
+        );
+        throw error;
+      } finally {
+        logger.info(
+          `Tool "${request.toolCall.name}" finished in ${Date.now() - startedAt}ms`,
+        );
+      }
+    },
+  });
+}

package/agent/middleware/sequenceDebug.ts

@@ -0,0 +1,302 @@
+import { AIMessage } from "@langchain/core/messages";
+import { createMiddleware } from "langchain";
+import YAML from "yaml";
+import type { ToolCallEvent } from "../toolCallEvents.js";
+
+export type SequenceDebugResultType = "tool_calls" | "final_text";
+
+type SequenceDebugToolCall = {
+  toolCallId: string;
+  toolName: string;
+  input: string;
+  output: string | null;
+  error: string | null;
+};
+
+type PendingSequenceDebugToolCall = SequenceDebugToolCall & {
+  completed: boolean;
+};
+
+export type SequenceDebug = {
+  sequenceId: number;
+  startedAt: string;
+  prompt: string;
+  reasoning: string;
+  text: string;
+  toolCalls: SequenceDebugToolCall[];
+  endedAt: string;
+  resultType: SequenceDebugResultType;
+};
+
+type PendingSequenceDebug = Omit<SequenceDebug, "toolCalls" | "endedAt" | "resultType"> & {
+  toolCalls: PendingSequenceDebugToolCall[];
+  pendingToolCalls: number;
+  resultType: SequenceDebugResultType | null;
+};
+
+type SequenceDebugModelCall = {
+  reasoning: string;
+  text: string;
+  resultType: SequenceDebugResultType;
+};
+
+export type SequenceDebugModelCallSink = {
+  handleModelCallStart: (prompt: string) => void;
+  handleModelCallComplete: (params: SequenceDebugModelCall) => void;
+};
+
+export type SequenceDebugCollector = SequenceDebugModelCallSink & {
+  handleToolCallEvent: (event: ToolCallEvent) => void;
+  flush: () => void;
+  getHistory: () => SequenceDebug[];
+};
+
+function createPendingSequenceDebug(sequenceId: number): PendingSequenceDebug {
+  return {
+    sequenceId,
+    startedAt: new Date().toISOString(),
+    prompt: "",
+    reasoning: "",
+    text: "",
+    toolCalls: [],
+    pendingToolCalls: 0,
+    resultType: null,
+  };
+}
+
+function hasSequenceDebugContent(sequence: PendingSequenceDebug | null): sequence is PendingSequenceDebug {
+  return Boolean(
+    sequence &&
+      (
+        sequence.prompt ||
+        sequence.reasoning ||
+        sequence.text ||
+        sequence.toolCalls.length > 0
+      ),
+  );
+}
+
+function finalizeSequenceDebug(sequence: PendingSequenceDebug): SequenceDebug {
+  return {
+    sequenceId: sequence.sequenceId,
+    startedAt: sequence.startedAt,
+    prompt: sequence.prompt,
+    reasoning: sequence.reasoning,
+    text: sequence.text,
+    toolCalls: sequence.toolCalls.map(({ completed: _completed, ...toolCall }) => toolCall),
+    endedAt: new Date().toISOString(),
+    resultType: sequence.resultType ?? "final_text",
+  };
+}
+
+function stringifyPromptForDebug(params: {
+  systemMessage: { toDict(): unknown };
+  messages: Array<{ toDict(): unknown }>;
+  tools: unknown[];
+  modelSettings?: Record<string, unknown>;
+}) {
+  const { systemMessage, messages, tools, modelSettings } = params;
+
+  return YAML.stringify({
+    systemMessage: systemMessage.toDict(),
+    messages: messages.map((message) => message.toDict()),
+    tools: tools.map((tool) => {
+      if (
+        typeof tool === "object" &&
+        tool !== null &&
+        "name" in tool &&
+        typeof tool.name === "string"
+      ) {
+        return tool.name;
+      }
+
+      if (
+        typeof tool === "object" &&
+        tool !== null &&
+        "schema" in tool &&
+        typeof tool.schema === "object" &&
+        tool.schema !== null &&
+        "name" in tool.schema &&
+        typeof tool.schema.name === "string"
+      ) {
+        return tool.schema.name;
+      }
+
+      return "";
+    }),
+    ...(modelSettings && Object.keys(modelSettings).length > 0
+      ? { modelSettings }
+      : {}),
+  });
+}
+
+function getMessageBlocks(message: {
+  contentBlocks?: unknown;
+  content?: unknown;
+}) {
+  if (Array.isArray(message.contentBlocks)) {
+    return message.contentBlocks;
+  }
+
+  if (Array.isArray(message.content)) {
+    return message.content;
+  }
+
+  return [];
+}
+
+function hasToolCallSignal(message: {
+  tool_calls?: unknown;
+  tool_call_chunks?: unknown;
+  additional_kwargs?: { tool_calls?: unknown };
+}) {
+  return Boolean(
+    (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) ||
+      (Array.isArray(message.tool_call_chunks) && message.tool_call_chunks.length > 0) ||
+      (Array.isArray(message.additional_kwargs?.tool_calls) &&
+        message.additional_kwargs.tool_calls.length > 0),
+  );
+}
+
+function extractSequenceResponseDebug(message: AIMessage): SequenceDebugModelCall {
+  const blocks = getMessageBlocks(message);
+  const reasoning = blocks
+    .filter((block: any) => block?.type === "reasoning")
+    .map((block: any) => String(block.reasoning ?? ""))
+    .join("");
+  const textFromBlocks = blocks
+    .filter((block: any) => block?.type === "text")
+    .map((block: any) => String(block.text ?? ""))
+    .join("");
+
+  return {
+    reasoning,
+    text: textFromBlocks || (typeof message.content === "string" ? message.content : ""),
+    resultType: hasToolCallSignal(message) ? "tool_calls" : "final_text",
+  };
+}
+
+export function createSequenceDebugCollector(): SequenceDebugCollector {
+  let nextSequenceId = 1;
+  let currentSequenceDebug: PendingSequenceDebug | null = null;
+  const history: SequenceDebug[] = [];
+
+  const ensureSequenceDebug = () => {
+    if (!currentSequenceDebug) {
+      currentSequenceDebug = createPendingSequenceDebug(nextSequenceId++);
+    }
+
+    return currentSequenceDebug;
+  };
+
+  const flush = () => {
+    if (!hasSequenceDebugContent(currentSequenceDebug)) {
+      currentSequenceDebug = null;
+      return;
+    }
+
+    const finalizedSequenceDebug = finalizeSequenceDebug(currentSequenceDebug);
+    history.push(finalizedSequenceDebug);
+    currentSequenceDebug = null;
+  };
+
+  return {
+    handleModelCallStart(prompt) {
+      if (
+        currentSequenceDebug?.resultType &&
+        currentSequenceDebug.pendingToolCalls === 0
+      ) {
+        flush();
+      }
+
+      const sequenceDebug = ensureSequenceDebug();
+      sequenceDebug.prompt = prompt;
+    },
+    handleModelCallComplete(params) {
+      const sequenceDebug = ensureSequenceDebug();
+      sequenceDebug.reasoning = params.reasoning;
+      sequenceDebug.text = params.text;
+      sequenceDebug.resultType = params.resultType;
+
+      if (
+        sequenceDebug.resultType === "final_text" &&
+        sequenceDebug.pendingToolCalls === 0
+      ) {
+        flush();
+      }
+    },
+    handleToolCallEvent(event) {
+      const sequenceDebug = ensureSequenceDebug();
+
+      if (event.phase === "start") {
+        sequenceDebug.toolCalls.push({
+          toolCallId: event.toolCallId,
+          toolName: event.toolName,
+          input: event.input,
+          output: null,
+          error: null,
+          completed: false,
+        });
+        sequenceDebug.pendingToolCalls += 1;
+        return;
+      }
+
+      const pendingToolCall = sequenceDebug.toolCalls.find(
+        (toolCall) => toolCall.toolCallId === event.toolCallId && !toolCall.completed,
+      );
+
+      if (pendingToolCall) {
+        pendingToolCall.output = event.output;
+        pendingToolCall.error = event.error;
+        pendingToolCall.completed = true;
+      } else {
+        sequenceDebug.toolCalls.push({
+          toolCallId: event.toolCallId,
+          toolName: event.toolName,
+          input: "",
+          output: event.output,
+          error: event.error,
+          completed: true,
+        });
+      }
+
+      sequenceDebug.pendingToolCalls = Math.max(
+        0,
+        sequenceDebug.pendingToolCalls - 1,
+      );
+
+      if (
+        sequenceDebug.resultType === "tool_calls" &&
+        sequenceDebug.pendingToolCalls === 0
+      ) {
+        flush();
+      }
+    },
+    flush,
+    getHistory() {
+      return history;
+    },
+  };
+}
+
+export function createSequenceDebugMiddleware(
+  sink: SequenceDebugModelCallSink,
+) {
+  return createMiddleware({
+    name: "SequenceDebugMiddleware",
+    async wrapModelCall(request, handler) {
+      sink.handleModelCallStart(
+        stringifyPromptForDebug({
+          systemMessage: request.systemMessage,
+          messages: request.messages,
+          tools: request.tools,
+          modelSettings: request.modelSettings,
+        }),
+      );
+
+      const response = await handler(request) as AIMessage;
+      sink.handleModelCallComplete(extractSequenceResponseDebug(response));
+      return response;
+    },
+  });
+}