CodexEx.AppServer.Message (codex_ex v0.1.0)

Copy Markdown View Source

Helpers for protocol-native app-server notifications and server requests.

Summary

Types

hook_run_result()
supported_reply_payload()
t()

Functions

encode_reply_payload(payload)
extract_hook_run(message)
extract_item(message)
extract_text_delta(message)
extract_thread_goal(message)
extract_token_usage(message)
extract_turn(message)
extract_turn_diff(message)
hook_run_item_attributes(hook_run)
item_id(message)
method_name(arg1)
request_id(arg1)
resolved_request_id(message)
supported_reply_payload?(payload)
thread_id(message)
turn_id(message)

Types

hook_run_result()

@type hook_run_result() :: {:ok, map()} | {:error, term()}

supported_reply_payload()

@type supported_reply_payload() ::
  %CodexEx.AppServer.Protocol.Generated.Shared.ToolRequestUserInputResponse{
    answers: term()
  }
  | %CodexEx.AppServer.Protocol.Generated.Shared.McpServerElicitationRequestResponse{
      _meta: term(),
      action: term(),
      content: term()
    }
  | %CodexEx.AppServer.Protocol.Generated.Shared.CommandExecutionRequestApprovalResponse{
      decision: term()
    }
  | %CodexEx.AppServer.Protocol.Generated.Shared.DynamicToolCallResponse{
      content_items: term(),
      success: term()
    }
  | %CodexEx.AppServer.Protocol.Generated.Shared.ExecCommandApprovalResponse{
      decision: term()
    }
  | %CodexEx.AppServer.Protocol.Generated.Shared.FileChangeRequestApprovalResponse{
      decision: term()
    }
  | %CodexEx.AppServer.Protocol.Generated.Shared.ApplyPatchApprovalResponse{
      decision: term()
    }

t()

@type t() ::
  %CodexEx.AppServer.Protocol.Generated.Shared.ServerNotification{
    id: term(),
    method: term(),
    params: term()
  }
  | %CodexEx.AppServer.Protocol.Generated.Shared.ServerRequest{
      id: term(),
      method: term(),
      params: term()
    }
  | %CodexEx.AppServer.Protocol.GenericNotification{
      method: term(),
      params: term()
    }
  | %CodexEx.AppServer.Protocol.GenericServerRequest{
      id: term(),
      method: term(),
      params: term()
    }
  | %CodexEx.AppServer.Protocol.UnmatchedResponse{id: term(), payload: term()}

Functions

encode_reply_payload(payload)

@spec encode_reply_payload(term()) ::
  {:ok, map()} | {:error, {:unsupported_request_reply_payload, term()}}

extract_hook_run(message)

@spec extract_hook_run(term()) :: hook_run_result() | nil

extract_item(message)

@spec extract_item(term()) :: CodexEx.AppServer.ThreadItem.result() | nil

extract_text_delta(message)

@spec extract_text_delta(term()) :: binary() | nil

extract_thread_goal(message)

@spec extract_thread_goal(t()) :: CodexEx.AppServer.ThreadGoal.result() | nil

extract_token_usage(message)

@spec extract_token_usage(t()) :: CodexEx.AppServer.TokenUsage.result() | nil

extract_turn(message)

@spec extract_turn(term()) :: CodexEx.AppServer.Turn.result() | nil

extract_turn_diff(message)

@spec extract_turn_diff(term()) :: binary() | nil

hook_run_item_attributes(hook_run)

@spec hook_run_item_attributes(map()) :: map() | nil

item_id(message)

@spec item_id(term()) :: binary() | nil

method_name(arg1)

@spec method_name(term()) :: binary() | nil

request_id(arg1)

@spec request_id(term()) :: term() | nil

resolved_request_id(message)

@spec resolved_request_id(term()) :: term() | nil

supported_reply_payload?(payload)

@spec supported_reply_payload?(term()) :: boolean()

thread_id(message)

@spec thread_id(term()) :: binary() | nil

turn_id(message)

@spec turn_id(term()) :: binary() | nil