@adminforth/agent 2.0.10 → 2.2.0

package/agent/middleware/apiBasedTools.ts

@@ -1,174 +0,0 @@
-import { ToolMessage } from "@langchain/core/messages";
-import { isGraphInterrupt } from "@langchain/langgraph";
-import { createMiddleware } from "langchain";
-import { logger, type AdminUser, type IAdminForth } from "adminforth";
-import {
-  formatApiBasedToolCall,
-  type ApiBasedTool,
-} from "../../apiBasedTools.js";
-import {
-  createToolCallTracker,
-  type ToolCallEventSink,
-} from "../toolCallEvents.js";
-import { ALWAYS_AVAILABLE_API_TOOL_NAMES } from "../tools/index.js";
-import { createApiTool } from "../tools/apiTool.js";
-import type { AgentEventEmitter } from "../../agentEvents.js";
-import type { SequenceDebugCollector } from "./sequenceDebug.js";
-import { isAbortError } from "../../errors.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>,
-  adminforth: IAdminForth,
-) {
-  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]);
-      const availableTools = [...request.tools, ...tools];
-
-      logger.info(
-        `AdminForth Agent callable tools: ${availableTools.map((tool) => tool.name).join(", ")}`,
-      );
-
-      return handler({
-        ...request,
-        tools: availableTools,
-      });
-    },
-    async wrapToolCall(request, handler) {
-      const startedAt = Date.now();
-      const toolInput = JSON.stringify(request.toolCall.args ?? {});
-      if (!request.toolCall.id) {
-        throw new Error(`Tool call "${request.toolCall.name}" has no id.`);
-      }
-
-      const toolCallId = request.toolCall.id;
-      const { adminUser, abortSignal, emit, sequenceDebugSink, userTimeZone } = request.runtime.context as {
-        adminUser: AdminUser;
-        abortSignal?: AbortSignal;
-        emit?: AgentEventEmitter;
-        sequenceDebugSink: SequenceDebugCollector;
-        userTimeZone: string;
-      };
-      const emitToolCall: ToolCallEventSink = (event) => {
-        sequenceDebugSink.handleToolCallEvent(event);
-        void emit?.({
-          type: "tool-call",
-          data: event,
-        });
-      };
-      const toolArgs = (request.toolCall.args ?? {}) as Record<string, unknown>;
-      let toolInfo: string | undefined;
-
-      if (request.toolCall.name === "fetch_skill") {
-        toolInfo = `Load ${(toolArgs.skillName as string).split("_").join(" ")} skill`;
-      } else if (request.toolCall.name === "fetch_tool_schema") {
-        toolInfo = `Load ${(toolArgs.toolName as string).split("_").join(" ")} tool `;
-      } else {
-        toolInfo = await formatApiBasedToolCall({
-          adminforth,
-          adminUser,
-          inputs: toolArgs,
-          toolName: request.toolCall.name,
-          userTimeZone,
-        });
-      }
-      const toolCallTracker = createToolCallTracker({
-        emit: emitToolCall,
-        toolCallId,
-        toolName: request.toolCall.name,
-        toolInfo,
-        input: toolArgs,
-        startedAt,
-      });
-      toolCallTracker.start();
-      logger.info(
-        `Invoking tool "${request.toolCall.name}" with input: ${toolInput}`,
-      );
-
-      try {
-
-        const result = getEnabledApiToolNames(request.state.messages).has(request.toolCall.name)
-          ? await handler({
-              ...request,
-              tool: dynamicTools[request.toolCall.name],
-            })
-          : await handler(request);
-
-        toolCallTracker.finishSuccess(result);
-        return result;
-      } catch (error) {
-        if (
-          isGraphInterrupt(error)
-          || abortSignal?.aborted
-          || isAbortError(error)
-        ) {
-          throw error;
-        }
-
-        const message = error instanceof Error ? error.message : String(error);
-
-        logger.error(
-          `Error calling tool "${request.toolCall.name}": ${error instanceof Error ? error.stack ?? error.message : String(error)}`,
-        );
-        toolCallTracker.finishError(`Error: ${message}`);
-        return new ToolMessage({
-          name: request.toolCall.name,
-          tool_call_id: toolCallId,
-          status: "error",
-          content: `Error: ${message}`,
-        })
-      } finally {
-        logger.info(
-          `Tool "${request.toolCall.name}" finished in ${Date.now() - startedAt}ms`,
-        );
-      }
-    },
-  });
-}

package/agent/middleware/openAiResponsesContinuation.ts

