@strayl/agent 0.1.2 → 0.1.4

package/src/llm/client.ts

@@ -1,276 +0,0 @@
-import OpenAI from "openai";
-import type { Message } from "../types.js";
-import { resolveModel, getModelLimits } from "./models.js";
-import { streamGeminiNative } from "./gemini-native.js";
-
-export type LLMChunk =
-  | { type: "text"; text: string }
-  | { type: "reasoning"; text: string }
-  | { type: "tool_call_delta"; index: number; id?: string; name?: string; arguments: string }
-  | { type: "tool_call_complete"; id: string; name: string; arguments: string }
-  | { type: "usage"; input_tokens: number; output_tokens: number; cost?: number };
-
-// Provider routing is handled by the proxy (api.strayl.dev).
-// The SDK sends all requests to STRAYL_API_URL with a session token.
-// The proxy adds real API keys, routes to the correct provider, and checks billing.
-//
-// For local development without a proxy, set STRAYL_LLM_DIRECT=1 and provide
-// provider-specific env vars (OPENROUTER_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY).
-
-type Mode = "proxy" | "direct";
-
-const GEMINI_MODELS = new Set(["gemini-3-flash-preview", "google/gemini-3.1-pro-preview"]);
-
-export interface LLMClientConfig {
-  modelTier: string;
-  env: Record<string, string>;
-  sessionId?: string;
-}
-
-export class LLMClient {
-  readonly modelName: string;
-  readonly maxTokens: number;
-  readonly maxInputTokens: number;
-  private client: OpenAI;
-  private mode: Mode;
-  private geminiApiKey?: string;
-  private sessionId?: string;
-
-  constructor(config: LLMClientConfig) {
-    this.modelName = resolveModel(config.modelTier);
-    const limits = getModelLimits(this.modelName);
-    this.maxTokens = limits.maxTokens;
-    this.maxInputTokens = limits.maxInputTokens;
-    this.sessionId = config.sessionId;
-
-    // Direct mode: local dev with raw API keys (no proxy)
-    // Proxy mode: production, SDK has no API keys
-    this.mode = config.env.STRAYL_LLM_DIRECT === "1" ? "direct" : "proxy";
-    this.geminiApiKey = config.env.GOOGLE_GENERATIVE_AI_API_KEY;
-
-    this.client = this.createClient(config);
-  }
-
-  private createClient(config: LLMClientConfig): OpenAI {
-    if (this.mode === "proxy") {
-      // All requests go through the Strayl API proxy.
-      // Proxy handles: provider routing, API key injection, billing, rate limiting.
-      // Auth: STRAYL_SESSION_TOKEN passed as Bearer token.
-      // Model header: X-Strayl-Model tells proxy which provider to route to.
-      const apiUrl = config.env.STRAYL_API_URL ?? "https://api.strayl.dev";
-      return new OpenAI({
-        apiKey: config.env.STRAYL_SESSION_TOKEN ?? "no-token",
-        baseURL: `${apiUrl}/v1`,
-        defaultHeaders: {
-          "X-Strayl-Model": this.modelName,
-          "X-Strayl-Session": config.sessionId ?? "",
-        },
-      });
-    }
-
-    // Direct mode — for local development
-    if (GEMINI_MODELS.has(this.modelName) && config.env.GOOGLE_GENERATIVE_AI_API_KEY) {
-      return new OpenAI({
-        apiKey: config.env.GOOGLE_GENERATIVE_AI_API_KEY,
-        baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
-        fetch: this.directGeminiFetch.bind(this),
-      });
-    }
-
-    return new OpenAI({
-      apiKey: config.env.OPENROUTER_API_KEY,
-      baseURL: "https://openrouter.ai/api/v1",
-    });
-  }
-
-  private async directGeminiFetch(url: RequestInfo | URL, init?: RequestInit): Promise<Response> {
-    if (!init?.body || typeof init.body !== "string") return fetch(url, init);
-
-    let body: Record<string, unknown>;
-    try {
-      body = JSON.parse(init.body);
-    } catch {
-      return fetch(url, init);
-    }
-
-    const ALLOWED = new Set([
-      "model", "messages", "tools", "tool_choice",
-      "max_tokens", "max_completion_tokens",
-      "temperature", "top_p", "n", "stream", "stop",
-      "presence_penalty", "frequency_penalty",
-      "response_format", "reasoning_effort", "seed", "google",
-    ]);
-
-    for (const key of Object.keys(body)) {
-      if (!ALLOWED.has(key)) delete body[key];
-    }
-
-    body.reasoning_effort = "medium";
-
-    // Inject thought_signature bypass for multi-turn tool calling
-    if (Array.isArray(body.messages)) {
-      for (const msg of body.messages as Record<string, unknown>[]) {
-        if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
-          for (const tc of msg.tool_calls as Record<string, unknown>[]) {
-            const extra = tc.extra_content as Record<string, Record<string, unknown>> | undefined;
-            if (!extra?.google?.thought_signature) {
-              tc.extra_content = {
-                ...(extra ?? {}),
-                google: {
-                  ...(extra?.google ?? {}),
-                  thought_signature: "skip_thought_signature_validator",
-                },
-              };
-            }
-          }
-        }
-      }
-    }
-
-    const modifiedInit = { ...init, body: JSON.stringify(body) };
-
-    // Retry with exponential backoff for 429/503
-    const MAX_RETRIES = 4;
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-      const response = await fetch(url, modifiedInit);
-      if ((response.status === 429 || response.status === 503) && attempt < MAX_RETRIES) {
-        const retryAfter = response.headers.get("retry-after");
-        const delay = retryAfter
-          ? Math.min(parseInt(retryAfter, 10) * 1000, 30_000)
-          : 1000 * Math.pow(2, attempt - 1);
-        await new Promise(r => setTimeout(r, delay));
-        continue;
-      }
-      if (!response.ok) {
-        try {
-          const clone = response.clone();
-          const arrayBuf = await clone.arrayBuffer();
-          const bytes = new Uint8Array(arrayBuf);
-          let errorText: string;
-          if (bytes[0] === 0x1f && bytes[1] === 0x8b) {
-            const ds = new DecompressionStream("gzip");
-            const decompressed = new Response(new Blob([bytes]).stream().pipeThrough(ds));
-            errorText = await decompressed.text();
-          } else {
-            errorText = new TextDecoder().decode(bytes);
-          }
-          throw new Error(`Gemini API ${response.status}: ${errorText.slice(0, 500)}`);
-        } catch (e) {
-          if (e instanceof Error && e.message.startsWith("Gemini API")) throw e;
-        }
-      }
-      return response;
-    }
-    return fetch(url, modifiedInit);
-  }
-
-  async *stream(messages: Message[], tools: OpenAI.ChatCompletionTool[]): AsyncGenerator<LLMChunk> {
-    // Native Gemini API for thinking support (direct mode only)
-    if (this.mode === "direct" && GEMINI_MODELS.has(this.modelName) && this.geminiApiKey) {
-      yield* streamGeminiNative(this.geminiApiKey, this.modelName, messages, tools, this.maxTokens);
-      return;
-    }
-
-    const params: OpenAI.ChatCompletionCreateParamsStreaming = {
-      model: this.modelName,
-      messages: messages as OpenAI.ChatCompletionMessageParam[],
-      tools: tools.length > 0 ? tools : undefined,
-      stream: true,
-      max_tokens: this.maxTokens,
-    };
-
-    // Request usage tracking (proxy passes this through to OpenRouter)
-    (params as unknown as Record<string, unknown>).usage = { include: true };
-
-    const response = await this.client.chat.completions.create(params);
-
-    const partialToolCalls = new Map<number, { id: string; name: string; arguments: string }>();
-    let emittedToolCalls = false;
-
-    for await (const chunk of response) {
-      const choice = chunk.choices[0];
-      if (!choice) {
-        if (chunk.usage) {
-          yield {
-            type: "usage",
-            input_tokens: chunk.usage.prompt_tokens ?? 0,
-            output_tokens: chunk.usage.completion_tokens ?? 0,
-            cost: (chunk as unknown as { usage?: { cost?: number } }).usage?.cost,
-          };
-        }
-        continue;
-      }
-
-      const delta = choice.delta;
-
-      if (delta?.content) {
-        yield { type: "text", text: delta.content };
-      }
-
-      // Reasoning content (provider-specific fields — proxy passes them through)
-      const anyDelta = delta as Record<string, unknown> | undefined;
-      if (anyDelta?.thought && typeof anyDelta.thought === "string") {
-        yield { type: "reasoning", text: anyDelta.thought };
-      }
-      if (anyDelta?.reasoning_content && typeof anyDelta.reasoning_content === "string") {
-        yield { type: "reasoning", text: anyDelta.reasoning_content };
-      }
-      if (anyDelta?.reasoning && typeof anyDelta.reasoning === "string") {
-        yield { type: "reasoning", text: anyDelta.reasoning };
-      }
-
-      if (delta?.tool_calls) {
-        for (const tc of delta.tool_calls) {
-          const idx = tc.index;
-          let partial = partialToolCalls.get(idx);
-
-          if (!partial) {
-            partial = { id: tc.id || "", name: tc.function?.name || "", arguments: "" };
-            partialToolCalls.set(idx, partial);
-          }
-
-          if (tc.id) partial.id = tc.id;
-          if (tc.function?.name) partial.name = tc.function.name;
-          if (tc.function?.arguments) {
-            partial.arguments += tc.function.arguments;
-            yield {
-              type: "tool_call_delta",
-              index: idx,
-              id: partial.id,
-              name: partial.name,
-              arguments: tc.function.arguments,
-            };
-          }
-        }
-      }
-
-      if (choice.finish_reason === "tool_calls" || choice.finish_reason === "stop") {
-        if (!emittedToolCalls) {
-          emittedToolCalls = true;
-          for (const [, partial] of partialToolCalls) {
-            if (partial.id && partial.name) {
-              yield { type: "tool_call_complete", id: partial.id, name: partial.name, arguments: partial.arguments };
-            }
-          }
-        }
-      }
-
-      if (chunk.usage) {
-        yield {
-          type: "usage",
-          input_tokens: chunk.usage.prompt_tokens ?? 0,
-          output_tokens: chunk.usage.completion_tokens ?? 0,
-          cost: (chunk as unknown as { usage?: { cost?: number } }).usage?.cost,
-        };
-      }
-    }
-
-    if (!emittedToolCalls) {
-      for (const [, partial] of partialToolCalls) {
-        if (partial.id && partial.name && partial.arguments) {
-          yield { type: "tool_call_complete", id: partial.id, name: partial.name, arguments: partial.arguments };
-        }
-      }
-    }
-  }
-}

