anymous 1.3.0 → 1.3.2

package/src/tool/mcp-websearch.ts

@@ -1,97 +0,0 @@
-import type { Duration } from "effect"
-import { Effect, Schema } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
-
-export const EXA_URL = process.env.EXA_API_KEY
-  ? `https://mcp.exa.ai/mcp?exaApiKey=${encodeURIComponent(process.env.EXA_API_KEY)}`
-  : "https://mcp.exa.ai/mcp"
-export const PARALLEL_URL = "https://search.parallel.ai/mcp"
-
-const McpResult = Schema.Struct({
-  result: Schema.Struct({
-    content: Schema.Array(
-      Schema.Struct({
-        type: Schema.String,
-        text: Schema.String,
-      }),
-    ),
-  }),
-})
-
-const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(McpResult))
-
-const parsePayload = (payload: string) =>
-  Effect.gen(function* () {
-    const trimmed = payload.trim()
-    if (!trimmed.startsWith("{")) return undefined
-    const data = yield* decode(trimmed)
-    return data.result.content.find((item) => item.text)?.text
-  })
-
-export const parseResponse = Effect.fn("McpWebSearch.parseResponse")(function* (body: string) {
-  const trimmed = body.trim()
-  const direct = trimmed ? yield* parsePayload(trimmed) : undefined
-  if (direct) return direct
-
-  for (const line of body.split("\n")) {
-    if (!line.startsWith("data: ")) continue
-    const data = yield* parsePayload(line.substring(6))
-    if (data) return data
-  }
-  return undefined
-})
-
-export const SearchArgs = Schema.Struct({
-  query: Schema.String,
-  type: Schema.String,
-  numResults: Schema.Number,
-  livecrawl: Schema.String,
-  contextMaxCharacters: Schema.optional(Schema.Number),
-})
-
-export const ParallelSearchArgs = Schema.Struct({
-  objective: Schema.String,
-  search_queries: Schema.Array(Schema.String),
-  session_id: Schema.optional(Schema.String),
-  model_name: Schema.optional(Schema.String),
-})
-
-const McpRequest = <F extends Schema.Struct.Fields>(args: Schema.Struct<F>) =>
-  Schema.Struct({
-    jsonrpc: Schema.Literal("2.0"),
-    id: Schema.Literal(1),
-    method: Schema.Literal("tools/call"),
-    params: Schema.Struct({
-      name: Schema.String,
-      arguments: args,
-    }),
-  })
-
-export const call = <F extends Schema.Struct.Fields>(
-  http: HttpClient.HttpClient,
-  url: string,
-  tool: string,
-  args: Schema.Struct<F>,
-  value: Schema.Struct.Type<F>,
-  timeout: Duration.Input,
-  headers?: Record<string, string>,
-) =>
-  Effect.gen(function* () {
-    const request = yield* HttpClientRequest.post(url).pipe(
-      HttpClientRequest.accept("application/json, text/event-stream"),
-      HttpClientRequest.setHeaders(headers ?? {}),
-      HttpClientRequest.schemaBodyJson(McpRequest(args))({
-        jsonrpc: "2.0" as const,
-        id: 1 as const,
-        method: "tools/call" as const,
-        params: { name: tool, arguments: value },
-      }),
-    )
-    const response = yield* HttpClient.filterStatusOk(http)
-      .execute(request)
-      .pipe(
-        Effect.timeoutOrElse({ duration: timeout, orElse: () => Effect.die(new Error(`${tool} request timed out`)) }),
-      )
-    const body = yield* response.text
-    return yield* parseResponse(body)
-  })

package/src/tool/memory.ts

