anymous 1.2.7 → 1.3.1

package/src/account/schema.ts

@@ -1,99 +0,0 @@
-import { Schema } from "effect"
-import type * as HttpClientError from "effect/unstable/http/HttpClientError"
-
-export const AccountID = Schema.String.pipe(Schema.brand("AccountID"))
-export type AccountID = Schema.Schema.Type<typeof AccountID>
-
-export const OrgID = Schema.String.pipe(Schema.brand("OrgID"))
-export type OrgID = Schema.Schema.Type<typeof OrgID>
-
-export const AccessToken = Schema.String.pipe(Schema.brand("AccessToken"))
-export type AccessToken = Schema.Schema.Type<typeof AccessToken>
-
-export const RefreshToken = Schema.String.pipe(Schema.brand("RefreshToken"))
-export type RefreshToken = Schema.Schema.Type<typeof RefreshToken>
-
-export const DeviceCode = Schema.String.pipe(Schema.brand("DeviceCode"))
-export type DeviceCode = Schema.Schema.Type<typeof DeviceCode>
-
-export const UserCode = Schema.String.pipe(Schema.brand("UserCode"))
-export type UserCode = Schema.Schema.Type<typeof UserCode>
-
-export class Info extends Schema.Class<Info>("Account")({
-  id: AccountID,
-  email: Schema.String,
-  url: Schema.String,
-  active_org_id: Schema.NullOr(OrgID),
-}) {}
-
-export class Org extends Schema.Class<Org>("Org")({
-  id: OrgID,
-  name: Schema.String,
-}) {}
-
-export class AccountRepoError extends Schema.TaggedErrorClass<AccountRepoError>()("AccountRepoError", {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect()),
-}) {}
-
-export class AccountServiceError extends Schema.TaggedErrorClass<AccountServiceError>()("AccountServiceError", {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect()),
-}) {}
-
-export class AccountTransportError extends Schema.TaggedErrorClass<AccountTransportError>()("AccountTransportError", {
-  method: Schema.String,
-  url: Schema.String,
-  description: Schema.optional(Schema.String),
-  cause: Schema.optional(Schema.Defect()),
-}) {
-  static fromHttpClientError(error: HttpClientError.TransportError): AccountTransportError {
-    return new AccountTransportError({
-      method: error.request.method,
-      url: error.request.url,
-      description: error.description,
-      cause: error.cause,
-    })
-  }
-
-  override get message(): string {
-    return [
-      `Could not reach ${this.method} ${this.url}.`,
-      `This failed before the server returned an HTTP response.`,
-      this.description,
-      `Check your network, proxy, or VPN configuration and try again.`,
-    ]
-      .filter(Boolean)
-      .join("\n")
-  }
-}
-
-export type AccountError = AccountRepoError | AccountServiceError | AccountTransportError
-
-export class Login extends Schema.Class<Login>("Login")({
-  code: DeviceCode,
-  user: UserCode,
-  url: Schema.String,
-  server: Schema.String,
-  expiry: Schema.Duration,
-  interval: Schema.Duration,
-}) {}
-
-export class PollSuccess extends Schema.TaggedClass<PollSuccess>()("PollSuccess", {
-  email: Schema.String,
-}) {}
-
-export class PollPending extends Schema.TaggedClass<PollPending>()("PollPending", {}) {}
-
-export class PollSlow extends Schema.TaggedClass<PollSlow>()("PollSlow", {}) {}
-
-export class PollExpired extends Schema.TaggedClass<PollExpired>()("PollExpired", {}) {}
-
-export class PollDenied extends Schema.TaggedClass<PollDenied>()("PollDenied", {}) {}
-
-export class PollError extends Schema.TaggedClass<PollError>()("PollError", {
-  cause: Schema.Defect(),
-}) {}
-
-export const PollResult = Schema.Union([PollSuccess, PollPending, PollSlow, PollExpired, PollDenied, PollError])
-export type PollResult = Schema.Schema.Type<typeof PollResult>

package/src/account/url.ts

@@ -1,8 +0,0 @@
-export const normalizeServerUrl = (input: string): string => {
-  const url = new URL(input)
-  url.search = ""
-  url.hash = ""
-
-  const pathname = url.pathname.replace(/\/+$/, "")
-  return pathname.length === 0 ? url.origin : `${url.origin}${pathname}`
-}

