anymous 1.3.0 → 1.3.2

package/src/acp/session.ts

@@ -1,232 +0,0 @@
-import type { McpServer } from "@agentclientprotocol/sdk"
-import type { Message, Part } from "@anymous-ai/sdk/v2"
-import { LayerNode } from "@anymous-ai/core/effect/layer-node"
-import type { ProviderV2 } from "@anymous-ai/core/provider"
-import type { ModelV2 } from "@anymous-ai/core/model"
-import { Context, Effect, Layer, Ref } from "effect"
-import * as ACPError from "./error"
-
-export type SelectedModel = {
-  providerID: ProviderV2.ID
-  modelID: ModelV2.ID
-}
-
-export type KnownMessagePartMetadata = {
-  messageId: string
-  partId: string
-  partType?: Part["type"]
-  role?: Message["role"]
-  ignored?: boolean
-  toolCallId?: string
-  metadata?: unknown
-}
-
-export type Info = {
-  id: string
-  cwd: string
-  mcpServers: readonly McpServer[]
-  createdAt: Date
-  model?: SelectedModel
-  variant?: string
-  modeId?: string
-  knownParts: ReadonlyMap<string, KnownMessagePartMetadata>
-}
-
-export type StoreInput = {
-  id: string
-  cwd: string
-  mcpServers?: readonly McpServer[]
-  createdAt?: Date
-  model?: SelectedModel
-  variant?: string
-  modeId?: string
-}
-
-export type RecordPartMetadataInput = {
-  sessionId: string
-  messageId: string
-  partId: string
-  partType?: Part["type"]
-  role?: Message["role"]
-  ignored?: boolean
-  toolCallId?: string
-  metadata?: unknown
-}
-
-export type PartMetadataLookupInput = {
-  sessionId: string
-  messageId: string
-  partId: string
-}
-
-export type Interface = {
-  readonly create: (input: StoreInput) => Effect.Effect<Info>
-  readonly load: (input: StoreInput) => Effect.Effect<Info>
-  readonly list: (cwd?: string) => Effect.Effect<readonly Info[]>
-  readonly get: (sessionId: string) => Effect.Effect<Info, ACPError.SessionNotFoundError>
-  readonly tryGet: (sessionId: string) => Effect.Effect<Info | undefined>
-  readonly remove: (sessionId: string) => Effect.Effect<Info | undefined>
-  readonly setModel: (
-    sessionId: string,
-    model: SelectedModel | undefined,
-  ) => Effect.Effect<Info, ACPError.SessionNotFoundError>
-  readonly getModel: (sessionId: string) => Effect.Effect<SelectedModel | undefined, ACPError.SessionNotFoundError>
-  readonly setVariant: (
-    sessionId: string,
-    variant: string | undefined,
-  ) => Effect.Effect<Info, ACPError.SessionNotFoundError>
-  readonly getVariant: (sessionId: string) => Effect.Effect<string | undefined, ACPError.SessionNotFoundError>
-  readonly setMode: (
-    sessionId: string,
-    modeId: string | undefined,
-  ) => Effect.Effect<Info, ACPError.SessionNotFoundError>
-  readonly getMode: (sessionId: string) => Effect.Effect<string | undefined, ACPError.SessionNotFoundError>
-  readonly recordPartMetadata: (
-    input: RecordPartMetadataInput,
-  ) => Effect.Effect<KnownMessagePartMetadata, ACPError.SessionNotFoundError>
-  readonly getPartMetadata: (
-    input: PartMetadataLookupInput,
-  ) => Effect.Effect<KnownMessagePartMetadata | undefined, ACPError.SessionNotFoundError>
-  readonly tryGetPartMetadata: (input: PartMetadataLookupInput) => Effect.Effect<KnownMessagePartMetadata | undefined>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@anymous/ACP/Session") {}
-
-type State = Map<string, Info>
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const sessions = yield* Ref.make<State>(new Map())
-
-    const store = Effect.fn("ACP.Session.store")(function* (input: StoreInput) {
-      const session = makeSession(input)
-      yield* Ref.update(sessions, (state) => new Map(state).set(session.id, session))
-      return snapshot(session)
-    })
-
-    const tryGet = Effect.fn("ACP.Session.tryGet")(function* (sessionId: string) {
-      const session = (yield* Ref.get(sessions)).get(sessionId)
-      if (!session) return
-      return snapshot(session)
-    })
-
-    const get = Effect.fn("ACP.Session.get")(function* (sessionId: string) {
-      const session = yield* tryGet(sessionId)
-      if (session) return session
-      return yield* new ACPError.SessionNotFoundError({ sessionId })
-    })
-
-    const update = Effect.fn("ACP.Session.update")(function* (sessionId: string, fn: (session: Info) => Info) {
-      const result = yield* Ref.modify(sessions, (state) => {
-        const session = state.get(sessionId)
-        if (!session) return [undefined, state] as const
-        const next = fn(session)
-        return [snapshot(next), new Map(state).set(sessionId, next)] as const
-      })
-      if (result) return result
-      return yield* new ACPError.SessionNotFoundError({ sessionId })
-    })
-
-    const remove = Effect.fn("ACP.Session.remove")(function* (sessionId: string) {
-      return yield* Ref.modify(sessions, (state) => {
-        const session = state.get(sessionId)
-        if (!session) return [undefined, state] as const
-        const next = new Map(state)
-        next.delete(sessionId)
-        return [snapshot(session), next] as const
-      })
-    })
-
-    const setModel: Interface["setModel"] = Effect.fn("ACP.Session.setModel")((sessionId, model) =>
-      update(sessionId, (session) => ({ ...session, model })),
-    )
-
-    const setVariant: Interface["setVariant"] = Effect.fn("ACP.Session.setVariant")((sessionId, variant) =>
-      update(sessionId, (session) => ({ ...session, variant })),
-    )
-
-    const setMode: Interface["setMode"] = Effect.fn("ACP.Session.setMode")((sessionId, modeId) =>
-      update(sessionId, (session) => ({ ...session, modeId })),
-    )
-
-    const recordPartMetadata: Interface["recordPartMetadata"] = Effect.fn("ACP.Session.recordPartMetadata")((input) => {
-      const metadata = {
-        messageId: input.messageId,
-        partId: input.partId,
-        partType: input.partType,
-        role: input.role,
-        ignored: input.ignored,
-        toolCallId: input.toolCallId,
-        metadata: input.metadata,
-      }
-      return update(input.sessionId, (session) => ({
-        ...session,
-        knownParts: new Map(session.knownParts).set(partMetadataKey(input), metadata),
-      })).pipe(Effect.as(metadata))
-    })
-
-    return Service.of({
-      create: store,
-      load: store,
-      list: Effect.fn("ACP.Session.list")(function* (cwd?: string) {
-        return [...(yield* Ref.get(sessions)).values()]
-          .filter((session) => !cwd || session.cwd === cwd)
-          .map(snapshot)
-          .toSorted((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
-      }),
-      get,
-      tryGet,
-      remove,
-      setModel,
-      getModel: Effect.fn("ACP.Session.getModel")(function* (sessionId) {
-        return (yield* get(sessionId)).model
-      }),
-      setVariant,
-      getVariant: Effect.fn("ACP.Session.getVariant")(function* (sessionId) {
-        return (yield* get(sessionId)).variant
-      }),
-      setMode,
-      getMode: Effect.fn("ACP.Session.getMode")(function* (sessionId) {
-        return (yield* get(sessionId)).modeId
-      }),
-      recordPartMetadata,
-      getPartMetadata: Effect.fn("ACP.Session.getPartMetadata")(function* (input) {
-        return (yield* get(input.sessionId)).knownParts.get(partMetadataKey(input))
-      }),
-      tryGetPartMetadata: Effect.fn("ACP.Session.tryGetPartMetadata")(function* (input) {
-        return (yield* tryGet(input.sessionId))?.knownParts.get(partMetadataKey(input))
-      }),
-    })
-  }),
-)
-
-export const node = LayerNode.make({ service: Service, layer, deps: [] })
-
-function makeSession(input: StoreInput): Info {
-  return {
-    id: input.id,
-    cwd: input.cwd,
-    mcpServers: [...(input.mcpServers ?? [])],
-    createdAt: input.createdAt ? new Date(input.createdAt) : new Date(),
-    model: input.model,
-    variant: input.variant,
-    modeId: input.modeId,
-    knownParts: new Map(),
-  }
-}
-
-function snapshot(session: Info): Info {
-  return {
-    ...session,
-    mcpServers: [...session.mcpServers],
-    createdAt: new Date(session.createdAt),
-    knownParts: new Map(session.knownParts),
-  }
-}
-
-function partMetadataKey(input: { messageId: string; partId: string }) {
-  return `${input.messageId}:${input.partId}`
-}
-
-export * as ACPSession from "./session"