@@ -1,59 +0,0 @@
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-import { Memory } from "@/memory/memory"
-import DESCRIPTION from "./memory.txt"
-
-export const Parameters = Schema.Struct({
-  action: Schema.Literals(["read", "write", "delete", "list"]).annotate({ description: "Action to perform" }),
-  key: Schema.optional(Schema.String).annotate({ description: "Memory key (required for read/write/delete)" }),
-  value: Schema.optional(Schema.String).annotate({ description: "Memory value (required for write)" }),
-})
-
-export const MemoryTool = Tool.define<typeof Parameters, {}, Memory.Service>(
-  "memory",
-  Effect.gen(function* () {
-    const memory = yield* Memory.Service
-
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: Schema.Schema.Type<typeof Parameters>) =>
-        Effect.gen(function* () {
-          const { action, key, value } = params
-
-          if (action === "list") {
-            const entries = yield* memory.list()
-            if (entries.length === 0) {
-              return { title: "No memories", output: "No memories stored.", metadata: {} }
-            }
-            const formatted = entries.map((e) => `- ${e.key}: ${e.value}`).join("\n")
-            return { title: `Listed ${entries.length} memories`, output: formatted, metadata: {} }
-          }
-
-          if (action === "read") {
-            if (!key) return { title: "Error", output: "Key is required for read action.", metadata: {} }
-            const entry = yield* memory.read(key)
-            if (!entry) return { title: "Not found", output: `No memory found for key "${key}".`, metadata: {} }
-            return { title: `Read memory: ${key}`, output: entry.value, metadata: {} }
-          }
-
-          if (action === "write") {
-            if (!key || !value) {
-              return { title: "Error", output: "Both key and value are required for write action.", metadata: {} }
-            }
-            yield* memory.write(key, value)
-            return { title: `Memory saved: ${key}`, output: `Saved memory "${key}".`, metadata: {} }
-          }
-
-          if (action === "delete") {
-            if (!key) return { title: "Error", output: "Key is required for delete action.", metadata: {} }
-            const deleted = yield* memory.delete(key)
-            if (!deleted) return { title: "Not found", output: `No memory found for key "${key}".`, metadata: {} }
-            return { title: `Memory deleted: ${key}`, output: `Deleted memory "${key}".`, metadata: {} }
-          }
-
-          return { title: "Unknown action", output: `Unknown action: ${action}`, metadata: {} }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/memory.txt

@@ -1,14 +0,0 @@
-Persistent shared context memory that persists across sessions. Use this to remember important information about the project, user preferences, architecture decisions, credentials, or any context you want to carry between sessions.
-
-Actions:
-- read (key): Read a specific memory
-- write (key, value): Save or update a memory
-- delete (key): Remove a memory
-- list: List all memories
-
-Memories are scoped to the current project (workspace). Memories you write are only visible when working inside this same project. They are automatically injected into the system prompt at the start of every session as shared context. Use this for:
-- Project architecture decisions
-- Coding conventions and preferences
-- Authentication tokens or API keys
-- Important findings or TODOs
-- User preferences for how you should behave

package/src/tool/plan-enter.txt

@@ -1,14 +0,0 @@
-Use this tool to suggest switching to plan agent when the user's request would benefit from planning before implementation.
-
-If they explicitly mention wanting to create a plan ALWAYS call this tool first.
-
-This tool will ask the user if they want to switch to plan agent.
-
-Call this tool when:
-- The user's request is complex and would benefit from planning first
-- You want to research and design before making changes
-- The task involves multiple files or significant architectural decisions
-
-Do NOT call this tool:
-- For simple, straightforward tasks
-- When the user explicitly wants immediate implementation

package/src/tool/plan-exit.txt

@@ -1,13 +0,0 @@
-Use this tool when you have completed the planning phase and are ready to exit plan agent.
-
-This tool will ask the user if they want to switch to build agent to start implementing the plan.
-
-Call this tool:
-- After you have written a complete plan to the plan file
-- After you have clarified any questions with the user
-- When you are confident the plan is ready for implementation
-
-Do NOT call this tool:
-- Before you have created or finalized the plan
-- If you still have unanswered questions about the implementation
-- If the user has indicated they want to continue planning

package/src/tool/plan.ts

@@ -1,79 +0,0 @@
-import path from "path"
-import type { SessionV1 } from "@anymous-ai/core/v1/session"
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-import { Question } from "../question"
-import { Session } from "@/session/session"
-import { MessageV2 } from "../session/message-v2"
-import { Provider } from "@/provider/provider"
-import { InstanceState } from "@/effect/instance-state"
-import { MessageID, PartID } from "../session/schema"
-import EXIT_DESCRIPTION from "./plan-exit.txt"
-
-export const Parameters = Schema.Struct({})
-
-export const PlanExitTool = Tool.define(
-  "plan_exit",
-  Effect.gen(function* () {
-    const session = yield* Session.Service
-    const question = yield* Question.Service
-    const provider = yield* Provider.Service
-
-    return {
-      description: EXIT_DESCRIPTION,
-      parameters: Parameters,
-      execute: (_params: {}, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          const instance = yield* InstanceState.context
-          const info = yield* session.get(ctx.sessionID)
-          const plan = path.relative(instance.worktree, Session.plan(info, instance))
-          const answers = yield* question.ask({
-            sessionID: ctx.sessionID,
-            questions: [
-              {
-                question: `Plan at ${plan} is complete. Would you like to switch to the build agent and start implementing?`,
-                header: "Build Agent",
-                custom: false,
-                options: [
-                  { label: "Yes", description: "Switch to build agent and start implementing the plan" },
-                  { label: "No", description: "Stay with plan agent to continue refining the plan" },
-                ],
-              },
-            ],
-            tool: ctx.callID ? { messageID: ctx.messageID, callID: ctx.callID } : undefined,
-          })
-
-          if (answers[0]?.[0] === "No") yield* new Question.RejectedError()
-
-          const messages = yield* session.messages({ sessionID: ctx.sessionID }).pipe(Effect.orDie)
-          const lastUser = messages.findLast((item) => item.info.role === "user" && item.info.model)
-          const model =
-            lastUser?.info.role === "user" && lastUser.info.model ? lastUser.info.model : yield* provider.defaultModel()
-
-          const msg: SessionV1.User = {
-            id: MessageID.ascending(),
-            sessionID: ctx.sessionID,
-            role: "user",
-            time: { created: Date.now() },
-            agent: "build",
-            model,
-          }
-          yield* session.updateMessage(msg)
-          yield* session.updatePart({
-            id: PartID.ascending(),
-            messageID: msg.id,
-            sessionID: ctx.sessionID,
-            type: "text",
-            text: `The plan at ${plan} has been approved, you can now edit files. Execute the plan`,
-            synthetic: true,
-          } satisfies SessionV1.TextPart)
-
-          return {
-            title: "Switching to build agent",
-            output: "User approved switching to build agent. Wait for further instructions.",
-            metadata: {},
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/question.ts

@@ -1,44 +0,0 @@
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-import { Question } from "../question"
-import DESCRIPTION from "./question.txt"
-
-export const Parameters = Schema.Struct({
-  questions: Schema.mutable(Schema.Array(Question.Prompt)).annotate({ description: "Questions to ask" }),
-})
-
-type Metadata = {
-  answers: ReadonlyArray<Question.Answer>
-}
-
-export const QuestionTool = Tool.define<typeof Parameters, Metadata, Question.Service>(
-  "question",
-  Effect.gen(function* () {
-    const question = yield* Question.Service
-
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context<Metadata>) =>
-        Effect.gen(function* () {
-          const answers = yield* question.ask({
-            sessionID: ctx.sessionID,
-            questions: params.questions,
-            tool: ctx.callID ? { messageID: ctx.messageID, callID: ctx.callID } : undefined,
-          })
-
-          const formatted = params.questions
-            .map((q, i) => `"${q.question}"="${answers[i]?.length ? answers[i].join(", ") : "Unanswered"}"`)
-            .join(", ")
-
-          return {
-            title: `Asked ${params.questions.length} question${params.questions.length > 1 ? "s" : ""}`,
-            output: `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`,
-            metadata: {
-              answers,
-            },
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/question.txt

@@ -1,10 +0,0 @@
-Use this tool when you need to ask the user questions during execution. This allows you to:
-1. Gather user preferences or requirements
-2. Clarify ambiguous instructions
-3. Get decisions on implementation choices as you work
-4. Offer choices to the user about what direction to take.
-
-Usage notes:
-- When `custom` is enabled (default), a "Type your own answer" option is added automatically; don't include "Other" or catch-all options
-- Answers are returned as arrays of labels; set `multiple: true` to allow selecting more than one
-- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label