saeeol 1.2.0 → 1.2.2

package/src/tool/mcp-exa.ts

@@ -1,73 +1 @@
-import { Duration, Effect, Schema } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
-
-const URL = process.env.EXA_API_KEY
-  ? `https://mcp.exa.ai/mcp?exaApiKey=${encodeURIComponent(process.env.EXA_API_KEY)}`
-  : "https://mcp.exa.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 parseSse = Effect.fn("McpExa.parseSse")(function* (body: string) {
-  for (const line of body.split("\n")) {
-    if (!line.startsWith("data: ")) continue
-    const data = yield* decode(line.substring(6))
-    if (data.result.content[0]?.text) return data.result.content[0].text
-  }
-  return undefined
-})
-
-export const SearchArgs = Schema.Struct({
-  query: Schema.String,
-  type: Schema.String,
-  numResults: Schema.Number,
-  livecrawl: Schema.String,
-  contextMaxCharacters: Schema.optional(Schema.Number),
-})
-
-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,
-  tool: string,
-  args: Schema.Struct<F>,
-  value: Schema.Struct.Type<F>,
-  timeout: Duration.Input,
-) =>
-  Effect.gen(function* () {
-    const request = yield* HttpClientRequest.post(URL).pipe(
-      HttpClientRequest.accept("application/json, text/event-stream"),
-      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* parseSse(body)
-  })
+export * from "./integration/mcp-exa"

package/src/tool/package.ts

@@ -1,168 +1 @@
-import { Effect, Schema } from "effect"
-import { Npm } from "@saeeol/core/npm"
-import * as Bus from "@/bus"
-import * as Tool from "./tool"
-import { ProviderInstallEvent } from "@/provider/provider-events"
-
-const Parameters = Schema.Struct({
-  action: Schema.Literals(["install", "list"]).annotate({
-    description: '"install" to install provider packages, "list" to show available providers',
-  }),
-  packages: Schema.optional(Schema.Array(Schema.String)).annotate({
-    description:
-      'Package names to install. npm names like "@ai-sdk/anthropic" or short names like "anthropic".',
-  }),
-})
-
-type Params = Schema.Schema.Type<typeof Parameters>
-
-const SHORT_NAME_MAP: Record<string, string> = {
-  anthropic: "@ai-sdk/anthropic",
-  openai: "@ai-sdk/openai",
-  "openai-compatible": "@ai-sdk/openai-compatible",
-  google: "@ai-sdk/google",
-  "google-vertex": "@ai-sdk/google-vertex",
-  bedrock: "@ai-sdk/amazon-bedrock",
-  "amazon-bedrock": "@ai-sdk/amazon-bedrock",
-  azure: "@ai-sdk/azure",
-  openrouter: "@openrouter/ai-sdk-provider",
-  groq: "@ai-sdk/groq",
-  deepinfra: "@ai-sdk/deepinfra",
-  gateway: "@ai-sdk/gateway",
-  alibaba: "@ai-sdk/alibaba",
-  cerebras: "@ai-sdk/cerebras",
-  xai: "@ai-sdk/xai",
-  mistral: "@ai-sdk/mistral",
-  cohere: "@ai-sdk/cohere",
-  togetherai: "@ai-sdk/togetherai",
-  perplexity: "@ai-sdk/perplexity",
-  vercel: "@ai-sdk/vercel",
-  gitlab: "gitlab-ai-provider",
-  venice: "venice-ai-sdk-provider",
-}
-
-const KNOWN_PROVIDERS = [
-  { npm: "@saeeol/gateway", label: "Saeeol Gateway (bundled)" },
-  { npm: "@ai-sdk/anthropic", label: "Anthropic (Claude)" },
-  { npm: "@ai-sdk/openai", label: "OpenAI (GPT)" },
-  { npm: "@ai-sdk/openai-compatible", label: "OpenAI Compatible" },
-  { npm: "@ai-sdk/google", label: "Google (Gemini)" },
-  { npm: "@ai-sdk/github-copilot", label: "GitHub Copilot" },
-  { npm: "@ai-sdk/amazon-bedrock", label: "Amazon Bedrock" },
-  { npm: "@ai-sdk/azure", label: "Azure OpenAI" },
-  { npm: "@ai-sdk/google-vertex", label: "Google Vertex AI" },
-  { npm: "@openrouter/ai-sdk-provider", label: "OpenRouter" },
-  { npm: "@ai-sdk/groq", label: "Groq" },
-  { npm: "@ai-sdk/deepinfra", label: "DeepInfra" },
-  { npm: "@ai-sdk/gateway", label: "Vercel AI Gateway" },
-  { npm: "@ai-sdk/alibaba", label: "Alibaba (Qwen)" },
-  { npm: "@ai-sdk/cerebras", label: "Cerebras" },
-  { npm: "@ai-sdk/xai", label: "xAI (Grok)" },
-  { npm: "@ai-sdk/mistral", label: "Mistral" },
-  { npm: "@ai-sdk/cohere", label: "Cohere" },
-  { npm: "@ai-sdk/togetherai", label: "Together AI" },
-  { npm: "@ai-sdk/perplexity", label: "Perplexity" },
-  { npm: "@ai-sdk/vercel", label: "Vercel" },
-]
-
-function resolve(pkg: string) {
-  if (pkg.startsWith("@") || pkg.startsWith("file://")) return pkg
-  return SHORT_NAME_MAP[pkg] ?? pkg
-}
-
-export const PackageTool = Tool.define(
-  "package",
-  Effect.gen(function* () {
-    return {
-      description: [
-        "Manage saeeol provider SDK packages.",
-        "",
-        "Use this tool when the user asks to install additional AI providers,",
-        "or when you detect that a required provider is not available.",
-        "",
-        'Actions: "install" — install provider packages, "list" — show available providers',
-        "",
-        "Short names: anthropic, openai, google, bedrock, azure, openrouter, groq,",
-        "deepinfra, cerebras, xai, mistral, cohere, togetherai, perplexity, vercel",
-      ].join("\n"),
-      parameters: Parameters,
-      execute: (params: Params, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          if (params.action === "list") {
-            const lines = [
-              "Available provider SDKs:",
-              "",
-              ...KNOWN_PROVIDERS.map((p) => `  ${p.label}\n    npm: ${p.npm}`),
-              "",
-              'Install: { action: "install", packages: ["anthropic"] }',
-            ]
-            return { title: "Available Providers", output: lines.join("\n"), metadata: {} }
-          }
-
-          // action === "install"
-          const packages = params.packages
-          if (!packages || packages.length === 0) {
-            return {
-              title: "Package Install",
-              output: "No packages specified. Provide package names in the 'packages' array.",
-              metadata: {},
-            }
-          }
-
-          const resolved = packages.map(resolve)
-
-          yield* ctx.ask({
-            permission: "package",
-            patterns: resolved,
-            always: resolved,
-            metadata: {},
-          })
-
-          const results: string[] = []
-          for (const pkg of resolved) {
-            void Bus.publish(ProviderInstallEvent.Started, {
-              providerID: pkg,
-              pkg,
-            })
-            try {
-              const entry = yield* Effect.promise(() => Npm.add(pkg))
-              if (!entry.entrypoint) {
-                void Bus.publish(ProviderInstallEvent.Failed, {
-                  providerID: pkg,
-                  pkg,
-                  error: "No import entrypoint found",
-                })
-                results.push(`X ${pkg}: no import entrypoint`)
-                continue
-              }
-              void Bus.publish(ProviderInstallEvent.Completed, {
-                providerID: pkg,
-                pkg,
-              })
-              results.push(`OK ${pkg}`)
-            } catch (err) {
-              const msg = err instanceof Error ? err.message : String(err)
-              void Bus.publish(ProviderInstallEvent.Failed, {
-                providerID: pkg,
-                pkg,
-                error: msg,
-              })
-              results.push(`X ${pkg}: ${msg}`)
-            }
-          }
-
-          return {
-            title: "Package Install",
-            output: [
-              `${resolved.length} package(s) processed:`,
-              "",
-              ...results,
-              "",
-              "Installed providers are now available.",
-            ].join("\n"),
-            metadata: {},
-          }
-        }),
-    }
-  }),
-)
+export * from "./integration/package"

