client_gen.go

// Code generated by acp-go-generator; DO NOT EDIT.

package acp

import (
	"context"
	"encoding/json"
)

func (c *ClientSideConnection) handle(ctx context.Context, method string, params json.RawMessage) (any, *RequestError) {
	switch method {
	case ClientMethodElicitationComplete:
		var p UnstableCompleteElicitationNotification
		if err := json.Unmarshal(params, &p); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := p.Validate(); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		exp, ok := c.client.(interface {
			UnstableCompleteElicitation(context.Context, UnstableCompleteElicitationNotification) error
		})
		if !ok {
			return nil, NewMethodNotFound(method)
		}
		if err := exp.UnstableCompleteElicitation(ctx, p); err != nil {
			return nil, toReqErr(err)
		}
		return nil, nil
	case ClientMethodElicitationCreate:
		var p UnstableCreateElicitationRequest
		if err := json.Unmarshal(params, &p); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := p.Validate(); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		exp, ok := c.client.(interface {
			UnstableCreateElicitation(context.Context, UnstableCreateElicitationRequest) (UnstableCreateElicitationResponse, error)
		})
		if !ok {
			return nil, NewMethodNotFound(method)
		}
		resp, err := exp.UnstableCreateElicitation(ctx, p)
		if err != nil {
			return nil, toReqErr(err)
		}
		return resp, nil
	case ClientMethodFsReadTextFile:
		var p ReadTextFileRequest
		if err := json.Unmarshal(params, &p); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := p.Validate(); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		resp, err := c.client.ReadTextFile(ctx, p)
		if err != nil {
			return nil, toReqErr(err)
		}
		return resp, nil
	case ClientMethodFsWriteTextFile:
		var p WriteTextFileRequest
		if err := json.Unmarshal(params, &p); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := p.Validate(); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		resp, err := c.client.WriteTextFile(ctx, p)
		if err != nil {
			return nil, toReqErr(err)
		}
		return resp, nil
	case ClientMethodMcpConnect:
		var p UnstableConnectMcpRequest
		if err := json.Unmarshal(params, &p); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := p.Validate(); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		exp, ok := c.client.(interface {
			UnstableConnectMcp(context.Context, UnstableConnectMcpRequest) (UnstableConnectMcpResponse, error)
		})
		if !ok {
			return nil, NewMethodNotFound(method)
		}
		resp, err := exp.UnstableConnectMcp(ctx, p)
		if err != nil {
			return nil, toReqErr(err)
		}
		return resp, nil
	case ClientMethodMcpDisconnect:
		var p UnstableDisconnectMcpRequest
		if err := json.Unmarshal(params, &p); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := p.Validate(); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		exp, ok := c.client.(interface {
			UnstableDisconnectMcp(context.Context, UnstableDisconnectMcpRequest) (UnstableDisconnectMcpResponse, error)
		})
		if !ok {
			return nil, NewMethodNotFound(method)
		}
		resp, err := exp.UnstableDisconnectMcp(ctx, p)
		if err != nil {
			return nil, toReqErr(err)
		}
		return resp, nil
	case ClientMethodSessionRequestPermission:
		var p RequestPermissionRequest
		if err := json.Unmarshal(params, &p); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := p.Validate(); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		resp, err := c.client.RequestPermission(ctx, p)
		if err != nil {
			return nil, toReqErr(err)
		}
		return resp, nil
	case ClientMethodSessionUpdate:
		var p SessionNotification
		if err := json.Unmarshal(params, &p); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := p.Validate(); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := c.client.SessionUpdate(ctx, p); err != nil {
			return nil, toReqErr(err)
		}
		return nil, nil
	case ClientMethodTerminalCreate:
		var p CreateTerminalRequest
		if err := json.Unmarshal(params, &p); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := p.Validate(); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		resp, err := c.client.CreateTerminal(ctx, p)
		if err != nil {
			return nil, toReqErr(err)
		}
		return resp, nil
	case ClientMethodTerminalKill:
		var p KillTerminalRequest
		if err := json.Unmarshal(params, &p); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := p.Validate(); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		resp, err := c.client.KillTerminal(ctx, p)
		if err != nil {
			return nil, toReqErr(err)
		}
		return resp, nil
	case ClientMethodTerminalOutput:
		var p TerminalOutputRequest
		if err := json.Unmarshal(params, &p); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := p.Validate(); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		resp, err := c.client.TerminalOutput(ctx, p)
		if err != nil {
			return nil, toReqErr(err)
		}
		return resp, nil
	case ClientMethodTerminalRelease:
		var p ReleaseTerminalRequest
		if err := json.Unmarshal(params, &p); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := p.Validate(); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		resp, err := c.client.ReleaseTerminal(ctx, p)
		if err != nil {
			return nil, toReqErr(err)
		}
		return resp, nil
	case ClientMethodTerminalWaitForExit:
		var p WaitForTerminalExitRequest
		if err := json.Unmarshal(params, &p); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		if err := p.Validate(); err != nil {
			return nil, NewInvalidParams(map[string]any{"error": err.Error()})
		}
		resp, err := c.client.WaitForTerminalExit(ctx, p)
		if err != nil {
			return nil, toReqErr(err)
		}
		return resp, nil
	default:
		return nil, NewMethodNotFound(method)
	}
}
func (c *ClientSideConnection) Authenticate(ctx context.Context, params AuthenticateRequest) (AuthenticateResponse, error) {
	resp, err := SendRequest[AuthenticateResponse](c.conn, ctx, AgentMethodAuthenticate, params)
	return resp, err
}
func (c *ClientSideConnection) UnstableDidChangeDocument(ctx context.Context, params UnstableDidChangeDocumentNotification) error {
	return c.conn.SendNotification(ctx, AgentMethodDocumentDidChange, params)
}
func (c *ClientSideConnection) UnstableDidCloseDocument(ctx context.Context, params UnstableDidCloseDocumentNotification) error {
	return c.conn.SendNotification(ctx, AgentMethodDocumentDidClose, params)
}
func (c *ClientSideConnection) UnstableDidFocusDocument(ctx context.Context, params UnstableDidFocusDocumentNotification) error {
	return c.conn.SendNotification(ctx, AgentMethodDocumentDidFocus, params)
}
func (c *ClientSideConnection) UnstableDidOpenDocument(ctx context.Context, params UnstableDidOpenDocumentNotification) error {
	return c.conn.SendNotification(ctx, AgentMethodDocumentDidOpen, params)
}
func (c *ClientSideConnection) UnstableDidSaveDocument(ctx context.Context, params UnstableDidSaveDocumentNotification) error {
	return c.conn.SendNotification(ctx, AgentMethodDocumentDidSave, params)
}
func (c *ClientSideConnection) Initialize(ctx context.Context, params InitializeRequest) (InitializeResponse, error) {
	resp, err := SendRequest[InitializeResponse](c.conn, ctx, AgentMethodInitialize, params)
	return resp, err
}
func (c *ClientSideConnection) UnstableLogout(ctx context.Context, params UnstableLogoutRequest) (UnstableLogoutResponse, error) {
	resp, err := SendRequest[UnstableLogoutResponse](c.conn, ctx, AgentMethodLogout, params)
	return resp, err
}
func (c *ClientSideConnection) UnstableAcceptNes(ctx context.Context, params UnstableAcceptNesNotification) error {
	return c.conn.SendNotification(ctx, AgentMethodNesAccept, params)
}
func (c *ClientSideConnection) UnstableCloseNes(ctx context.Context, params UnstableCloseNesRequest) (UnstableCloseNesResponse, error) {
	resp, err := SendRequest[UnstableCloseNesResponse](c.conn, ctx, AgentMethodNesClose, params)
	return resp, err
}
func (c *ClientSideConnection) UnstableRejectNes(ctx context.Context, params UnstableRejectNesNotification) error {
	return c.conn.SendNotification(ctx, AgentMethodNesReject, params)
}
func (c *ClientSideConnection) UnstableStartNes(ctx context.Context, params UnstableStartNesRequest) (UnstableStartNesResponse, error) {
	resp, err := SendRequest[UnstableStartNesResponse](c.conn, ctx, AgentMethodNesStart, params)
	return resp, err
}
func (c *ClientSideConnection) UnstableSuggestNes(ctx context.Context, params UnstableSuggestNesRequest) (UnstableSuggestNesResponse, error) {
	resp, err := SendRequest[UnstableSuggestNesResponse](c.conn, ctx, AgentMethodNesSuggest, params)
	return resp, err
}
func (c *ClientSideConnection) UnstableDisableProviders(ctx context.Context, params UnstableDisableProvidersRequest) (UnstableDisableProvidersResponse, error) {
	resp, err := SendRequest[UnstableDisableProvidersResponse](c.conn, ctx, AgentMethodProvidersDisable, params)
	return resp, err
}
func (c *ClientSideConnection) UnstableListProviders(ctx context.Context, params UnstableListProvidersRequest) (UnstableListProvidersResponse, error) {
	resp, err := SendRequest[UnstableListProvidersResponse](c.conn, ctx, AgentMethodProvidersList, params)
	return resp, err
}
func (c *ClientSideConnection) UnstableSetProviders(ctx context.Context, params UnstableSetProvidersRequest) (UnstableSetProvidersResponse, error) {
	resp, err := SendRequest[UnstableSetProvidersResponse](c.conn, ctx, AgentMethodProvidersSet, params)
	return resp, err
}
func (c *ClientSideConnection) Cancel(ctx context.Context, params CancelNotification) error {
	return c.conn.SendNotification(ctx, AgentMethodSessionCancel, params)
}
func (c *ClientSideConnection) CloseSession(ctx context.Context, params CloseSessionRequest) (CloseSessionResponse, error) {
	resp, err := SendRequest[CloseSessionResponse](c.conn, ctx, AgentMethodSessionClose, params)
	return resp, err
}
func (c *ClientSideConnection) UnstableForkSession(ctx context.Context, params UnstableForkSessionRequest) (UnstableForkSessionResponse, error) {
	resp, err := SendRequest[UnstableForkSessionResponse](c.conn, ctx, AgentMethodSessionFork, params)
	return resp, err
}
func (c *ClientSideConnection) ListSessions(ctx context.Context, params ListSessionsRequest) (ListSessionsResponse, error) {
	resp, err := SendRequest[ListSessionsResponse](c.conn, ctx, AgentMethodSessionList, params)
	return resp, err
}
func (c *ClientSideConnection) LoadSession(ctx context.Context, params LoadSessionRequest) (LoadSessionResponse, error) {
	resp, err := SendRequest[LoadSessionResponse](c.conn, ctx, AgentMethodSessionLoad, params)
	return resp, err
}
func (c *ClientSideConnection) NewSession(ctx context.Context, params NewSessionRequest) (NewSessionResponse, error) {
	resp, err := SendRequest[NewSessionResponse](c.conn, ctx, AgentMethodSessionNew, params)
	return resp, err
}
func (c *ClientSideConnection) Prompt(ctx context.Context, params PromptRequest) (PromptResponse, error) {
	resp, err := SendRequest[PromptResponse](c.conn, ctx, AgentMethodSessionPrompt, params)
	if err != nil {
		if ctx.Err() != nil {
			_ = c.Cancel(context.Background(), CancelNotification{SessionId: params.SessionId})
		}
	}
	return resp, err
}
func (c *ClientSideConnection) ResumeSession(ctx context.Context, params ResumeSessionRequest) (ResumeSessionResponse, error) {
	resp, err := SendRequest[ResumeSessionResponse](c.conn, ctx, AgentMethodSessionResume, params)
	return resp, err
}
func (c *ClientSideConnection) SetSessionConfigOption(ctx context.Context, params SetSessionConfigOptionRequest) (SetSessionConfigOptionResponse, error) {
	resp, err := SendRequest[SetSessionConfigOptionResponse](c.conn, ctx, AgentMethodSessionSetConfigOption, params)
	return resp, err
}
func (c *ClientSideConnection) SetSessionMode(ctx context.Context, params SetSessionModeRequest) (SetSessionModeResponse, error) {
	resp, err := SendRequest[SetSessionModeResponse](c.conn, ctx, AgentMethodSessionSetMode, params)
	return resp, err
}
func (c *ClientSideConnection) UnstableSetSessionModel(ctx context.Context, params UnstableSetSessionModelRequest) (UnstableSetSessionModelResponse, error) {
	resp, err := SendRequest[UnstableSetSessionModelResponse](c.conn, ctx, AgentMethodSessionSetModel, params)
	return resp, err
}