@@ -1,92 +0,0 @@
-import { AIMessage } from "@langchain/core/messages";
-import { createMiddleware } from "langchain";
-
-type OpenAiResponsesMetadata = {
-  id?: string;
-};
-
-type OpenAiResponsesContext = {
-  sessionId: string;
-  turnId: string;
-};
-
-function getTurnKey(context: OpenAiResponsesContext) {
-  return `${context.sessionId}:${context.turnId}`;
-}
-
-function getResponseId(message: AIMessage) {
-  const metadata = message.response_metadata as OpenAiResponsesMetadata | undefined;
-  return metadata?.id ?? null;
-}
-
-function getPreviousResponseId(modelSettings?: Record<string, unknown>) {
-  return (modelSettings as { previous_response_id?: string } | undefined)
-    ?.previous_response_id;
-}
-
-function getContinuationMessages<T extends { response_metadata?: unknown }>(
-  messages: T[],
-  previousResponseId: string,
-) {
-  let continuationStartIndex: number | null = null;
-
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index];
-
-    if (
-      AIMessage.isInstance(message) &&
-      (message.response_metadata as OpenAiResponsesMetadata | undefined)?.id ===
-        previousResponseId
-    ) {
-      continuationStartIndex = index + 1;
-      break;
-    }
-  }
-
-  if (continuationStartIndex === null) {
-    return null;
-  }
-
-  return messages.slice(continuationStartIndex);
-}
-
-export function createOpenAiResponsesContinuationMiddleware() {
-  const responseIdsByTurn = new Map<string, string>();
-
-  return createMiddleware({
-    name: "OpenAiResponsesContinuationMiddleware",
-    async wrapModelCall(request, handler) {
-      const context = request.runtime.context as OpenAiResponsesContext;
-      const turnKey = getTurnKey(context);
-      const previousResponseId =
-        getPreviousResponseId(request.modelSettings) ??
-        responseIdsByTurn.get(turnKey);
-      const continuationMessages = previousResponseId
-        ? getContinuationMessages(request.messages, previousResponseId)
-        : null;
-
-      const response = await handler(
-        previousResponseId && continuationMessages
-          ? {
-              ...request,
-              messages: continuationMessages,
-              modelSettings: {
-                ...request.modelSettings,
-                previous_response_id: previousResponseId,
-              },
-            }
-          : request,
-      ) as AIMessage;
-
-      const responseId = getResponseId(response);
-
-      if (responseId) {
-        responseIdsByTurn.set(turnKey, responseId);
-      } else {
-        responseIdsByTurn.delete(turnKey);
-      }
-
-      return response;
-    },
-  });
-}

package/agent/middleware/sequenceDebug.ts