package/src/acp/agent.ts

@@ -1,95 +0,0 @@
-import {
-  RequestError,
-  type Agent as ACPAgent,
-  type AgentSideConnection,
-  type AuthenticateRequest,
-  type CancelNotification,
-  type CloseSessionRequest,
-  type ForkSessionRequest,
-  type InitializeRequest,
-  type ListSessionsRequest,
-  type LoadSessionRequest,
-  type NewSessionRequest,
-  type PromptRequest,
-  type ResumeSessionRequest,
-  type SetSessionConfigOptionRequest,
-  type SetSessionModelRequest,
-  type SetSessionModeRequest,
-} from "@agentclientprotocol/sdk"
-import { Effect } from "effect"
-import type { anymousClient } from "@anymous-ai/sdk/v2"
-import * as ACPError from "./error"
-import * as ACPService from "./service"
-
-export function init({ sdk: _sdk }: { sdk: anymousClient }) {
-  return {
-    create: (connection: AgentSideConnection) => {
-      return new Agent(ACPService.make({ sdk: _sdk, connection }))
-    },
-  }
-}
-
-export class Agent implements ACPAgent {
-  constructor(private readonly service: ACPService.Interface) {}
-
-  initialize(params: InitializeRequest) {
-    return run(this.service.initialize(params))
-  }
-
-  authenticate(params: AuthenticateRequest) {
-    return run(this.service.authenticate(params))
-  }
-
-  newSession(params: NewSessionRequest) {
-    return run(this.service.newSession(params))
-  }
-
-  loadSession(params: LoadSessionRequest) {
-    return run(this.service.loadSession(params))
-  }
-
-  listSessions(params: ListSessionsRequest) {
-    return run(this.service.listSessions(params))
-  }
-
-  resumeSession(params: ResumeSessionRequest) {
-    return run(this.service.resumeSession(params))
-  }
-
-  closeSession(params: CloseSessionRequest) {
-    return run(this.service.closeSession(params))
-  }
-
-  unstable_forkSession(params: ForkSessionRequest) {
-    return run(this.service.forkSession(params))
-  }
-
-  setSessionConfigOption(params: SetSessionConfigOptionRequest) {
-    return run(this.service.setSessionConfigOption(params))
-  }
-
-  setSessionMode(params: SetSessionModeRequest) {
-    return run(this.service.setSessionMode(params))
-  }
-
-  unstable_setSessionModel(params: SetSessionModelRequest) {
-    return run(this.service.setSessionModel(params))
-  }
-
-  prompt(params: PromptRequest) {
-    return run(this.service.prompt(params))
-  }
-
-  cancel(params: CancelNotification) {
-    return run(this.service.cancel(params))
-  }
-}
-
-function run<A>(effect: Effect.Effect<A, ACPService.Error>) {
-  return Effect.runPromise(effect.pipe(Effect.mapError(ACPError.toRequestError))).catch((defect: unknown) => {
-    if (defect instanceof RequestError) throw defect
-    throw ACPError.toRequestError(ACPError.fromUnknownDefect(defect))
-  })
-}
-
-export * as ACP from "./agent"

package/src/acp/config-option.ts