package/src/llm/gemini-native.ts

@@ -1,307 +0,0 @@
-/**
- * Native Gemini API client for streaming with thinking support.
- * Uses the generateContent endpoint directly (not OpenAI-compat).
- *
- * Key difference from OpenAI-compat: thinking text is returned as `thought: true`
- * parts, and tool calls carry `thoughtSignature` that must be replayed in
- * subsequent requests for multi-turn to work.
- */
-
-import type { Message } from "../types.js";
-import type { LLMChunk } from "./client.js";
-import type OpenAI from "openai";
-
-// Extended chunk type for Gemini thought signatures
-export type GeminiLLMChunk = LLMChunk
-  | { type: "thought_signature"; index: number; signature: string };
-
-interface GeminiPart {
-  text?: string;
-  thought?: boolean;
-  thoughtSignature?: string;
-  functionCall?: { name: string; args: Record<string, unknown> };
-  functionResponse?: { name: string; response: Record<string, unknown> };
-}
-
-interface GeminiContent {
-  role: "user" | "model";
-  parts: GeminiPart[];
-}
-
-interface GeminiFunctionDeclaration {
-  name: string;
-  description: string;
-  parameters?: Record<string, unknown>;
-}
-
-// ─── Message Conversion ──────────────────────────────────────────────
-
-/**
- * We store thoughtSignature in the ToolCall id field as a prefix:
- * "gemini_fc_<ts>_<idx>|<signature>"
- * This is a hack, but it avoids changing the Message type just for Gemini.
- */
-
-function convertMessages(messages: Message[]): {
-  systemInstruction: { parts: Array<{ text: string }> } | undefined;
-  contents: GeminiContent[];
-} {
-  let systemInstruction: { parts: Array<{ text: string }> } | undefined;
-  const contents: GeminiContent[] = [];
-
-  for (const msg of messages) {
-    const textContent = typeof msg.content === "string"
-      ? msg.content
-      : msg.content?.map(p => p.text ?? "").join("") ?? "";
-
-    switch (msg.role) {
-      case "system":
-        if (!systemInstruction) {
-          systemInstruction = { parts: [{ text: textContent }] };
-        } else {
-          systemInstruction.parts.push({ text: textContent });
-        }
-        break;
-
-      case "user":
-        contents.push({ role: "user", parts: [{ text: textContent }] });
-        break;
-
-      case "assistant": {
-        const parts: GeminiPart[] = [];
-        if (textContent) parts.push({ text: textContent });
-        if (msg.tool_calls) {
-          for (const tc of msg.tool_calls) {
-            let args: Record<string, unknown> = {};
-            try { args = JSON.parse(tc.function.arguments); } catch {}
-
-            // Extract thoughtSignature from ID (stored as "id|signature")
-            const pipeIdx = tc.id.indexOf("|");
-            const thoughtSignature = pipeIdx >= 0 ? tc.id.slice(pipeIdx + 1) : undefined;
-
-            const part: GeminiPart = {
-              functionCall: { name: tc.function.name, args },
-            };
-            if (thoughtSignature) {
-              part.thoughtSignature = thoughtSignature;
-            }
-            parts.push(part);
-          }
-        }
-        if (parts.length > 0) {
-          contents.push({ role: "model", parts });
-        }
-        break;
-      }
-
-      case "tool": {
-        let response: Record<string, unknown> = {};
-        try {
-          const parsed = JSON.parse(textContent);
-          // Gemini requires response to be a plain object (not array)
-          if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-            response = parsed as Record<string, unknown>;
-          } else {
-            response = { result: parsed };
-          }
-        } catch {
-          response = { result: textContent };
-        }
-
-        // Tool responses are role: "user" in Gemini API
-        const last = contents[contents.length - 1];
-        if (last?.role === "user" && last.parts.some(p => p.functionResponse)) {
-          last.parts.push({
-            functionResponse: { name: msg.name ?? "unknown", response },
-          });
-        } else {
-          contents.push({
-            role: "user",
-            parts: [{
-              functionResponse: { name: msg.name ?? "unknown", response },
-            }],
-          });
-        }
-        break;
-      }
-    }
-  }
-
-  return { systemInstruction, contents };
-}
-
-// ─── Tool Conversion ─────────────────────────────────────────────────
-
-function convertTools(tools: OpenAI.ChatCompletionTool[]): Array<{ functionDeclarations: GeminiFunctionDeclaration[] }> | undefined {
-  const decls: GeminiFunctionDeclaration[] = [];
-  for (const t of tools) {
-    if (t.type !== "function") continue;
-    decls.push({
-      name: t.function.name,
-      description: t.function.description ?? "",
-      parameters: t.function.parameters as Record<string, unknown> | undefined,
-    });
-  }
-  return decls.length > 0 ? [{ functionDeclarations: decls }] : undefined;
-}
-
-// ─── SSE Stream Parser ───────────────────────────────────────────────
-
-async function* parseSSEStream(response: Response): AsyncGenerator<Record<string, unknown>> {
-  const reader = response.body!.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop()!;
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith("data: ")) {
-        const jsonStr = trimmed.slice(6);
-        if (jsonStr === "[DONE]") return;
-        try {
-          yield JSON.parse(jsonStr);
-        } catch {}
-      }
-    }
-  }
-
-  if (buffer.trim().startsWith("data: ")) {
-    try { yield JSON.parse(buffer.trim().slice(6)); } catch {}
-  }
-}
-
-// ─── Main Streaming Function ─────────────────────────────────────────
-
-export async function* streamGeminiNative(
-  apiKey: string,
-  modelName: string,
-  messages: Message[],
-  tools: OpenAI.ChatCompletionTool[],
-  maxTokens: number,
-): AsyncGenerator<LLMChunk> {
-  const { systemInstruction, contents } = convertMessages(messages);
-  const geminiTools = convertTools(tools);
-
-  const body: Record<string, unknown> = {
-    contents,
-    generationConfig: {
-      maxOutputTokens: maxTokens,
-      thinkingConfig: {
-        thinkingBudget: 8192,
-        includeThoughts: true,
-      },
-    },
-  };
-
-  if (systemInstruction) body.systemInstruction = systemInstruction;
-  if (geminiTools) body.tools = geminiTools;
-
-  const url = `https://generativelanguage.googleapis.com/v1beta/models/${modelName}:streamGenerateContent?alt=sse&key=${apiKey}`;
-
-  const MAX_RETRIES = 4;
-  let response: Response | null = null;
-
-  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-    response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body),
-    });
-
-    if ((response.status === 429 || response.status === 503) && attempt < MAX_RETRIES) {
-      const retryAfter = response.headers.get("retry-after");
-      const delay = retryAfter
-        ? Math.min(parseInt(retryAfter, 10) * 1000, 30_000)
-        : 1000 * Math.pow(2, attempt - 1);
-      await new Promise(r => setTimeout(r, delay));
-      continue;
-    }
-
-    if (!response.ok) {
-      let errorText = "";
-      try { errorText = await response.text(); } catch {}
-      throw new Error(`Gemini API ${response.status}: ${errorText.slice(0, 500)}`);
-    }
-
-    break;
-  }
-
-  if (!response?.body) {
-    throw new Error("Gemini API returned no body");
-  }
-
-  let toolCallIndex = 0;
-  let usageEmitted = false;
-
-  for await (const chunk of parseSSEStream(response)) {
-    const candidates = chunk.candidates as Array<{
-      content?: { parts?: GeminiPart[] };
-      finishReason?: string;
-    }> | undefined;
-
-    // Process parts
-    if (candidates?.[0]?.content?.parts) {
-      for (const part of candidates[0].content!.parts!) {
-        // Thinking content
-        if (part.thought && part.text) {
-          yield { type: "reasoning", text: part.text };
-          continue;
-        }
-
-        // Text content (skip empty text and thoughtSignature-only parts)
-        if (part.text && !part.thought && !part.thoughtSignature) {
-          yield { type: "text", text: part.text };
-          continue;
-        }
-
-        // Function call — include thoughtSignature in the ID
-        if (part.functionCall) {
-          const baseId = `gemini_fc_${Date.now()}_${toolCallIndex}`;
-          // Encode thoughtSignature into the ID so it survives the message round-trip
-          const id = part.thoughtSignature
-            ? `${baseId}|${part.thoughtSignature}`
-            : baseId;
-          const argsStr = JSON.stringify(part.functionCall.args ?? {});
-
-          yield {
-            type: "tool_call_delta",
-            index: toolCallIndex,
-            id,
-            name: part.functionCall.name,
-            arguments: argsStr,
-          };
-          yield {
-            type: "tool_call_complete",
-            id,
-            name: part.functionCall.name,
-            arguments: argsStr,
-          };
-          toolCallIndex++;
-        }
-      }
-    }
-
-    // Usage in final chunk
-    const meta = chunk.usageMetadata as {
-      promptTokenCount?: number;
-      candidatesTokenCount?: number;
-      thoughtsTokenCount?: number;
-    } | undefined;
-
-    if (meta && candidates?.[0]?.finishReason && !usageEmitted) {
-      usageEmitted = true;
-      yield {
-        type: "usage",
-        input_tokens: meta.promptTokenCount ?? 0,
-        output_tokens: (meta.candidatesTokenCount ?? 0) + (meta.thoughtsTokenCount ?? 0),
-      };
-    }
-  }
-}