@@ -1,429 +0,0 @@
-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;
-  promptTokens: number;
-  reasoning: string;
-  reasoningTokens: number;
-  text: string;
-  textTokens: number;
-  uncachedInputTokens: number;
-  cachedInputTokens: number;
-  outputTokens: number;
-  cachedTokens: number;
-  responseId: string | null;
-  toolCalls: SequenceDebugToolCall[];
-  endedAt: string;
-  resultType: SequenceDebugResultType;
-};
-
-type PendingSequenceDebug = Omit<SequenceDebug, "toolCalls" | "endedAt" | "resultType"> & {
-  toolCalls: PendingSequenceDebugToolCall[];
-  pendingToolCalls: number;
-  resultType: SequenceDebugResultType | null;
-};
-
-type SequenceDebugModelCall = {
-  promptTokens: number;
-  reasoning: string;
-  reasoningTokens: number;
-  text: string;
-  textTokens: number;
-  uncachedInputTokens: number;
-  cachedInputTokens: number;
-  outputTokens: number;
-  cachedTokens: number;
-  responseId: string | null;
-  resultType: SequenceDebugResultType;
-};
-
-type OpenAiUsageMetadata = {
-  input_tokens?: number;
-  output_tokens?: number;
-  input_token_details?: {
-    cache_read?: number;
-  };
-};
-
-type OpenAiResponseMetadata = {
-  id?: string;
-};
-
-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: "",
-    promptTokens: 0,
-    reasoning: "",
-    reasoningTokens: 0,
-    text: "",
-    textTokens: 0,
-    uncachedInputTokens: 0,
-    cachedInputTokens: 0,
-    outputTokens: 0,
-    cachedTokens: 0,
-    responseId: null,
-    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,
-    promptTokens: sequence.promptTokens,
-    reasoning: sequence.reasoning,
-    reasoningTokens: sequence.reasoningTokens,
-    text: sequence.text,
-    textTokens: sequence.textTokens,
-    uncachedInputTokens: sequence.uncachedInputTokens,
-    cachedInputTokens: sequence.cachedInputTokens,
-    outputTokens: sequence.outputTokens,
-    cachedTokens: sequence.cachedTokens,
-    responseId: sequence.responseId,
-    toolCalls: sequence.toolCalls.map(({ completed: _completed, ...toolCall }) => toolCall),
-    endedAt: new Date().toISOString(),
-    resultType: sequence.resultType ?? "final_text",
-  };
-}
-
-type SequenceDebugPromptModel = {
-  getName?: () => string;
-  model?: string;
-  _defaultConfig?: {
-    modelProvider?: string;
-  };
-  invocationParams?: (options?: Record<string, unknown>) => Record<string, unknown>;
-};
-
-function getDebugModelName(model: SequenceDebugPromptModel) {
-  return typeof model.getName === "function" ? model.getName() : undefined;
-}
-
-function getDebugToolName(tool: unknown) {
-  if (!tool || typeof tool !== "object") {
-    return null;
-  }
-
-  const name = (tool as { name?: unknown }).name;
-  return typeof name === "string" ? name : null;
-}
-
-function formatToolsForDebug(tools: unknown[]) {
-  return tools.map((tool) => ({
-    name: getDebugToolName(tool),
-  }));
-}
-
-function stringifyPromptForDebug(params: {
-  model: SequenceDebugPromptModel;
-  systemMessage: { text: string };
-  messages: unknown[];
-  tools: unknown[];
-  toolChoice?: unknown;
-  modelSettings?: Record<string, unknown>;
-}) {
-  const { model, systemMessage, messages, tools, toolChoice, modelSettings } = params;
-  const invocationParams =
-    typeof model.invocationParams === "function"
-      ? model.invocationParams({
-          ...(modelSettings ?? {}),
-          ...(tools.length > 0 ? { tools } : {}),
-          ...(toolChoice !== undefined ? { tool_choice: toolChoice } : {}),
-        })
-      : null;
-
-  return YAML.stringify({
-    model: {
-      name: getDebugModelName(model) ?? null,
-      provider: model._defaultConfig?.modelProvider ?? null,
-      configuredModel:
-        typeof model.model === "string" ? model.model : null,
-    },
-    systemMessage,
-    messages,
-    ...(tools.length > 0 ? { tools: formatToolsForDebug(tools) } : {}),
-    ...(toolChoice !== undefined ? { toolChoice } : {}),
-    ...(modelSettings ? { modelSettings } : {}),
-    ...(invocationParams ? { invocationParams } : {}),
-  });
-}
-
-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 hasTokenCounter(model: unknown): model is {
-  getNumTokens: (content: string) => Promise<number>;
-} {
-  return (
-    typeof model === "object" &&
-    model !== null &&
-    "getNumTokens" in model &&
-    typeof model.getNumTokens === "function"
-  );
-}
-
-async function countTokens(model: unknown, content: string) {
-  if (!content) {
-    return 0;
-  }
-
-  if (!hasTokenCounter(model)) {
-    return 0;
-  }
-
-  return await model.getNumTokens(content);
-}
-
-function extractSequenceResponseDebug(message: AIMessage): SequenceDebugModelCall {
-  const usageMetadata = message.usage_metadata as OpenAiUsageMetadata | undefined;
-  const promptTokens = usageMetadata?.input_tokens ?? 0;
-  const cachedInputTokens = usageMetadata?.input_token_details?.cache_read ?? 0;
-  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 {
-    promptTokens,
-    reasoning,
-    reasoningTokens: 0,
-    text: textFromBlocks || (typeof message.content === "string" ? message.content : ""),
-    textTokens: 0,
-    uncachedInputTokens: Math.max(promptTokens - cachedInputTokens, 0),
-    cachedInputTokens,
-    outputTokens: usageMetadata?.output_tokens ?? 0,
-    cachedTokens: cachedInputTokens,
-    responseId:
-      (message.response_metadata as OpenAiResponseMetadata | undefined)?.id ??
-      null,
-    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.promptTokens = params.promptTokens;
-      sequenceDebug.reasoning = params.reasoning;
-      sequenceDebug.reasoningTokens = params.reasoningTokens;
-      sequenceDebug.text = params.text;
-      sequenceDebug.textTokens = params.textTokens;
-      sequenceDebug.uncachedInputTokens = params.uncachedInputTokens;
-      sequenceDebug.cachedInputTokens = params.cachedInputTokens;
-      sequenceDebug.outputTokens = params.outputTokens;
-      sequenceDebug.cachedTokens = params.cachedTokens;
-      sequenceDebug.responseId = params.responseId;
-      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) {
-      const prompt = stringifyPromptForDebug({
-        model: request.model as unknown as SequenceDebugPromptModel,
-        systemMessage: request.systemMessage,
-        messages: request.messages,
-        tools: request.tools,
-        toolChoice: request.toolChoice,
-        modelSettings: request.modelSettings,
-      });
-
-      sink.handleModelCallStart(
-        prompt,
-      );
-
-      const response = await handler(request) as AIMessage;
-      const debug = extractSequenceResponseDebug(response);
-      const [promptTokens, reasoningTokens, textTokens] = await Promise.all([
-        debug.promptTokens || countTokens(request.model, prompt),
-        countTokens(request.model, debug.reasoning),
-        countTokens(request.model, debug.text),
-      ]);
-
-      sink.handleModelCallComplete({
-        ...debug,
-        promptTokens,
-        reasoningTokens,
-        textTokens,
-        uncachedInputTokens: debug.promptTokens ? debug.uncachedInputTokens : promptTokens,
-        outputTokens: debug.outputTokens || reasoningTokens + textTokens,
-      });
-      return response;
-    },
-  });
-}

package/agent/models/AgentModeResolver.ts

@@ -1,9 +0,0 @@
-import type { PluginOptions } from "../../types.js";
-
-export class AgentModeResolver {
-  constructor(private readonly options: PluginOptions) {}
-
-  resolve(modeName?: string | null) {
-    return this.options.modes.find((mode) => mode.name === modeName) ?? this.options.modes[0];
-  }
-}