@@ -1,203 +0,0 @@
-import type { SessionConfigOption } from "@agentclientprotocol/sdk"
-
-export const DEFAULT_VARIANT_VALUE = "default"
-
-export type ConfigOptionModel = {
-  id: string
-  name: string
-  variants?: Record<string, Record<string, unknown>>
-}
-
-export type ConfigOptionProvider = {
-  id: string
-  name: string
-  models: Record<string, ConfigOptionModel>
-}
-
-export type ConfigOptionMode = {
-  id: string
-  name: string
-  description?: string
-}
-
-export type ModelSelection = {
-  model: {
-    providerID: string
-    modelID: string
-  }
-  variant?: string
-}
-
-export function buildModelSelectOption(input: {
-  providers: readonly ConfigOptionProvider[]
-  currentModel: ModelSelection["model"]
-  currentVariant?: string
-  includeVariants?: boolean
-}): SessionConfigOption {
-  return {
-    id: "model",
-    name: "Model",
-    category: "model",
-    type: "select",
-    currentValue: formatCurrentModelId({
-      model: input.currentModel,
-      variant: input.currentVariant,
-      variants: variantsForModel(input.providers, input.currentModel),
-      includeVariant: input.includeVariants ?? false,
-    }),
-    options: buildModelSelectOptions(input.providers, { includeVariants: input.includeVariants ?? false }),
-  }
-}
-
-export function buildEffortSelectOption(input: {
-  variants: readonly string[]
-  currentVariant?: string
-}): SessionConfigOption | undefined {
-  if (input.variants.length === 0) return undefined
-
-  return {
-    id: "effort",
-    name: "Effort",
-    description: "Available effort levels for this model",
-    category: "thought_level",
-    type: "select",
-    currentValue: selectVariant(input.currentVariant, input.variants),
-    options: input.variants.map((variant) => ({
-      value: variant,
-      name: formatVariantName(variant),
-    })),
-  }
-}
-
-export function buildModeSelectOption(input: {
-  modes: readonly ConfigOptionMode[]
-  currentModeId: string
-}): SessionConfigOption {
-  return {
-    id: "mode",
-    name: "Session Mode",
-    category: "mode",
-    type: "select",
-    currentValue: input.currentModeId,
-    options: input.modes.map((mode) => ({
-      value: mode.id,
-      name: mode.name,
-      ...(mode.description ? { description: mode.description } : {}),
-    })),
-  }
-}
-
-export function buildConfigOptions(input: {
-  providers: readonly ConfigOptionProvider[]
-  currentModel: ModelSelection["model"]
-  currentVariant?: string
-  includeModelVariants?: boolean
-  modes?: readonly ConfigOptionMode[]
-  currentModeId?: string
-}): SessionConfigOption[] {
-  const variants = variantsForModel(input.providers, input.currentModel)
-  const effort = buildEffortSelectOption({ variants, currentVariant: input.currentVariant })
-
-  return [
-    buildModelSelectOption({
-      providers: input.providers,
-      currentModel: input.currentModel,
-      currentVariant: input.currentVariant,
-      includeVariants: input.includeModelVariants ?? false,
-    }),
-    ...(effort ? [effort] : []),
-    ...(input.modes && input.currentModeId
-      ? [buildModeSelectOption({ modes: input.modes, currentModeId: input.currentModeId })]
-      : []),
-  ]
-}
-
-export function parseModelSelection(modelId: string, providers: readonly ConfigOptionProvider[]): ModelSelection {
-  const provider = providers.find((item) => modelId.startsWith(`${item.id}/`))
-  if (provider) {
-    const modelID = modelId.slice(provider.id.length + 1)
-    if (provider.models[modelID]) {
-      return { model: { providerID: provider.id, modelID } }
-    }
-
-    const separator = modelID.lastIndexOf("/")
-    if (separator > -1) {
-      const baseModelID = modelID.slice(0, separator)
-      const variant = modelID.slice(separator + 1)
-      if (provider.models[baseModelID]?.variants?.[variant]) {
-        return { model: { providerID: provider.id, modelID: baseModelID }, variant }
-      }
-    }
-
-    return { model: { providerID: provider.id, modelID } }
-  }
-
-  const separator = modelId.indexOf("/")
-  if (separator === -1) {
-    return { model: { providerID: modelId, modelID: "" } }
-  }
-
-  return {
-    model: {
-      providerID: modelId.slice(0, separator),
-      modelID: modelId.slice(separator + 1),
-    },
-  }
-}
-
-export function formatCurrentModelId(input: {
-  model: ModelSelection["model"]
-  variant?: string
-  variants?: readonly string[]
-  includeVariant?: boolean
-}) {
-  const base = `${input.model.providerID}/${input.model.modelID}`
-  if (!input.includeVariant || !input.variants?.length) return base
-  return `${base}/${selectVariant(input.variant, input.variants)}`
-}
-
-export function formatVariantName(variant: string) {
-  return variant
-    .split(/[_-]/)
-    .map((part) => (part ? part.charAt(0).toUpperCase() + part.slice(1) : part))
-    .join(" ")
-}
-
-function buildModelSelectOptions(
-  providers: readonly ConfigOptionProvider[],
-  options: { includeVariants: boolean },
-): Array<{ value: string; name: string }> {
-  return providers.flatMap((provider) =>
-    Object.values(provider.models)
-      .sort((a, b) => a.name.localeCompare(b.name))
-      .flatMap((model) => {
-        const base = {
-          value: `${provider.id}/${model.id}`,
-          name: `${provider.name}/${model.name}`,
-        }
-        if (!options.includeVariants || !model.variants) return [base]
-
-        return [
-          base,
-          ...Object.keys(model.variants)
-            .filter((variant) => variant !== DEFAULT_VARIANT_VALUE)
-            .map((variant) => ({
-              value: `${provider.id}/${model.id}/${variant}`,
-              name: `${provider.name}/${model.name} (${formatVariantName(variant)})`,
-            })),
-        ]
-      }),
-  )
-}
-
-function variantsForModel(providers: readonly ConfigOptionProvider[], model: ModelSelection["model"]) {
-  return Object.keys(
-    providers.find((provider) => provider.id === model.providerID)?.models[model.modelID]?.variants ?? {},
-  )
-}
-
-function selectVariant(variant: string | undefined, variants: readonly string[]) {
-  if (variant && variants.includes(variant)) return variant
-  if (variants.includes(DEFAULT_VARIANT_VALUE)) return DEFAULT_VARIANT_VALUE
-  return variants[0]
-}

