plugsuits 1.0.0

package/src/agent.ts

@@ -0,0 +1,455 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import type { ProviderOptions as AiProviderOptions } from "@ai-sdk/provider-utils";
+import {
+  createAgent,
+  type AgentStreamOptions as HarnessAgentStreamOptions,
+  type AgentStreamResult as HarnessAgentStreamResult,
+} from "@ai-sdk-tool/harness";
+import { createFriendli } from "@friendliai/ai-provider";
+import {
+  InvalidToolInputError,
+  type ModelMessage,
+  NoSuchToolError,
+  wrapLanguageModel,
+} from "ai";
+import { getEnvironmentContext } from "./context/environment-context";
+import { loadSkillsMetadata } from "./context/skills";
+import { SYSTEM_PROMPT } from "./context/system-prompt";
+import type { TranslationModelConfig } from "./context/translation";
+import { env } from "./env";
+import {
+  applyFriendliInterleavedField,
+  buildFriendliChatTemplateKwargs,
+  getFriendliSelectableReasoningModes,
+} from "./friendli-reasoning";
+import { buildMiddlewares } from "./middleware";
+import {
+  buildTodoContinuationPrompt,
+  getIncompleteTodos,
+} from "./middleware/todo-continuation";
+import { DEFAULT_REASONING_MODE, type ReasoningMode } from "./reasoning-mode";
+import {
+  DEFAULT_TOOL_FALLBACK_MODE,
+  LEGACY_ENABLED_TOOL_FALLBACK_MODE,
+  type ToolFallbackMode,
+} from "./tool-fallback-mode";
+import { createTools, type ToolRegistry } from "./tools";
+
+export const DEFAULT_MODEL_ID = "MiniMaxAI/MiniMax-M2.5";
+export const DEFAULT_ANTHROPIC_MODEL_ID = "claude-sonnet-4-6";
+const OUTPUT_TOKEN_MAX = 64_000;
+const TRANSLATION_MAX_OUTPUT_TOKENS = 4000;
+
+type ProviderOptions = AiProviderOptions | undefined;
+
+export type AgentStreamOptions = Pick<HarnessAgentStreamOptions, "abortSignal">;
+export type AgentStreamResult = HarnessAgentStreamResult;
+
+export type ProviderType = "friendli" | "anthropic";
+
+export const ANTHROPIC_MODELS = [
+  { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6 (Latest)" },
+  { id: "claude-opus-4-6", name: "Claude Opus 4.6 (Latest)" },
+] as const;
+
+const friendli = env.FRIENDLI_TOKEN
+  ? createFriendli({
+      apiKey: env.FRIENDLI_TOKEN,
+      includeUsage: true,
+    })
+  : null;
+
+const anthropic = env.ANTHROPIC_API_KEY
+  ? createAnthropic({
+      apiKey: env.ANTHROPIC_API_KEY,
+    })
+  : null;
+
+const getModel = (modelId: string, provider: ProviderType) => {
+  if (provider === "anthropic") {
+    if (!anthropic) {
+      throw new Error(
+        "ANTHROPIC_API_KEY is not set. Please set it in your environment."
+      );
+    }
+    return anthropic(modelId);
+  }
+
+  if (!friendli) {
+    throw new Error(
+      "FRIENDLI_TOKEN is not set. Please set it in your environment."
+    );
+  }
+  return friendli(modelId);
+};
+
+const ANTHROPIC_THINKING_BUDGET_TOKENS = 10_000;
+const ANTHROPIC_MAX_OUTPUT_TOKENS = 64_000;
+const ANTHROPIC_SELECTABLE_REASONING_MODES: ReasoningMode[] = ["off", "on"];
+const REASONING_MODE_PRIORITY: readonly ReasoningMode[] = [
+  "preserved",
+  "interleaved",
+  "on",
+  "off",
+];
+const TRANSLATION_REASONING_MODE_PRIORITY: readonly ReasoningMode[] = [
+  "off",
+  "on",
+];
+
+const selectBestReasoningMode = (
+  modes: readonly ReasoningMode[]
+): ReasoningMode => {
+  for (const mode of REASONING_MODE_PRIORITY) {
+    if (modes.includes(mode)) {
+      return mode;
+    }
+  }
+
+  return DEFAULT_REASONING_MODE;
+};
+
+export const selectTranslationReasoningMode = (
+  modes: readonly ReasoningMode[]
+): ReasoningMode => {
+  for (const mode of TRANSLATION_REASONING_MODE_PRIORITY) {
+    if (modes.includes(mode)) {
+      return mode;
+    }
+  }
+
+  return selectBestReasoningMode(modes);
+};
+
+const isAnthropicWithReasoning = (
+  modelId: string,
+  provider: ProviderType,
+  reasoningMode: ReasoningMode
+): boolean => {
+  const thinkingEnabled = reasoningMode !== "off";
+  return (
+    provider === "anthropic" && thinkingEnabled && !modelId.includes("opus")
+  );
+};
+
+const getProviderOptions = (
+  modelId: string,
+  provider: ProviderType,
+  reasoningMode: ReasoningMode
+): { options: ProviderOptions; maxOutputTokens: number } => {
+  const thinkingEnabled = reasoningMode !== "off";
+
+  const getAnthropicProviderOptions = () => {
+    if (!thinkingEnabled) {
+      return undefined;
+    }
+
+    const isOpus = modelId.includes("opus");
+    if (isOpus) {
+      return { anthropic: { effort: "high" } };
+    }
+
+    return {
+      anthropic: {
+        thinking: {
+          type: "enabled",
+          budgetTokens: ANTHROPIC_THINKING_BUDGET_TOKENS,
+        },
+      },
+    };
+  };
+
+  if (provider === "anthropic") {
+    return {
+      options: getAnthropicProviderOptions(),
+      maxOutputTokens: isAnthropicWithReasoning(
+        modelId,
+        provider,
+        reasoningMode
+      )
+        ? ANTHROPIC_MAX_OUTPUT_TOKENS - ANTHROPIC_THINKING_BUDGET_TOKENS
+        : OUTPUT_TOKEN_MAX,
+    };
+  }
+
+  const chatTemplateKwargs = buildFriendliChatTemplateKwargs(
+    modelId,
+    reasoningMode
+  );
+
+  return {
+    options: chatTemplateKwargs
+      ? {
+          friendli: {
+            chat_template_kwargs: chatTemplateKwargs,
+          },
+        }
+      : undefined,
+    maxOutputTokens: OUTPUT_TOKEN_MAX,
+  };
+};
+
+const createBaseModel = (
+  modelId: string,
+  provider: ProviderType,
+  toolFallbackMode: ToolFallbackMode,
+  reasoningMode: ReasoningMode
+) => {
+  const model = getModel(modelId, provider);
+  const { options, maxOutputTokens } = getProviderOptions(
+    modelId,
+    provider,
+    reasoningMode
+  );
+
+  const wrappedModel = wrapLanguageModel({
+    model,
+    middleware: buildMiddlewares({
+      toolFallbackMode,
+    }),
+  });
+
+  return { model: wrappedModel, providerOptions: options, maxOutputTokens };
+};
+
+const defaultToolRegistry = createTools();
+
+/**
+ * Repair malformed tool calls from weak models.
+ * Cleans hashline artifacts (e.g. `42#AB|content42#AB`) that models
+ * sometimes embed in JSON arguments.
+ */
+const repairToolCall: Parameters<
+  typeof import("ai").streamText
+>[0]["experimental_repairToolCall"] = ({ toolCall, error }) => {
+  if (NoSuchToolError.isInstance(error)) {
+    return Promise.resolve(null);
+  }
+  if (!InvalidToolInputError.isInstance(error)) {
+    return Promise.resolve(null);
+  }
+  try {
+    const raw =
+      typeof toolCall.input === "string"
+        ? toolCall.input
+        : JSON.stringify(toolCall.input);
+    const cleaned = raw
+      .replace(
+        /(\d+#[A-Z]{2})(?:[|=-][^"{}[\]]*?)\1(?:[|=-][^"{}[\]]*?)*/g,
+        "$1"
+      )
+      .replace(/(\d+#[A-Z]{2})(?:-\1)+/g, "$1");
+    const parsed = JSON.parse(cleaned);
+    return Promise.resolve({ ...toolCall, input: JSON.stringify(parsed) });
+  } catch {
+    return Promise.resolve(null);
+  }
+};
+
+export type ModelType = "serverless" | "dedicated";
+
+export class AgentManager {
+  private modelId: string = DEFAULT_MODEL_ID;
+  private modelType: ModelType = "serverless";
+  private provider: ProviderType = "friendli";
+  private headlessMode = false;
+  private reasoningMode: ReasoningMode = DEFAULT_REASONING_MODE;
+  private toolRegistry: ToolRegistry = defaultToolRegistry;
+  private toolFallbackMode: ToolFallbackMode = DEFAULT_TOOL_FALLBACK_MODE;
+  private translationEnabled = true;
+
+  constructor() {
+    this.applyBestReasoningModeForCurrentModel();
+  }
+
+  resetForTesting(): void {
+    this.modelId = DEFAULT_MODEL_ID;
+    this.modelType = "serverless";
+    this.provider = "friendli";
+    this.headlessMode = false;
+    this.reasoningMode = DEFAULT_REASONING_MODE;
+    this.toolRegistry = defaultToolRegistry;
+    this.toolFallbackMode = DEFAULT_TOOL_FALLBACK_MODE;
+    this.translationEnabled = true;
+    this.applyBestReasoningModeForCurrentModel();
+  }
+
+  private applyBestReasoningModeForCurrentModel(): void {
+    this.reasoningMode = selectBestReasoningMode(
+      this.getSelectableReasoningModes()
+    );
+  }
+
+  private buildModel(reasoningMode: ReasoningMode = this.reasoningMode) {
+    return createBaseModel(
+      this.modelId,
+      this.provider,
+      this.toolFallbackMode,
+      reasoningMode
+    );
+  }
+
+  getModelId(): string {
+    return this.modelId;
+  }
+
+  setModelId(modelId: string): void {
+    this.modelId = modelId;
+    this.applyBestReasoningModeForCurrentModel();
+  }
+
+  getModelType(): ModelType {
+    return this.modelType;
+  }
+
+  setModelType(type: ModelType): void {
+    this.modelType = type;
+  }
+
+  getProvider(): ProviderType {
+    return this.provider;
+  }
+
+  setProvider(provider: ProviderType): void {
+    this.provider = provider;
+    if (provider === "anthropic") {
+      this.modelId = DEFAULT_ANTHROPIC_MODEL_ID;
+    } else {
+      this.modelId = DEFAULT_MODEL_ID;
+    }
+
+    this.applyBestReasoningModeForCurrentModel();
+  }
+
+  setHeadlessMode(enabled: boolean): void {
+    this.headlessMode = enabled;
+  }
+
+  isHeadlessMode(): boolean {
+    return this.headlessMode;
+  }
+
+  setReasoningMode(mode: ReasoningMode): void {
+    this.reasoningMode = mode;
+  }
+
+  getReasoningMode(): ReasoningMode {
+    return this.reasoningMode;
+  }
+
+  getSelectableReasoningModes(): ReasoningMode[] {
+    if (this.provider === "friendli") {
+      return getFriendliSelectableReasoningModes(this.modelId);
+    }
+    return [...ANTHROPIC_SELECTABLE_REASONING_MODES];
+  }
+
+  setThinkingEnabled(enabled: boolean): void {
+    this.reasoningMode = enabled ? "on" : DEFAULT_REASONING_MODE;
+  }
+
+  isThinkingEnabled(): boolean {
+    return this.reasoningMode !== DEFAULT_REASONING_MODE;
+  }
+
+  getToolFallbackMode(): ToolFallbackMode {
+    return this.toolFallbackMode;
+  }
+
+  setToolFallbackMode(mode: ToolFallbackMode): void {
+    this.toolFallbackMode = mode;
+  }
+
+  setToolFallbackEnabled(enabled: boolean): void {
+    this.toolFallbackMode = enabled
+      ? LEGACY_ENABLED_TOOL_FALLBACK_MODE
+      : DEFAULT_TOOL_FALLBACK_MODE;
+  }
+
+  isToolFallbackEnabled(): boolean {
+    return this.toolFallbackMode !== DEFAULT_TOOL_FALLBACK_MODE;
+  }
+
+  setTranslationEnabled(enabled: boolean): void {
+    this.translationEnabled = enabled;
+  }
+
+  isTranslationEnabled(): boolean {
+    return this.translationEnabled;
+  }
+
+  getTranslationReasoningMode(): ReasoningMode {
+    return selectTranslationReasoningMode(this.getSelectableReasoningModes());
+  }
+
+  getTranslationModelConfig(): TranslationModelConfig {
+    const translationReasoningMode = this.getTranslationReasoningMode();
+    const { model, providerOptions } = this.buildModel(
+      translationReasoningMode
+    );
+
+    return {
+      model,
+      providerOptions,
+      maxOutputTokens: TRANSLATION_MAX_OUTPUT_TOKENS,
+    };
+  }
+
+  async getInstructions(): Promise<string> {
+    let instructions = SYSTEM_PROMPT + getEnvironmentContext();
+
+    const skillMetadata = await loadSkillsMetadata();
+    if (skillMetadata) {
+      instructions += skillMetadata;
+    }
+
+    const incompleteTodos = await getIncompleteTodos();
+    if (incompleteTodos.length > 0) {
+      instructions += `
+
+${buildTodoContinuationPrompt(incompleteTodos)}`;
+    }
+
+    return instructions;
+  }
+
+  getTools(): ToolRegistry {
+    return this.toolRegistry;
+  }
+
+  setTools(toolRegistry: ToolRegistry): void {
+    this.toolRegistry = toolRegistry;
+  }
+
+  async stream(
+    messages: ModelMessage[],
+    options: AgentStreamOptions = {}
+  ): Promise<AgentStreamResult> {
+    const { model, providerOptions, maxOutputTokens } = this.buildModel();
+    const preparedMessages =
+      this.provider === "friendli"
+        ? applyFriendliInterleavedField(
+            messages,
+            this.modelId,
+            this.reasoningMode
+          )
+        : messages;
+
+    const agent = createAgent({
+      model,
+      tools: this.toolRegistry,
+      instructions: await this.getInstructions(),
+      maxStepsPerTurn: 1,
+      experimental_repairToolCall: repairToolCall,
+    });
+
+    return agent.stream({
+      messages: preparedMessages,
+      ...options,
+      providerOptions,
+      maxOutputTokens,
+    });
+  }
+}
+
+export const agentManager = new AgentManager();

package/src/cli-args.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it } from "bun:test";
+import {
+  parseProviderArg,
+  parseReasoningCliOption,
+  parseToolFallbackCliOption,
+  parseTranslateCliOption,
+} from "./cli-args";
+
+describe("parseProviderArg", () => {
+  it("returns 'anthropic' for valid anthropic arg", () => {
+    expect(parseProviderArg("anthropic")).toBe("anthropic");
+  });
+
+  it("returns 'friendli' for valid friendli arg", () => {
+    expect(parseProviderArg("friendli")).toBe("friendli");
+  });
+
+  it("returns null for unknown provider", () => {
+    expect(parseProviderArg("openai")).toBeNull();
+  });
+
+  it("returns null for undefined", () => {
+    expect(parseProviderArg(undefined)).toBeNull();
+  });
+
+  it("returns null for empty string", () => {
+    expect(parseProviderArg("")).toBeNull();
+  });
+});
+
+describe("parseTranslateCliOption", () => {
+  it("returns true for --translate", () => {
+    expect(parseTranslateCliOption("--translate")).toBe(true);
+  });
+
+  it("returns false for --no-translate", () => {
+    expect(parseTranslateCliOption("--no-translate")).toBe(false);
+  });
+
+  it("returns null for unrecognized args", () => {
+    expect(parseTranslateCliOption("--other")).toBeNull();
+    expect(parseTranslateCliOption("translate")).toBeNull();
+  });
+});
+
+describe("parseReasoningCliOption", () => {
+  it("returns mode 'on' for --think", () => {
+    const result = parseReasoningCliOption(["--think"], 0);
+    expect(result).toEqual({ consumedArgs: 0, mode: "on" });
+  });
+
+  it("returns null for unrelated args", () => {
+    expect(parseReasoningCliOption(["--model"], 0)).toBeNull();
+    expect(parseReasoningCliOption(["foo"], 0)).toBeNull();
+  });
+
+  it("parses --reasoning-mode with valid value", () => {
+    const result = parseReasoningCliOption(
+      ["--reasoning-mode", "interleaved"],
+      0
+    );
+    expect(result).toEqual({ consumedArgs: 1, mode: "interleaved" });
+  });
+
+  it("falls back to default when --reasoning-mode value is missing", () => {
+    const result = parseReasoningCliOption(["--reasoning-mode"], 0);
+    expect(result).toEqual({ consumedArgs: 0, mode: "off" });
+  });
+
+  it("falls back to default when --reasoning-mode is followed by another flag", () => {
+    const result = parseReasoningCliOption(["--reasoning-mode", "--model"], 0);
+    expect(result).toEqual({ consumedArgs: 0, mode: "off" });
+  });
+
+  it("falls back to default for invalid reasoning mode value", () => {
+    const result = parseReasoningCliOption(["--reasoning-mode", "garbage"], 0);
+    expect(result).toEqual({ consumedArgs: 1, mode: "off" });
+  });
+
+  it("handles valid aliases like 'enable' → 'on'", () => {
+    const result = parseReasoningCliOption(["--reasoning-mode", "enable"], 0);
+    expect(result).toEqual({ consumedArgs: 1, mode: "on" });
+  });
+});
+
+describe("parseToolFallbackCliOption", () => {
+  it("returns null for unrelated args", () => {
+    expect(parseToolFallbackCliOption(["--model"], 0)).toBeNull();
+  });
+
+  it("parses --toolcall-mode with valid value", () => {
+    const result = parseToolFallbackCliOption(
+      ["--toolcall-mode", "morphxml"],
+      0
+    );
+    expect(result).toEqual({ consumedArgs: 1, mode: "morphxml" });
+  });
+
+  it("uses DEFAULT_TOOL_FALLBACK_MODE when --toolcall-mode has no value", () => {
+    const result = parseToolFallbackCliOption(["--toolcall-mode"], 0);
+    expect(result).toEqual({ consumedArgs: 0, mode: "disable" });
+  });
+
+  it("uses DEFAULT_TOOL_FALLBACK_MODE when --toolcall-mode is followed by a flag", () => {
+    const result = parseToolFallbackCliOption(
+      ["--toolcall-mode", "--model"],
+      0
+    );
+    expect(result).toEqual({ consumedArgs: 0, mode: "disable" });
+  });
+
+  it("parses --tool-fallback with valid value", () => {
+    const result = parseToolFallbackCliOption(["--tool-fallback", "hermes"], 0);
+    expect(result).toEqual({ consumedArgs: 1, mode: "hermes" });
+  });
+
+  it("uses LEGACY_ENABLED mode when --tool-fallback has no value", () => {
+    const result = parseToolFallbackCliOption(["--tool-fallback"], 0);
+    expect(result).toEqual({ consumedArgs: 0, mode: "morphxml" });
+  });
+
+  it("uses LEGACY_ENABLED mode when --tool-fallback is followed by a flag", () => {
+    const result = parseToolFallbackCliOption(
+      ["--tool-fallback", "--other"],
+      0
+    );
+    expect(result).toEqual({ consumedArgs: 0, mode: "morphxml" });
+  });
+
+  it("falls back to appropriate default for invalid value", () => {
+    const toolcall = parseToolFallbackCliOption(
+      ["--toolcall-mode", "garbage"],
+      0
+    );
+    expect(toolcall).toEqual({ consumedArgs: 1, mode: "disable" });
+
+    const fallback = parseToolFallbackCliOption(
+      ["--tool-fallback", "garbage"],
+      0
+    );
+    expect(fallback).toEqual({ consumedArgs: 1, mode: "morphxml" });
+  });
+
+  it("handles correct index in multi-arg arrays", () => {
+    const args = ["--model", "gpt-4", "--toolcall-mode", "hermes"];
+    expect(parseToolFallbackCliOption(args, 0)).toBeNull();
+    expect(parseToolFallbackCliOption(args, 2)).toEqual({
+      consumedArgs: 1,
+      mode: "hermes",
+    });
+  });
+});

package/src/cli-args.ts

@@ -0,0 +1,90 @@
+import type { ProviderType } from "./agent";
+import {
+  DEFAULT_REASONING_MODE,
+  parseReasoningMode,
+  type ReasoningMode,
+} from "./reasoning-mode";
+import {
+  DEFAULT_TOOL_FALLBACK_MODE,
+  LEGACY_ENABLED_TOOL_FALLBACK_MODE,
+  parseToolFallbackMode,
+  type ToolFallbackMode,
+} from "./tool-fallback-mode";
+
+export type { ProviderType };
+
+export const parseProviderArg = (
+  providerArg: string | undefined
+): ProviderType | null => {
+  if (providerArg === "anthropic" || providerArg === "friendli") {
+    return providerArg;
+  }
+  return null;
+};
+
+export const parseTranslateCliOption = (arg: string): boolean | null => {
+  if (arg === "--translate") {
+    return true;
+  }
+  if (arg === "--no-translate") {
+    return false;
+  }
+  return null;
+};
+
+export const parseReasoningCliOption = (
+  args: string[],
+  index: number
+): { consumedArgs: number; mode: ReasoningMode } | null => {
+  const arg = args[index];
+  if (arg === "--think") {
+    return { consumedArgs: 0, mode: "on" };
+  }
+  if (arg !== "--reasoning-mode") {
+    return null;
+  }
+  const candidate = args[index + 1];
+  if (candidate && !candidate.startsWith("--")) {
+    const parsedMode = parseReasoningMode(candidate);
+    return {
+      consumedArgs: 1,
+      mode: parsedMode ?? DEFAULT_REASONING_MODE,
+    };
+  }
+  return {
+    consumedArgs: 0,
+    mode: DEFAULT_REASONING_MODE,
+  };
+};
+
+export const parseToolFallbackCliOption = (
+  args: string[],
+  index: number
+): { consumedArgs: number; mode: ToolFallbackMode } | null => {
+  const arg = args[index];
+
+  const parseCandidate = (
+    fallbackMode: ToolFallbackMode
+  ): { consumedArgs: number; mode: ToolFallbackMode } => {
+    const candidate = args[index + 1];
+    if (!candidate || candidate.startsWith("--")) {
+      return {
+        consumedArgs: 0,
+        mode: fallbackMode,
+      };
+    }
+    const parsedMode = parseToolFallbackMode(candidate);
+    return {
+      consumedArgs: 1,
+      mode: parsedMode ?? fallbackMode,
+    };
+  };
+
+  if (arg === "--toolcall-mode") {
+    return parseCandidate(DEFAULT_TOOL_FALLBACK_MODE);
+  }
+  if (arg === "--tool-fallback") {
+    return parseCandidate(LEGACY_ENABLED_TOOL_FALLBACK_MODE);
+  }
+  return null;
+};