package/src/llm/models.ts

@@ -1,64 +0,0 @@
-export const MODEL_MAP: Record<string, string> = {
-  // Tier defaults
-  auto: "gemini-3-flash-preview",
-  light: "x-ai/grok-4.1-fast",
-  pro: "anthropic/claude-sonnet-4.6",
-  deep: "anthropic/claude-opus-4.6",
-
-  // Short aliases
-  haiku: "anthropic/claude-haiku-4.5",
-  kimi: "moonshotai/kimi-k2.5",
-  grok: "x-ai/grok-4.1-fast",
-  gemini: "google/gemini-3.1-pro-preview",
-  sonnet: "anthropic/claude-sonnet-4.6",
-  codex: "openai/gpt-5.3-codex",
-  opus: "anthropic/claude-opus-4.6",
-  flash: "gemini-3-flash-preview",
-
-  // Full IDs map to themselves
-  "anthropic/claude-haiku-4.5": "anthropic/claude-haiku-4.5",
-  "moonshotai/kimi-k2.5": "moonshotai/kimi-k2.5",
-  "x-ai/grok-4.1-fast": "x-ai/grok-4.1-fast",
-  "google/gemini-3.1-pro-preview": "google/gemini-3.1-pro-preview",
-  "anthropic/claude-sonnet-4.6": "anthropic/claude-sonnet-4.6",
-  "openai/gpt-5.3-codex": "openai/gpt-5.3-codex",
-  "anthropic/claude-opus-4.6": "anthropic/claude-opus-4.6",
-  "gemini-3-flash-preview": "gemini-3-flash-preview",
-};
-
-export const MODEL_LIMITS: Record<string, { maxTokens: number; maxInputTokens: number }> = {
-  "gemini-3-flash-preview": { maxTokens: 65_536, maxInputTokens: 1_000_000 },
-  "openai/gpt-5.3-codex": { maxTokens: 100_000, maxInputTokens: 280_000 },
-  "anthropic/claude-opus-4.6": { maxTokens: 100_000, maxInputTokens: 900_000 },
-  "anthropic/claude-haiku-4.5": { maxTokens: 16_384, maxInputTokens: 200_000 },
-  "moonshotai/kimi-k2.5": { maxTokens: 65_536, maxInputTokens: 262_000 },
-  "x-ai/grok-4.1-fast": { maxTokens: 100_000, maxInputTokens: 800_000 },
-  "google/gemini-3.1-pro-preview": { maxTokens: 65_536, maxInputTokens: 900_000 },
-  "anthropic/claude-sonnet-4.6": { maxTokens: 100_000, maxInputTokens: 900_000 },
-};
-
-export const DEFAULT_LIMITS = { maxTokens: 100_000, maxInputTokens: 280_000 };
-
-export type ModelTier = "light" | "pro" | "deep";
-
-export const MODEL_TO_TIER: Record<string, ModelTier> = {
-  "auto": "light",
-  "gemini-3-flash-preview": "light",
-  "anthropic/claude-haiku-4.5": "light",
-  "moonshotai/kimi-k2.5": "light",
-  "x-ai/grok-4.1-fast": "light",
-  "google/gemini-3.1-pro-preview": "pro",
-  "anthropic/claude-sonnet-4.6": "pro",
-  "openai/gpt-5.3-codex": "pro",
-  "anthropic/claude-opus-4.6": "deep",
-};
-export const SUBAGENT_MODEL = "x-ai/grok-4.1-fast";
-export const SUMMARIZATION_MODEL = "google/gemini-2.5-flash-lite";
-
-export function resolveModel(tier: string): string {
-  return MODEL_MAP[tier] ?? tier;
-}
-
-export function getModelLimits(model: string): { maxTokens: number; maxInputTokens: number } {
-  return MODEL_LIMITS[model] ?? DEFAULT_LIMITS;
-}

package/src/middleware/compose.ts

@@ -1,24 +0,0 @@
-import type { Middleware, Message } from "../types.js";
-import type OpenAI from "openai";
-
-export function composeMiddleware(middlewares: Middleware[]): {
-  beforeModel: (messages: Message[]) => Message[];
-  filterTools: (tools: OpenAI.ChatCompletionTool[]) => OpenAI.ChatCompletionTool[];
-} {
-  return {
-    beforeModel: (messages) => {
-      let result = messages;
-      for (const mw of middlewares) {
-        if (mw.beforeModel) result = mw.beforeModel(result);
-      }
-      return result;
-    },
-    filterTools: (tools) => {
-      let result = tools;
-      for (const mw of middlewares) {
-        if (mw.filterTools) result = mw.filterTools(result);
-      }
-      return result;
-    },
-  };
-}