@miaws/miaw 1.18.5 → 1.18.7

package/src/acp/content.ts

@@ -1,250 +0,0 @@
-import type { ContentBlock, ContentChunk, ResourceLink, Role } from "@agentclientprotocol/sdk"
-import path from "node:path"
-import { pathToFileURL } from "node:url"
-import { SessionV1 } from "@miaw/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) {
-        return [{ type: "text", text: 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
-  }
-}

package/src/acp/directory.ts

@@ -1,210 +0,0 @@
-import { Agent } from "@/agent/agent"
-import { Command } from "@/command"
-import { InstanceRef } from "@/effect/instance-ref"
-import { InstanceStore } from "@/project/instance-store"
-import { ProviderV2 } from "@miaw/core/provider"
-import { ModelV2 } from "@miaw/core/model"
-import { Provider } from "@/provider/provider"
-import { Context, Effect, Layer, SynchronizedRef } from "effect"
-import type * as ACPError from "./error"
-
-export type ModelOption = {
-  readonly providerID: ProviderV2.ID
-  readonly providerName: string
-  readonly modelID: ModelV2.ID
-  readonly modelName: string
-}
-
-export type ModeOption = {
-  readonly id: string
-  readonly name: string
-  readonly description?: string
-}
-
-export type ModelVariants = NonNullable<Provider.Model["variants"]>
-
-export type DefaultModel = {
-  readonly providerID: ProviderV2.ID
-  readonly modelID: ModelV2.ID
-}
-
-export type Snapshot = {
-  readonly directory: string
-  readonly providers: Record<ProviderV2.ID, Provider.Info>
-  readonly modelOptions: readonly ModelOption[]
-  readonly variantsByModel: Readonly<Record<string, ModelVariants>>
-  readonly availableModes: readonly ModeOption[]
-  readonly defaultModeID: string
-  readonly availableCommands: readonly Command.Info[]
-  readonly defaultModel?: DefaultModel
-}
-
-export interface LoaderInterface {
-  readonly load: (directory: string) => Effect.Effect<Snapshot, ACPError.Error>
-}
-
-export interface Interface {
-  readonly get: (directory: string) => Effect.Effect<Snapshot, ACPError.Error>
-  readonly refresh: (directory: string) => Effect.Effect<Snapshot, ACPError.Error>
-  readonly variants: (snapshot: Snapshot, model: DefaultModel) => ModelVariants | undefined
-}
-
-export class Loader extends Context.Service<Loader, LoaderInterface>()("@miaw/ACPDirectoryLoader") {}
-
-export class Service extends Context.Service<Service, Interface>()("@miaw/ACPDirectory") {}
-
-export const modelKey = (model: DefaultModel) => `${model.providerID}/${model.modelID}`
-
-export const variants = (snapshot: Snapshot, model: DefaultModel) => snapshot.variantsByModel[modelKey(model)]
-
-export const build = (input: {
-  readonly directory: string
-  readonly providers: Record<ProviderV2.ID, Provider.Info>
-  readonly modes: readonly ModeOption[]
-  readonly defaultModeID: string
-  readonly commands: readonly Command.Info[]
-  readonly defaultModel?: DefaultModel
-}): Snapshot => {
-  const modelOptions = Provider.sort(
-    Object.values(input.providers).flatMap((provider) =>
-      Object.values(provider.models).map((model) => ({
-        id: model.id,
-        providerID: provider.id,
-        providerName: provider.name,
-        modelID: model.id,
-        modelName: model.name,
-      })),
-    ),
-  ).map((model) => ({
-    providerID: model.providerID,
-    providerName: model.providerName,
-    modelID: model.modelID,
-    modelName: model.modelName,
-  }))
-
-  return {
-    directory: input.directory,
-    providers: input.providers,
-    modelOptions,
-    variantsByModel: Object.fromEntries(
-      Object.values(input.providers).flatMap((provider) =>
-        Object.values(provider.models).flatMap((model) =>
-          model.variants ? [[modelKey({ providerID: provider.id, modelID: model.id }), model.variants]] : [],
-        ),
-      ),
-    ),
-    availableModes: input.modes,
-    defaultModeID: input.modes.some((mode) => mode.id === input.defaultModeID)
-      ? input.defaultModeID
-      : (input.modes[0]?.id ?? input.defaultModeID),
-    availableCommands: input.commands,
-    ...(input.defaultModel ? { defaultModel: input.defaultModel } : {}),
-  }
-}
-
-export const loaderLayer = Layer.effect(
-  Loader,
-  Effect.gen(function* () {
-    const store = yield* InstanceStore.Service
-    const provider = yield* Provider.Service
-    const agent = yield* Agent.Service
-    const command = yield* Command.Service
-
-    return Loader.of({
-      load: Effect.fn("ACPDirectoryLoader.load")(function* (directory) {
-        const ctx = yield* store.load({ directory })
-        return yield* Effect.gen(function* () {
-          const providers = yield* provider.list()
-          const [agents, defaultAgent, commands, defaultModel] = yield* Effect.all(
-            [agent.list(), agent.defaultInfo(), command.list(), provider.defaultModel().pipe(Effect.option)],
-            { concurrency: "unbounded" },
-          )
-          return build({
-            directory,
-            providers,
-            modes: agents
-              .filter((item) => item.mode !== "subagent" && item.hidden !== true)
-              .map((item) => ({
-                id: item.name,
-                name: item.name,
-                ...(item.description ? { description: item.description } : {}),
-              })),
-            defaultModeID: defaultAgent.name,
-            commands: commands.toSorted((a, b) => a.name.localeCompare(b.name)),
-            ...(defaultModel._tag === "Some" ? { defaultModel: defaultModel.value } : {}),
-          })
-        }).pipe(Effect.provideService(InstanceRef, ctx))
-      }),
-    })
-  }),
-)
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const loader = yield* Loader
-    const snapshots = yield* SynchronizedRef.make(new Map<string, Effect.Effect<Snapshot, ACPError.Error>>())
-
-    const cached = Effect.fnUntraced(function* (directory: string) {
-      return yield* SynchronizedRef.modifyEffect(
-        snapshots,
-        Effect.fnUntraced(function* (items) {
-          const current = items.get(directory)
-          if (current) return [current, items] as const
-          const next = yield* Effect.cached(
-            loader.load(directory).pipe(
-              Effect.tapError(() =>
-                SynchronizedRef.update(snapshots, (state) => {
-                  const next = new Map(state)
-                  next.delete(directory)
-                  return next
-                }),
-              ),
-            ),
-          )
-          return [next, new Map(items).set(directory, next)] as const
-        }),
-      )
-    })
-
-    const get = Effect.fn("ACPDirectory.get")(function* (directory: string) {
-      return yield* yield* cached(directory)
-    })
-
-    const refresh = Effect.fn("ACPDirectory.refresh")(function* (directory: string) {
-      return yield* SynchronizedRef.modifyEffect(
-        snapshots,
-        Effect.fnUntraced(function* (items) {
-          const next = yield* Effect.cached(
-            loader.load(directory).pipe(
-              Effect.tapError(() =>
-                SynchronizedRef.update(snapshots, (state) => {
-                  const next = new Map(state)
-                  next.delete(directory)
-                  return next
-                }),
-              ),
-            ),
-          )
-          return [next, new Map(items).set(directory, next)] as const
-        }),
-      ).pipe(Effect.flatten)
-    })
-
-    return Service.of({
-      get,
-      refresh,
-      variants,
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(loaderLayer),
-  Layer.provide(Provider.defaultLayer),
-  Layer.provide(Agent.defaultLayer),
-  Layer.provide(Command.defaultLayer),
-  Layer.provide(InstanceStore.defaultLayer),
-)
-
-export * as Directory from "./directory"

package/src/acp/error.ts

@@ -1,90 +0,0 @@
-import { RequestError } from "@agentclientprotocol/sdk"
-import { Schema } from "effect"
-
-export class SessionNotFoundError extends Schema.TaggedErrorClass<SessionNotFoundError>()("ACPSessionNotFoundError", {
-  sessionId: Schema.String,
-}) {}
-
-export class InvalidConfigOptionError extends Schema.TaggedErrorClass<InvalidConfigOptionError>()(
-  "ACPInvalidConfigOptionError",
-  {
-    configId: Schema.String,
-  },
-) {}
-
-export class InvalidModelError extends Schema.TaggedErrorClass<InvalidModelError>()("ACPInvalidModelError", {
-  modelId: Schema.String,
-  providerId: Schema.optional(Schema.String),
-}) {}
-
-export class InvalidEffortError extends Schema.TaggedErrorClass<InvalidEffortError>()("ACPInvalidEffortError", {
-  effort: Schema.String,
-}) {}
-
-export class InvalidModeError extends Schema.TaggedErrorClass<InvalidModeError>()("ACPInvalidModeError", {
-  mode: Schema.String,
-}) {}
-
-export class AuthRequiredError extends Schema.TaggedErrorClass<AuthRequiredError>()("ACPAuthRequiredError", {
-  providerId: Schema.optional(Schema.String),
-}) {}
-
-export class UnknownAuthMethodError extends Schema.TaggedErrorClass<UnknownAuthMethodError>()(
-  "ACPUnknownAuthMethodError",
-  {
-    methodId: Schema.String,
-  },
-) {}
-
-export class UnsupportedOperationError extends Schema.TaggedErrorClass<UnsupportedOperationError>()(
-  "ACPUnsupportedOperationError",
-  {
-    method: Schema.String,
-  },
-) {}
-
-export class ServiceFailureError extends Schema.TaggedErrorClass<ServiceFailureError>()("ACPServiceFailureError", {
-  safeMessage: Schema.String,
-  service: Schema.optional(Schema.String),
-}) {}
-
-export type Error =
-  | SessionNotFoundError
-  | InvalidConfigOptionError
-  | InvalidModelError
-  | InvalidEffortError
-  | InvalidModeError
-  | AuthRequiredError
-  | UnknownAuthMethodError
-  | UnsupportedOperationError
-  | ServiceFailureError
-
-export function toRequestError(error: Error) {
-  switch (error._tag) {
-    case "ACPSessionNotFoundError":
-      return RequestError.invalidParams({ sessionId: error.sessionId }, `session not found: ${error.sessionId}`)
-    case "ACPInvalidConfigOptionError":
-      return RequestError.invalidParams({ configId: error.configId }, `unknown config option: ${error.configId}`)
-    case "ACPInvalidModelError":
-      return RequestError.invalidParams(
-        { providerId: error.providerId, modelId: error.modelId },
-        `model not found: ${error.modelId}`,
-      )
-    case "ACPInvalidEffortError":
-      return RequestError.invalidParams({ effort: error.effort }, `effort not found: ${error.effort}`)
-    case "ACPInvalidModeError":
-      return RequestError.invalidParams({ mode: error.mode }, `mode not found: ${error.mode}`)
-    case "ACPAuthRequiredError":
-      return RequestError.authRequired({ providerId: error.providerId }, "provider authentication required")
-    case "ACPUnknownAuthMethodError":
-      return RequestError.invalidParams({ methodId: error.methodId }, `unknown auth method: ${error.methodId}`)
-    case "ACPUnsupportedOperationError":
-      return RequestError.methodNotFound(error.method)
-    case "ACPServiceFailureError":
-      return RequestError.internalError({ service: error.service }, error.safeMessage)
-  }
-}
-
-export function fromUnknownDefect(_defect: unknown, safeMessage = "Internal service failure") {
-  return new ServiceFailureError({ safeMessage })
-}