Official
acp
ACP agents from the ACP registry (Gemini, Cursor, Droid, Kilo, pi, ...), Oh My Pi, and your own entries (custom.json in the plugin's data folder). Agents are discovered at runtime.
The app opens the listing; nothing installs until an agent in your Plugins workspace has read the files and you enable the plugin. In a terminal: dvg install divergence/acp@0.2.5
Permissions in 0.2.5
Take care. This plugin asks for permissions that can do anything your account can. The app asks you to hold Enable for two seconds or to type the plugin's name before it turns on.
Files
wire.ts4.3 KB
// ACP JSON-RPC boundary schemas. ACP is forward compatible, so the
// records are loose while every field consumed by the provider is parsed.
import * as z from "zod";
const unknownRecord = z.looseObject({});
const string = z.string().nullish();
const number = z.number().nullish();
export const capabilities = z.looseObject({
loadSession: z.boolean().optional(),
auth: z.looseObject({ logout: z.unknown().optional(), status: z.unknown().optional() }).nullish(),
promptCapabilities: z
.looseObject({
image: z.boolean().optional(),
audio: z.boolean().optional(),
embeddedContext: z.boolean().optional(),
})
.nullish(),
mcpCapabilities: z.looseObject({ http: z.boolean().optional() }).nullish(),
sessionCapabilities: z
.looseObject({
list: z.unknown().optional(),
fork: z.unknown().optional(),
resume: z.unknown().optional(),
close: z.unknown().optional(),
additionalDirectories: z.unknown().optional(),
systemPrompt: z.unknown().optional(),
options: z.unknown().optional(),
status: z.unknown().optional(),
})
.nullish(),
});
const authMethod = z.looseObject({
id: z.string(),
name: string,
description: string,
type: string,
args: z.array(z.unknown()).nullish(),
});
const agentInfo = z.looseObject({ name: string, title: string, version: string });
export const message = z.looseObject({
sessionId: string,
sessionUpdate: string,
promptId: string,
elicitationId: string,
terminalId: string,
toolCallId: string,
path: string,
content: z.unknown().nullish(),
line: number,
limit: number,
mode: string,
url: string,
command: z.unknown().optional(),
cwd: string,
outputByteLimit: z.unknown().optional(),
args: z.unknown().optional(),
env: z.unknown().optional(),
options: z.array(unknownRecord).nullish(),
toolCall: unknownRecord.nullish(),
requestedSchema: unknownRecord.nullish(),
message: string,
_meta: unknownRecord.nullish(),
});
const catalog = z.looseObject({ currentModeId: string, availableModes: z.array(unknownRecord).nullish() });
const models = z.looseObject({ currentModelId: string, availableModels: z.array(unknownRecord).nullish() });
export const session = z.looseObject({
sessionId: string,
cwd: string,
title: string,
updatedAt: string,
modes: catalog.nullish(),
models: models.nullish(),
configOptions: z.array(unknownRecord).nullish(),
});
export const responseSchemas = {
initialize: z.looseObject({
protocolVersion: z.number().nullish(),
agentCapabilities: capabilities.nullish(),
authMethods: z.array(authMethod).nullish(),
agentInfo: agentInfo.nullish(),
_meta: unknownRecord.nullish(),
}),
"session/new": session,
"session/options": session,
"session/status": z.looseObject({ status: z.string() }),
"auth/status": z.looseObject({ state: z.string() }),
"session/resume": session,
"session/load": session,
"session/fork": session,
"session/list": z.looseObject({ sessions: z.array(session).nullish(), nextCursor: string }),
"session/prompt": z.looseObject({ messageId: string, stopReason: string, usage: unknownRecord.nullish(), error: unknownRecord.nullish() }),
"session/set_mode": z.unknown(),
"session/set_model": z.unknown(),
"session/set_config_option": z.looseObject({ configOptions: z.array(unknownRecord).nullish() }),
"session/close": z.unknown(),
authenticate: z.unknown(),
logout: z.unknown(),
} satisfies Record<string, z.ZodType>;
export const responses: {
[M in keyof typeof responseSchemas]: z.ZodType<z.infer<(typeof responseSchemas)[M]>>;
} = responseSchemas;
export type Message = z.infer<typeof message>;
export type Response<M extends keyof typeof responses> = z.infer<(typeof responses)[M]>;
/// True for the updates that describe a session rather than report work:
/// the only ones worth keeping from before the session is addressable.
export function startupMetadata(update: Message) {
return (
typeof update.sessionUpdate === "string" &&
["current_mode_update", "config_option_update", "available_commands_update", "session_info_update", "notice"].includes(update.sessionUpdate)
);
}
/// The updates that are the conversation itself, as opposed to metadata
/// about the session.
export const TRANSCRIPT_UPDATES = new Set([
"user_message_chunk",
"agent_message_chunk",
"agent_thought_chunk",
"tool_call",
"tool_call_update",
"plan",
]);Versions
| Version | Published | Plugin API | Size | Permissions | Status |
|---|---|---|---|---|---|
| 0.2.5latest | Nov 21, 2026 | >=5 <6 | 134 KB | 6 permissions | Listed |
| 0.2.4 | Nov 16, 2026 | >=5 <6 | 132.8 KB | 6 permissions | Listed |
| 0.2.3 | Nov 11, 2026 | >=5 <6 | 108.9 KB | 6 permissions | Listed |
| 0.2.2 | Nov 9, 2026 | >=5 <6 | 105.6 KB | 6 permissions | Listed |
| 0.2.1 | Oct 27, 2026 | >=2 <4 | 105.3 KB | 6 permissions | Listed |
No comments yet.