package/src/tool/plan.ts

@@ -1,30 +1 @@
-import path from "path"
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-import { Session } from "@/session/session"
-import { InstanceState } from "@/effect/instance-state"
-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
-
-    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))
-          return {
-            title: "Planning complete",
-            output: `Plan is ready at ${plan}. Ending planning turn.`,
-            metadata: { plan },
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)
+export * from "./workflow/plan"

package/src/tool/question.ts

@@ -1,52 +1 @@
-import { Effect, Schema } from "effect"
-import { plural } from "@saeeol/boxes/plural"
-import * as Tool from "./tool"
-import { Question } from "../question"
-import DESCRIPTION from "./question.txt"
-import { SaeeolQuestionTool } from "@/saeeol/tool/question" 
-
-export const Parameters = Schema.Struct({
-  questions: Schema.mutable(Schema.Array(Question.Prompt)).annotate({ description: "Questions to ask" }),
-})
-
-type Metadata = {
-  answers: ReadonlyArray<Question.Answer>
-  dismissed?: boolean 
-}
-
-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* () {
-          // tool result via SaeeolQuestionTool helpers, so Effect.orDie below does not turn
-          // it into a defect and kill the in-flight stream.
-          const answers = yield* question
-            .ask({
-              sessionID: ctx.sessionID,
-              questions: params.questions,
-              tool: ctx.callID ? { messageID: ctx.messageID, callID: ctx.callID } : undefined,
-            })
-            .pipe(SaeeolQuestionTool.catchDismissed)
-          if (SaeeolQuestionTool.isDismissed(answers)) return SaeeolQuestionTool.dismissedResult()
-
-          const formatted = params.questions
-            .map((q, i) => `"${q.question}"="${answers[i]?.length ? answers[i].join(", ") : "Unanswered"}"`)
-            .join(", ")
-
-          return {
-            title: plural(params.questions.length, `Asked {} question`, `Asked {} questions`),
-            output: `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`,
-            metadata: {
-              answers,
-            },
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)
+export * from "./workflow/question"