Commit cb9a6942363ed7f097c7d1fb075bf3a265fbf5d2 | the-knife

author	Julius Marminge <julius0216@outlook.com> 2026-09-05 10:18:34-07:00
committer	GitHub <noreply@github.com> 2026-09-05 10:18:34-07:00
log	cb9a6942363ed7f097c7d1fb075bf3a265fbf5d2
tree	57aee2c3bb613ab548071fd344129ec5cc04a279
parent	62ed748ac94a73dca1b3eb99b1da52d71ebed247
signature	Signed by PGP key B5690EEEBB952194

refactor(acp): keep protocol implementation exports private (#10165)

4 files changed, 27 insertions(+), 31 deletions(-)

packages
- effect-acp
  - src
    agent.ts
    client.ts
    errors.ts
    rpc.ts

packages/effect-acp/src/agent.ts+1

...	...	@@ -254,6 +254,7 @@ interface AcpCoreAgentRequestHandlers {
254	254
255	255	const decodeCancelNotification = Schema.decodeUnknownEffect(AcpSchema.CancelNotification);
256	256
	257	/** @public Service construction is part of the canonical Effect module API. */
257	258	export const make = Effect.fn("effect-acp/AcpAgent.make")(function* (
258	259	stdio: Stdio.Stdio,
259	260	options: AcpAgentOptions = {},

packages/effect-acp/src/client.ts-5

...	...	@@ -585,11 +585,6 @@ export const make = Effect.fn("effect-acp/AcpClient.make")(function* (
585	585	});
586	586	});
587	587
588		export const layer = (
589		stdio: AcpProtocol.AcpStdio,
590		options: AcpClientOptions = {},
591		): Layer.Layer<AcpClient> => Layer.effect(AcpClient, make(stdio, options));
592
593	588	export const layerChildProcess = (
594	589	handle: ChildProcessSpawner.ChildProcessHandle,
595	590	options: AcpClientOptions = {},

packages/effect-acp/src/errors.ts+5-5

...	...	@@ -3,7 +3,7 @@ import type * as SchemaIssue from "effect/SchemaIssue";
3	3
4	4	import * as AcpSchema from "./_generated/schema.gen.ts";
5	5
6		export const AcpRequestOperation = Schema.Literals([
	6	const AcpRequestOperation = Schema.Literals([
7	7	"decode-extension-request-payload",
8	8	"encode-extension-response",
9	9	"handle-request",
...	...	@@ -11,12 +11,12 @@ export const AcpRequestOperation = Schema.Literals([
11	11	"receive-response",
12	12	"receive-streaming-response",
13	13	]);
14		export type AcpRequestOperation = typeof AcpRequestOperation.Type;
	14	type AcpRequestOperation = typeof AcpRequestOperation.Type;
15	15
16	16	export const AcpRequestId = Schema.Union([Schema.String, Schema.Number]);
17	17	export type AcpRequestId = typeof AcpRequestId.Type;
18	18
19		export const AcpSchemaIssueKind = Schema.Literals([
	19	const AcpSchemaIssueKind = Schema.Literals([
20	20	"Filter",
21	21	"Encoding",
22	22	"Pointer",
...	...	@@ -29,9 +29,9 @@ export const AcpSchemaIssueKind = Schema.Literals([
29	29	"Forbidden",
30	30	"OneOf",
31	31	]);
32		export type AcpSchemaIssueKind = typeof AcpSchemaIssueKind.Type;
	32	type AcpSchemaIssueKind = typeof AcpSchemaIssueKind.Type;
33	33
34		export interface AcpSchemaIssueDiagnostics {
	34	interface AcpSchemaIssueDiagnostics {
35	35	readonly issueCount: number;
36	36	readonly issueKinds: ReadonlyArray<AcpSchemaIssueKind>;
37	37	readonly maximumPathDepth: number;

packages/effect-acp/src/rpc.ts+21-21

...	...	@@ -4,127 +4,127 @@ import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
4	4	import * as AcpSchema from "./_generated/schema.gen.ts";
5	5	import { AGENT_METHODS, CLIENT_METHODS } from "./_generated/meta.gen.ts";
6	6
7		export const InitializeRpc = Rpc.make(AGENT_METHODS.initialize, {
	7	const InitializeRpc = Rpc.make(AGENT_METHODS.initialize, {
8	8	payload: AcpSchema.InitializeRequest,
9	9	success: AcpSchema.InitializeResponse,
10	10	error: AcpSchema.Error,
11	11	});
12	12
13		export const AuthenticateRpc = Rpc.make(AGENT_METHODS.authenticate, {
	13	const AuthenticateRpc = Rpc.make(AGENT_METHODS.authenticate, {
14	14	payload: AcpSchema.AuthenticateRequest,
15	15	success: AcpSchema.AuthenticateResponse,
16	16	error: AcpSchema.Error,
17	17	});
18	18
19		export const LogoutRpc = Rpc.make(AGENT_METHODS.logout, {
	19	const LogoutRpc = Rpc.make(AGENT_METHODS.logout, {
20	20	payload: AcpSchema.LogoutRequest,
21	21	success: AcpSchema.LogoutResponse,
22	22	error: AcpSchema.Error,
23	23	});
24	24
25		export const NewSessionRpc = Rpc.make(AGENT_METHODS.session_new, {
	25	const NewSessionRpc = Rpc.make(AGENT_METHODS.session_new, {
26	26	payload: AcpSchema.NewSessionRequest,
27	27	success: AcpSchema.NewSessionResponse,
28	28	error: AcpSchema.Error,
29	29	});
30	30
31		export const LoadSessionRpc = Rpc.make(AGENT_METHODS.session_load, {
	31	const LoadSessionRpc = Rpc.make(AGENT_METHODS.session_load, {
32	32	payload: AcpSchema.LoadSessionRequest,
33	33	success: AcpSchema.LoadSessionResponse,
34	34	error: AcpSchema.Error,
35	35	});
36	36
37		export const ListSessionsRpc = Rpc.make(AGENT_METHODS.session_list, {
	37	const ListSessionsRpc = Rpc.make(AGENT_METHODS.session_list, {
38	38	payload: AcpSchema.ListSessionsRequest,
39	39	success: AcpSchema.ListSessionsResponse,
40	40	error: AcpSchema.Error,
41	41	});
42	42
43		export const ForkSessionRpc = Rpc.make(AGENT_METHODS.session_fork, {
	43	const ForkSessionRpc = Rpc.make(AGENT_METHODS.session_fork, {
44	44	payload: AcpSchema.ForkSessionRequest,
45	45	success: AcpSchema.ForkSessionResponse,
46	46	error: AcpSchema.Error,
47	47	});
48	48
49		export const ResumeSessionRpc = Rpc.make(AGENT_METHODS.session_resume, {
	49	const ResumeSessionRpc = Rpc.make(AGENT_METHODS.session_resume, {
50	50	payload: AcpSchema.ResumeSessionRequest,
51	51	success: AcpSchema.ResumeSessionResponse,
52	52	error: AcpSchema.Error,
53	53	});
54	54
55		export const CloseSessionRpc = Rpc.make(AGENT_METHODS.session_close, {
	55	const CloseSessionRpc = Rpc.make(AGENT_METHODS.session_close, {
56	56	payload: AcpSchema.CloseSessionRequest,
57	57	success: AcpSchema.CloseSessionResponse,
58	58	error: AcpSchema.Error,
59	59	});
60	60
61		export const PromptRpc = Rpc.make(AGENT_METHODS.session_prompt, {
	61	const PromptRpc = Rpc.make(AGENT_METHODS.session_prompt, {
62	62	payload: AcpSchema.PromptRequest,
63	63	success: AcpSchema.PromptResponse,
64	64	error: AcpSchema.Error,
65	65	});
66	66
67		export const SetSessionModelRpc = Rpc.make(AGENT_METHODS.session_set_model, {
	67	const SetSessionModelRpc = Rpc.make(AGENT_METHODS.session_set_model, {
68	68	payload: AcpSchema.SetSessionModelRequest,
69	69	success: AcpSchema.SetSessionModelResponse,
70	70	error: AcpSchema.Error,
71	71	});
72	72
73		export const SetSessionConfigOptionRpc = Rpc.make(AGENT_METHODS.session_set_config_option, {
	73	const SetSessionConfigOptionRpc = Rpc.make(AGENT_METHODS.session_set_config_option, {
74	74	payload: AcpSchema.SetSessionConfigOptionRequest,
75	75	success: AcpSchema.SetSessionConfigOptionResponse,
76	76	error: AcpSchema.Error,
77	77	});
78	78
79		export const ReadTextFileRpc = Rpc.make(CLIENT_METHODS.fs_read_text_file, {
	79	const ReadTextFileRpc = Rpc.make(CLIENT_METHODS.fs_read_text_file, {
80	80	payload: AcpSchema.ReadTextFileRequest,
81	81	success: AcpSchema.ReadTextFileResponse,
82	82	error: AcpSchema.Error,
83	83	});
84	84
85		export const WriteTextFileRpc = Rpc.make(CLIENT_METHODS.fs_write_text_file, {
	85	const WriteTextFileRpc = Rpc.make(CLIENT_METHODS.fs_write_text_file, {
86	86	payload: AcpSchema.WriteTextFileRequest,
87	87	success: AcpSchema.WriteTextFileResponse,
88	88	error: AcpSchema.Error,
89	89	});
90	90
91		export const RequestPermissionRpc = Rpc.make(CLIENT_METHODS.session_request_permission, {
	91	const RequestPermissionRpc = Rpc.make(CLIENT_METHODS.session_request_permission, {
92	92	payload: AcpSchema.RequestPermissionRequest,
93	93	success: AcpSchema.RequestPermissionResponse,
94	94	error: AcpSchema.Error,
95	95	});
96	96
97		export const ElicitationRpc = Rpc.make(CLIENT_METHODS.session_elicitation, {
	97	const ElicitationRpc = Rpc.make(CLIENT_METHODS.session_elicitation, {
98	98	payload: AcpSchema.ElicitationRequest,
99	99	success: AcpSchema.ElicitationResponse,
100	100	error: AcpSchema.Error,
101	101	});
102	102
103		export const CreateTerminalRpc = Rpc.make(CLIENT_METHODS.terminal_create, {
	103	const CreateTerminalRpc = Rpc.make(CLIENT_METHODS.terminal_create, {
104	104	payload: AcpSchema.CreateTerminalRequest,
105	105	success: AcpSchema.CreateTerminalResponse,
106	106	error: AcpSchema.Error,
107	107	});
108	108
109		export const TerminalOutputRpc = Rpc.make(CLIENT_METHODS.terminal_output, {
	109	const TerminalOutputRpc = Rpc.make(CLIENT_METHODS.terminal_output, {
110	110	payload: AcpSchema.TerminalOutputRequest,
111	111	success: AcpSchema.TerminalOutputResponse,
112	112	error: AcpSchema.Error,
113	113	});
114	114
115		export const ReleaseTerminalRpc = Rpc.make(CLIENT_METHODS.terminal_release, {
	115	const ReleaseTerminalRpc = Rpc.make(CLIENT_METHODS.terminal_release, {
116	116	payload: AcpSchema.ReleaseTerminalRequest,
117	117	success: AcpSchema.ReleaseTerminalResponse,
118	118	error: AcpSchema.Error,
119	119	});
120	120
121		export const WaitForTerminalExitRpc = Rpc.make(CLIENT_METHODS.terminal_wait_for_exit, {
	121	const WaitForTerminalExitRpc = Rpc.make(CLIENT_METHODS.terminal_wait_for_exit, {
122	122	payload: AcpSchema.WaitForTerminalExitRequest,
123	123	success: AcpSchema.WaitForTerminalExitResponse,
124	124	error: AcpSchema.Error,
125	125	});
126	126
127		export const KillTerminalRpc = Rpc.make(CLIENT_METHODS.terminal_kill, {
	127	const KillTerminalRpc = Rpc.make(CLIENT_METHODS.terminal_kill, {
128	128	payload: AcpSchema.KillTerminalRequest,
129	129	success: AcpSchema.KillTerminalResponse,
130	130	error: AcpSchema.Error,