package/src/acp/tool.ts

@@ -1,364 +0,0 @@
-import { isAbsolute, resolve } from "path"
-import type { ToolCall, ToolCallContent, ToolCallLocation, ToolCallUpdate, ToolKind } from "@agentclientprotocol/sdk"
-
-export type ToolInput = Record<string, unknown>
-
-export type ToolAttachment = {
-  readonly mime?: string
-  readonly url?: string
-  readonly [key: string]: unknown
-}
-
-export type CompletedToolState = {
-  readonly status: "completed"
-  readonly input: ToolInput
-  readonly output: string
-  readonly metadata?: unknown
-  readonly attachments?: ReadonlyArray<ToolAttachment>
-}
-
-export type RunningToolState = {
-  readonly status: "running"
-  readonly input: ToolInput
-  readonly title?: string
-}
-
-export type ErrorToolState = {
-  readonly status: "error"
-  readonly input: ToolInput
-  readonly error: string
-  readonly metadata?: unknown
-}
-
-export type ImageAttachment = {
-  readonly mimeType: string
-  readonly data: string
-}
-
-export function toToolKind(toolName: string): ToolKind {
-  const tool = toolName.toLocaleLowerCase()
-
-  switch (tool) {
-    case "bash":
-    case "shell":
-      return "execute"
-
-    case "webfetch":
-      return "fetch"
-
-    case "edit":
-    case "apply_patch":
-    case "patch":
-    case "write":
-      return "edit"
-
-    case "grep":
-    case "glob":
-    case "context":
-    case "context7_resolve_library_id":
-    case "context7_get_library_docs":
-      return "search"
-
-    case "read":
-      return "read"
-
-    case "task":
-      return "think"
-
-    default:
-      return "other"
-  }
-}
-
-export function toLocations(toolName: string, input: ToolInput, cwd?: string): ToolCallLocation[] {
-  const tool = toolName.toLocaleLowerCase()
-
-  switch (tool) {
-    case "bash":
-    case "shell": {
-      const workdir = shellWorkdir(input, cwd)
-      return workdir ? [{ path: workdir }] : []
-    }
-
-    case "read":
-    case "edit":
-    case "write":
-      return locationFrom(input.filePath ?? input.filepath)
-
-    case "external_directory":
-      return locationFrom(input.filePath ?? input.filepath, input.parentDir, input.directories)
-
-    case "grep":
-    case "glob":
-    case "context":
-    case "context7_resolve_library_id":
-    case "context7_get_library_docs":
-      return locationFrom(input.path)
-
-    default:
-      return []
-  }
-}
-
-export function completedToolContent(toolName: string, state: CompletedToolState): ToolCallContent[] {
-  const text =
-    toolName.toLocaleLowerCase() === "read" ? (readDisplayText(state.metadata) ?? state.output) : state.output
-  const content: ToolCallContent[] = [
-    {
-      type: "content",
-      content: {
-        type: "text",
-        text,
-      },
-    },
-  ]
-
-  if (toToolKind(toolName) === "edit") {
-    content.push(...diffContent(state.input))
-  }
-
-  content.push(...imageContents(state.attachments ?? []))
-  return content
-}
-
-export function pendingToolCall(input: {
-  readonly toolCallId: string
-  readonly toolName: string
-  readonly state: { readonly input: ToolInput; readonly title?: string }
-  readonly cwd?: string
-}): ToolCall {
-  return {
-    toolCallId: input.toolCallId,
-    title: toolTitle(input.toolName, input.state.input, input.state.title),
-    kind: toToolKind(input.toolName),
-    status: "pending",
-    locations: toLocations(input.toolName, input.state.input, input.cwd),
-    rawInput: rawInput(input.toolName, input.state.input, input.cwd),
-  }
-}
-
-export function runningToolUpdate(input: {
-  readonly toolCallId: string
-  readonly toolName: string
-  readonly state: RunningToolState
-  readonly output?: string
-  readonly cwd?: string
-}): ToolCallUpdate {
-  const content = input.output
-    ? [
-        {
-          type: "content" as const,
-          content: {
-            type: "text" as const,
-            text: input.output,
-          },
-        },
-      ]
-    : undefined
-
-  return {
-    toolCallId: input.toolCallId,
-    status: "in_progress",
-    kind: toToolKind(input.toolName),
-    title: toolTitle(input.toolName, input.state.input, input.state.title),
-    locations: toLocations(input.toolName, input.state.input, input.cwd),
-    rawInput: rawInput(input.toolName, input.state.input, input.cwd),
-    ...(content ? { content } : {}),
-  }
-}
-
-export function duplicateRunningToolUpdate(input: {
-  readonly toolCallId: string
-  readonly toolName: string
-  readonly state: RunningToolState
-  readonly cwd?: string
-}): ToolCallUpdate {
-  return {
-    toolCallId: input.toolCallId,
-    status: "in_progress",
-    kind: toToolKind(input.toolName),
-    title: toolTitle(input.toolName, input.state.input, input.state.title),
-    locations: toLocations(input.toolName, input.state.input, input.cwd),
-    rawInput: rawInput(input.toolName, input.state.input, input.cwd),
-  }
-}
-
-export function completedToolUpdate(input: {
-  readonly toolCallId: string
-  readonly toolName: string
-  readonly state: CompletedToolState & { readonly title?: string }
-  readonly cwd?: string
-}): ToolCallUpdate {
-  return {
-    toolCallId: input.toolCallId,
-    status: "completed",
-    ...(input.state.title ? { title: input.state.title } : {}),
-    content: completedToolContent(input.toolName, input.state),
-    rawOutput: completedToolRawOutput(input.state),
-  }
-}
-
-export function errorToolUpdate(input: {
-  readonly toolCallId: string
-  readonly toolName: string
-  readonly state: ErrorToolState
-  readonly cwd?: string
-}): ToolCallUpdate {
-  return {
-    toolCallId: input.toolCallId,
-    status: "failed",
-    kind: toToolKind(input.toolName),
-    title: toolTitle(input.toolName, input.state.input, undefined),
-    locations: toLocations(input.toolName, input.state.input, input.cwd),
-    rawInput: rawInput(input.toolName, input.state.input, input.cwd),
-    content: [
-      {
-        type: "content",
-        content: {
-          type: "text",
-          text: input.state.error,
-        },
-      },
-    ],
-    rawOutput: {
-      error: input.state.error,
-      metadata: input.state.metadata,
-    },
-  }
-}
-
-export function completedToolRawOutput(state: CompletedToolState) {
-  return {
-    output: state.output,
-    ...(state.metadata !== undefined ? { metadata: state.metadata } : {}),
-    ...(state.attachments?.length ? { attachments: state.attachments } : {}),
-  }
-}
-
-export function imageContents(attachments: ReadonlyArray<ToolAttachment>): ToolCallContent[] {
-  return extractImageAttachments(attachments).map((attachment): ToolCallContent => {
-    return {
-      type: "content",
-      content: {
-        type: "image",
-        mimeType: attachment.mimeType,
-        data: attachment.data,
-      },
-    }
-  })
-}
-
-export function extractImageAttachments(attachments: ReadonlyArray<ToolAttachment>): ImageAttachment[] {
-  return attachments.flatMap((attachment): ImageAttachment[] => {
-    const data = dataUrlImage(attachment)
-    return data ? [data] : []
-  })
-}
-
-export function shellOutputSnapshot(state: { readonly metadata?: unknown }) {
-  if (!state.metadata || typeof state.metadata !== "object") return undefined
-  return stringValue((state.metadata as Record<string, unknown>).output)
-}
-
-// For shell tools, surface the actual command as the title so it stays visible
-// before output lands; non-shell tools keep their model-provided title.
-function toolTitle(toolName: string, input: ToolInput, fallback: string | undefined) {
-  if (isShell(toolName)) return shellCommand(input) ?? fallback ?? toolName
-  return fallback || toolName
-}
-
-// Enrich shell rawInput with the resolved working directory so clients can show
-// where the command runs, unless the model already specified one.
-function rawInput(toolName: string, input: ToolInput, cwd?: string): ToolInput {
-  if (!isShell(toolName)) return input
-  if (input.cwd || input.workdir) return input
-  const workdir = shellWorkdir(input, cwd)
-  return workdir ? { ...input, cwd: workdir } : input
-}
-
-function shellWorkdir(input: ToolInput, cwd?: string) {
-  const explicit = stringValue(input.workdir) ?? stringValue(input.cwd)
-  return resolvePath(explicit, cwd) ?? cwd
-}
-
-function resolvePath(value: string | undefined, cwd?: string) {
-  if (!value) return undefined
-  if (isAbsolute(value)) return value
-  return resolve(cwd ?? process.cwd(), value)
-}
-
-function shellCommand(input: ToolInput) {
-  return stringValue(input.command) ?? stringValue(input.cmd)
-}
-
-function isShell(toolName: string) {
-  const tool = toolName.toLocaleLowerCase()
-  return tool === "bash" || tool === "shell"
-}
-
-export const mapToolKind = toToolKind
-export const extractLocations = toLocations
-export const buildCompletedToolContent = completedToolContent
-export const buildCompletedRawOutput = completedToolRawOutput
-export const extractShellOutputSnapshot = shellOutputSnapshot
-export const buildPendingToolCall = pendingToolCall
-export const buildRunningToolUpdate = runningToolUpdate
-export const buildDuplicateRunningToolUpdate = duplicateRunningToolUpdate
-export const buildCompletedToolUpdate = completedToolUpdate
-export const buildErrorToolUpdate = errorToolUpdate
-
-function locationFrom(...values: unknown[]): ToolCallLocation[] {
-  return Array.from(
-    new Set(
-      values.flatMap((value): string[] => {
-        if (Array.isArray(value)) {
-          return value.filter((item): item is string => typeof item === "string" && item.length > 0)
-        }
-        const path = stringValue(value)
-        return path ? [path] : []
-      }),
-    ),
-    (path) => ({ path }),
-  )
-}
-
-function diffContent(input: ToolInput): ToolCallContent[] {
-  const oldText = stringValue(input.oldString)
-  const newText = stringValue(input.newString) ?? stringValue(input.content)
-  if (oldText === undefined || newText === undefined) return []
-
-  return [
-    {
-      type: "diff",
-      path: stringValue(input.filePath) ?? "",
-      oldText,
-      newText,
-    },
-  ]
-}
-
-function readDisplayText(metadata: unknown) {
-  if (!metadata || typeof metadata !== "object") return undefined
-  const display = (metadata as Record<string, unknown>).display
-  if (!display || typeof display !== "object") return undefined
-  const info = display as Record<string, unknown>
-  if (info.type === "file") return stringValue(info.text)
-  if (info.type === "directory" && Array.isArray(info.entries)) {
-    return info.entries.filter((item): item is string => typeof item === "string").join("\n")
-  }
-  return undefined
-}
-
-function dataUrlImage(attachment: ToolAttachment) {
-  const match = stringValue(attachment.url)?.match(/^data:([^;,]+)(?:;[^,]*)*;base64,(.*)$/)
-  const mime = match?.[1] ?? stringValue(attachment.mime)
-  if (!mime?.startsWith("image/")) return undefined
-
-  const data = match?.[2]
-  if (data === undefined) return undefined
-  return { mimeType: mime, data }
-}
-
-function stringValue(value: unknown) {
-  return typeof value === "string" ? value : undefined
-}