package/src/acp/content.ts

@@ -1,269 +0,0 @@
-import type { ContentBlock, ContentChunk, ResourceLink, Role } from "@agentclientprotocol/sdk"
-import path from "node:path"
-import { fileURLToPath, pathToFileURL } from "node:url"
-import { SessionV1 } from "@anymous-ai/core/v1/session"
-
-export type PromptPart = SessionV1.TextPartInput | SessionV1.FilePartInput
-
-export type ReplayPart =
-  | {
-      type: "text"
-      text: string
-      synthetic?: boolean
-      ignored?: boolean
-    }
-  | {
-      type: "file"
-      url: string
-      mime: string
-      filename?: string
-    }
-  | {
-      type: "reasoning"
-      text: string
-    }
-
-export function promptContentToParts(content: readonly ContentBlock[]): PromptPart[] {
-  return content.flatMap(contentBlockToParts)
-}
-
-export function contentBlockToParts(block: ContentBlock): PromptPart[] {
-  switch (block.type) {
-    case "text":
-      return [
-        {
-          type: "text",
-          text: block.text,
-          ...audienceFlags(block.annotations?.audience ?? undefined),
-        },
-      ]
-
-    case "image":
-      if (block.data) {
-        return [
-          {
-            type: "file",
-            url: `data:${block.mimeType};base64,${block.data}`,
-            filename: filenameFromUri(block.uri ?? undefined) ?? "image",
-            mime: block.mimeType,
-          },
-        ]
-      }
-      if (block.uri?.startsWith("data:")) {
-        return [
-          {
-            type: "file",
-            url: block.uri,
-            filename: filenameFromUri(block.uri) ?? "image",
-            mime: block.mimeType,
-          },
-        ]
-      }
-      if (block.uri?.startsWith("http://") || block.uri?.startsWith("https://")) {
-        return [
-          {
-            type: "file",
-            url: block.uri,
-            filename: filenameFromUri(block.uri) ?? "image",
-            mime: block.mimeType,
-          },
-        ]
-      }
-      return []
-
-    case "resource_link":
-      return [resourceLinkToPart(block)]
-
-    case "resource":
-      if ("text" in block.resource) {
-        try {
-          const parsed = new URL(block.resource.uri)
-          if (parsed.protocol === "file:") {
-            const line = parsed.hash.match(/^#L(\d+)/)?.[1]
-            let filepath: string
-            try {
-              filepath = fileURLToPath(parsed)
-            } catch {
-              filepath = decodeURIComponent(parsed.pathname)
-            }
-            if (path.sep === "\\") filepath = filepath.replace(/\\/g, "/")
-            return [
-              {
-                type: "text",
-                text: `[${filepath}${line ? `:${line}` : ""}]\n${block.resource.text}`,
-              },
-            ]
-          }
-        } catch {}
-        return [{ type: "text", text: `[${block.resource.uri}]\n${block.resource.text}` }]
-      }
-      if (block.resource.mimeType) {
-        return [
-          {
-            type: "file",
-            url: block.resource.uri.startsWith("data:")
-              ? block.resource.uri
-              : `data:${block.resource.mimeType};base64,${block.resource.blob}`,
-            filename: filenameFromUri(block.resource.uri) ?? "file",
-            mime: block.resource.mimeType,
-          },
-        ]
-      }
-      return []
-
-    default:
-      return []
-  }
-}
-
-export function partsToContentChunks(parts: readonly ReplayPart[]): ContentChunk[] {
-  return parts.flatMap(partToContentChunks)
-}
-
-export function partToContentChunks(part: ReplayPart): ContentChunk[] {
-  switch (part.type) {
-    case "text":
-      if (!part.text) return []
-      return [
-        {
-          content: {
-            type: "text",
-            text: part.text,
-            ...partAudience(part),
-          },
-        },
-      ]
-
-    case "file":
-      return filePartToContentChunks(part)
-
-    case "reasoning":
-      if (!part.text) return []
-      return [
-        {
-          content: {
-            type: "text",
-            text: part.text,
-          },
-        },
-      ]
-  }
-}
-
-function resourceLinkToPart(link: ResourceLink): PromptPart {
-  const parsed = uriToFilePart(link.uri, link.mimeType ?? "text/plain", link.name)
-  if (parsed.type === "file") return parsed
-  return { type: "text", text: parsed.text }
-}
-
-function uriToFilePart(
-  uri: string,
-  mime: string,
-  filename?: string,
-): SessionV1.FilePartInput | SessionV1.TextPartInput {
-  try {
-    if (uri.startsWith("file://")) {
-      return {
-        type: "file",
-        url: uri,
-        filename: filename ?? filenameFromUri(uri) ?? "file",
-        mime,
-      }
-    }
-    if (uri.startsWith("zed://")) {
-      const pathname = new URL(uri).searchParams.get("path")
-      if (pathname) {
-        return {
-          type: "file",
-          url: pathToFileURL(pathname).href,
-          filename: filename ?? (path.basename(pathname) || "file"),
-          mime,
-        }
-      }
-    }
-    return { type: "text", text: uri }
-  } catch {
-    return { type: "text", text: uri }
-  }
-}
-
-function filePartToContentChunks(part: Extract<ReplayPart, { type: "file" }>): ContentChunk[] {
-  if (part.url.startsWith("file://")) {
-    return [
-      {
-        content: {
-          type: "resource_link",
-          uri: part.url,
-          name: part.filename ?? "file",
-          mimeType: part.mime,
-        },
-      },
-    ]
-  }
-  if (!part.url.startsWith("data:")) return []
-
-  const data = decodeDataUrl(part.url)
-  if (!data) return []
-  if (data.mime.startsWith("image/")) {
-    return [
-      {
-        content: {
-          type: "image",
-          mimeType: data.mime,
-          data: data.base64,
-          uri: pathToFileURL(part.filename ?? "image").href,
-        },
-      },
-    ]
-  }
-
-  return [
-    {
-      content: {
-        type: "resource",
-        resource:
-          data.mime.startsWith("text/") || data.mime === "application/json"
-            ? {
-                uri: pathToFileURL(part.filename ?? "file").href,
-                mimeType: data.mime,
-                text: Buffer.from(data.base64, "base64").toString("utf8"),
-              }
-            : {
-                uri: pathToFileURL(part.filename ?? "file").href,
-                mimeType: data.mime,
-                blob: data.base64,
-              },
-      },
-    },
-  ]
-}
-
-function decodeDataUrl(url: string) {
-  const match = /^data:([^;]+);base64,(.*)$/.exec(url)
-  if (!match) return
-  return { mime: match[1], base64: match[2] }
-}
-
-function audienceFlags(audience: readonly Role[] | null | undefined) {
-  if (audience?.length === 1 && audience[0] === "assistant") return { synthetic: true }
-  if (audience?.length === 1 && audience[0] === "user") return { ignored: true }
-  return {}
-}
-
-function partAudience(part: Extract<ReplayPart, { type: "text" }>) {
-  const audience: Role[] | undefined = part.synthetic ? ["assistant"] : part.ignored ? ["user"] : undefined
-  if (!audience) return {}
-  return { annotations: { audience } }
-}
-
-function filenameFromUri(uri: string | undefined) {
-  if (!uri) return
-  if (uri.startsWith("data:")) return
-  try {
-    const parsed = new URL(uri)
-    const name = path.basename(parsed.pathname)
-    return name || undefined
-  } catch {
-    return path.basename(uri) || undefined
-  }
-}