# Files changed · PR \#10165 · pingdotgg/t3code

[View on GitCafe](https://git.cafe/pingdotgg/t3code/pull/10165/diffs)

Repository: [pingdotgg/t3code](https://git.cafe/pingdotgg/t3code)

Visibility: public

[refactor\(acp\): keep protocol implementation exports private](https://git.cafe/pingdotgg/t3code/pull/10165.md)

Version: 5

Head commit: 913f03875dda49579b78d72ec85471b5c3ad2b7f

Base commit: 62ed748ac94a73dca1b3eb99b1da52d71ebed247

Comparison base: 62ed748ac94a73dca1b3eb99b1da52d71ebed247

Showing up to 20 entries from this revision. If the pull request changes, reopen the first page before continuing.

## packages/effect-acp/src/agent.ts

Status: modified; +1; −0

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

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

Status: modified; +0; −5

```diff
@@ -585,11 +585,6 @@
   });
 });
 
-export const layer = (
-  stdio: AcpProtocol.AcpStdio,
-  options: AcpClientOptions = {},
-): Layer.Layer<AcpClient> => Layer.effect(AcpClient, make(stdio, options));
-
 export const layerChildProcess = (
   handle: ChildProcessSpawner.ChildProcessHandle,
   options: AcpClientOptions = {},
```

## packages/effect-acp/src/errors.ts

Status: modified; +5; −5

```diff
@@ -3,7 +3,7 @@
 
 import * as AcpSchema from "./_generated/schema.gen.ts";
 
-export const AcpRequestOperation = Schema.Literals([
+const AcpRequestOperation = Schema.Literals([
   "decode-extension-request-payload",
   "encode-extension-response",
   "handle-request",
@@ -11,12 +11,12 @@
   "receive-response",
   "receive-streaming-response",
 ]);
+type AcpRequestOperation = typeof AcpRequestOperation.Type;
-export type AcpRequestOperation = typeof AcpRequestOperation.Type;
 
 export const AcpRequestId = Schema.Union([Schema.String, Schema.Number]);
 export type AcpRequestId = typeof AcpRequestId.Type;
 
-export const AcpSchemaIssueKind = Schema.Literals([
+const AcpSchemaIssueKind = Schema.Literals([
   "Filter",
   "Encoding",
   "Pointer",
@@ -29,9 +29,9 @@
   "Forbidden",
   "OneOf",
 ]);
+type AcpSchemaIssueKind = typeof AcpSchemaIssueKind.Type;
-export type AcpSchemaIssueKind = typeof AcpSchemaIssueKind.Type;
 
-export interface AcpSchemaIssueDiagnostics {
+interface AcpSchemaIssueDiagnostics {
   readonly issueCount: number;
   readonly issueKinds: ReadonlyArray<AcpSchemaIssueKind>;
   readonly maximumPathDepth: number;
```

## packages/effect-acp/src/rpc.ts

Status: modified; +21; −21

```diff
@@ -4,127 +4,127 @@
 import * as AcpSchema from "./_generated/schema.gen.ts";
 import { AGENT_METHODS, CLIENT_METHODS } from "./_generated/meta.gen.ts";
 
-export const InitializeRpc = Rpc.make(AGENT_METHODS.initialize, {
+const InitializeRpc = Rpc.make(AGENT_METHODS.initialize, {
   payload: AcpSchema.InitializeRequest,
   success: AcpSchema.InitializeResponse,
   error: AcpSchema.Error,
 });
 
-export const AuthenticateRpc = Rpc.make(AGENT_METHODS.authenticate, {
+const AuthenticateRpc = Rpc.make(AGENT_METHODS.authenticate, {
   payload: AcpSchema.AuthenticateRequest,
   success: AcpSchema.AuthenticateResponse,
   error: AcpSchema.Error,
 });
 
+const LogoutRpc = Rpc.make(AGENT_METHODS.logout, {
-export const LogoutRpc = Rpc.make(AGENT_METHODS.logout, {
   payload: AcpSchema.LogoutRequest,
   success: AcpSchema.LogoutResponse,
   error: AcpSchema.Error,
 });
 
-export const NewSessionRpc = Rpc.make(AGENT_METHODS.session_new, {
+const NewSessionRpc = Rpc.make(AGENT_METHODS.session_new, {
   payload: AcpSchema.NewSessionRequest,
   success: AcpSchema.NewSessionResponse,
   error: AcpSchema.Error,
 });
 
+const LoadSessionRpc = Rpc.make(AGENT_METHODS.session_load, {
-export const LoadSessionRpc = Rpc.make(AGENT_METHODS.session_load, {
   payload: AcpSchema.LoadSessionRequest,
   success: AcpSchema.LoadSessionResponse,
   error: AcpSchema.Error,
 });
 
+const ListSessionsRpc = Rpc.make(AGENT_METHODS.session_list, {
-export const ListSessionsRpc = Rpc.make(AGENT_METHODS.session_list, {
   payload: AcpSchema.ListSessionsRequest,
   success: AcpSchema.ListSessionsResponse,
   error: AcpSchema.Error,
 });
 
+const ForkSessionRpc = Rpc.make(AGENT_METHODS.session_fork, {
-export const ForkSessionRpc = Rpc.make(AGENT_METHODS.session_fork, {
   payload: AcpSchema.ForkSessionRequest,
   success: AcpSchema.ForkSessionResponse,
   error: AcpSchema.Error,
 });
 
-export const ResumeSessionRpc = Rpc.make(AGENT_METHODS.session_resume, {
+const ResumeSessionRpc = Rpc.make(AGENT_METHODS.session_resume, {
   payload: AcpSchema.ResumeSessionRequest,
   success: AcpSchema.ResumeSessionResponse,
   error: AcpSchema.Error,
 });
 
-export const CloseSessionRpc = Rpc.make(AGENT_METHODS.session_close, {
+const CloseSessionRpc = Rpc.make(AGENT_METHODS.session_close, {
   payload: AcpSchema.CloseSessionRequest,
   success: AcpSchema.CloseSessionResponse,
   error: AcpSchema.Error,
 });
 
+const PromptRpc = Rpc.make(AGENT_METHODS.session_prompt, {
-export const PromptRpc = Rpc.make(AGENT_METHODS.session_prompt, {
   payload: AcpSchema.PromptRequest,
   success: AcpSchema.PromptResponse,
   error: AcpSchema.Error,
 });
 
-export const SetSessionModelRpc = Rpc.make(AGENT_METHODS.session_set_model, {
+const SetSessionModelRpc = Rpc.make(AGENT_METHODS.session_set_model, {
   payload: AcpSchema.SetSessionModelRequest,
   success: AcpSchema.SetSessionModelResponse,
   error: AcpSchema.Error,
 });
 
+const SetSessionConfigOptionRpc = Rpc.make(AGENT_METHODS.session_set_config_option, {
-export const SetSessionConfigOptionRpc = Rpc.make(AGENT_METHODS.session_set_config_option, {
   payload: AcpSchema.SetSessionConfigOptionRequest,
   success: AcpSchema.SetSessionConfigOptionResponse,
   error: AcpSchema.Error,
 });
 
-export const ReadTextFileRpc = Rpc.make(CLIENT_METHODS.fs_read_text_file, {
+const ReadTextFileRpc = Rpc.make(CLIENT_METHODS.fs_read_text_file, {
   payload: AcpSchema.ReadTextFileRequest,
   success: AcpSchema.ReadTextFileResponse,
   error: AcpSchema.Error,
 });
 
+const WriteTextFileRpc = Rpc.make(CLIENT_METHODS.fs_write_text_file, {
-export const WriteTextFileRpc = Rpc.make(CLIENT_METHODS.fs_write_text_file, {
   payload: AcpSchema.WriteTextFileRequest,
   success: AcpSchema.WriteTextFileResponse,
   error: AcpSchema.Error,
 });
 
+const RequestPermissionRpc = Rpc.make(CLIENT_METHODS.session_request_permission, {
-export const RequestPermissionRpc = Rpc.make(CLIENT_METHODS.session_request_permission, {
   payload: AcpSchema.RequestPermissionRequest,
   success: AcpSchema.RequestPermissionResponse,
   error: AcpSchema.Error,
 });
 
-export const ElicitationRpc = Rpc.make(CLIENT_METHODS.session_elicitation, {
+const ElicitationRpc = Rpc.make(CLIENT_METHODS.session_elicitation, {
   payload: AcpSchema.ElicitationRequest,
   success: AcpSchema.ElicitationResponse,
   error: AcpSchema.Error,
 });
 
-export const CreateTerminalRpc = Rpc.make(CLIENT_METHODS.terminal_create, {
+const CreateTerminalRpc = Rpc.make(CLIENT_METHODS.terminal_create, {
   payload: AcpSchema.CreateTerminalRequest,
   success: AcpSchema.CreateTerminalResponse,
   error: AcpSchema.Error,
 });
 
+const TerminalOutputRpc = Rpc.make(CLIENT_METHODS.terminal_output, {
-export const TerminalOutputRpc = Rpc.make(CLIENT_METHODS.terminal_output, {
   payload: AcpSchema.TerminalOutputRequest,
   success: AcpSchema.TerminalOutputResponse,
   error: AcpSchema.Error,
 });
 
-export const ReleaseTerminalRpc = Rpc.make(CLIENT_METHODS.terminal_release, {
+const ReleaseTerminalRpc = Rpc.make(CLIENT_METHODS.terminal_release, {
   payload: AcpSchema.ReleaseTerminalRequest,
   success: AcpSchema.ReleaseTerminalResponse,
   error: AcpSchema.Error,
 });
 
+const WaitForTerminalExitRpc = Rpc.make(CLIENT_METHODS.terminal_wait_for_exit, {
-export const WaitForTerminalExitRpc = Rpc.make(CLIENT_METHODS.terminal_wait_for_exit, {
   payload: AcpSchema.WaitForTerminalExitRequest,
   success: AcpSchema.WaitForTerminalExitResponse,
   error: AcpSchema.Error,
 });
 
-export const KillTerminalRpc = Rpc.make(CLIENT_METHODS.terminal_kill, {
+const KillTerminalRpc = Rpc.make(CLIENT_METHODS.terminal_kill, {
   payload: AcpSchema.KillTerminalRequest,
   success: AcpSchema.KillTerminalResponse,
   error: AcpSchema.Error,
```