Module: Phronomy::Agent::AsyncEventApi

Included in:
Base
Defined in:
lib/phronomy/agent/async_event_api.rb

Overview

Public Agent execution API. Agent instances are always stateful and all operations are coordinated through Phronomy::Persistence.

Instance Method Summary collapse

Instance Method Details

#approve(execution_id, approval_request_id:, approved: true, config: {}) ⇒ Object 



100
101
102
103
104
105
106
107
108
 
# File 'lib/phronomy/agent/async_event_api.rb', line 100

def approve(execution_id, approval_request_id:, approved: true, config: {})
  _check_scheduler_reentrancy(:approve, :approve_async)
  approve_async(
    execution_id,
    approval_request_id: approval_request_id,
    approved: approved,
    config: config
  ).wait_result
end

#approve_async(execution_id, approval_request_id:, approved: true, config: {}) ⇒ Object 



110
111
112
113
114
115
116
117
 
# File 'lib/phronomy/agent/async_event_api.rb', line 110

def approve_async(execution_id, approval_request_id:, approved: true, config: {})
  execution_coordinator.resume(
    execution_id,
    approval_request_id: approval_request_id,
    approved: approved,
    config: config
  )
end

#invoke(input, thread_id: nil, config: {}, invocation_context: nil, on_event: nil) ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/phronomy/agent/async_event_api.rb', line 8

def invoke(input, thread_id: nil, config: {}, invocation_context: nil, on_event: nil)
  if invocation_context
    thread_id, config = _apply_invocation_context(thread_id, config, invocation_context)
  end
  _check_scheduler_reentrancy(:invoke, :invoke_async)
  trace("agent.invoke", input: input, **_build_caller_meta(config)) do |_span|
    result = invoke_async(
      input,
      thread_id: thread_id,
      config: config,
      on_event: on_event
    ).wait_result
    [result, result[:usage]]
  end
end

#invoke_async(input, thread_id: nil, config: {}, invocation_context: nil, on_tool_approval_required: nil, on_event: nil) ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/phronomy/agent/async_event_api.rb', line 24

def invoke_async(
  input,
  thread_id: nil,
  config: {},
  invocation_context: nil,
  on_tool_approval_required: nil,
  on_event: nil
)
  if invocation_context
    thread_id, config = _apply_invocation_context(thread_id, config, invocation_context)
  end
  approval = _approval_configuration_snapshot(on_tool_approval_required)
  execution_coordinator.start(
    input,
    thread_id: thread_id,
    config: config,
    mode: :invoke,
    approval_policy: approval[:policy],
    approval_listener: approval[:listener],
    on_event: on_event
  )
end

#stream(input, thread_id: nil, config: {}, invocation_context: nil, on_tool_approval_required: nil, on_event: nil, &block) ⇒ Object

Raises:

  • (ArgumentError) 


47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/phronomy/agent/async_event_api.rb', line 47

def stream(
  input,
  thread_id: nil,
  config: {},
  invocation_context: nil,
  on_tool_approval_required: nil,
  on_event: nil,
  &block
)
  listener = resolve_event_listener(on_event, block)
  raise ArgumentError, "stream requires on_event: or a block" unless listener
  if invocation_context
    thread_id, config = _apply_invocation_context(thread_id, config, invocation_context)
  end
  _check_scheduler_reentrancy(:stream, :stream_async)
  trace("agent.stream", input: input, **_build_caller_meta(config)) do |_span|
    result = stream_async(
      input,
      thread_id: thread_id,
      config: config,
      on_tool_approval_required: on_tool_approval_required,
      on_event: listener
    ).wait_result
    [result, result[:usage]]
  end
end

#stream_async(input, thread_id: nil, config: {}, invocation_context: nil, on_tool_approval_required: nil, on_event: nil, &block) ⇒ Object

Raises:

  • (ArgumentError) 


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/phronomy/agent/async_event_api.rb', line 74

def stream_async(
  input,
  thread_id: nil,
  config: {},
  invocation_context: nil,
  on_tool_approval_required: nil,
  on_event: nil,
  &block
)
  listener = resolve_event_listener(on_event, block)
  raise ArgumentError, "stream_async requires on_event: or a block" unless listener
  if invocation_context
    thread_id, config = _apply_invocation_context(thread_id, config, invocation_context)
  end
  approval = _approval_configuration_snapshot(on_tool_approval_required)
  execution_coordinator.start(
    input,
    thread_id: thread_id,
    config: config,
    mode: :stream,
    approval_policy: approval[:policy],
    approval_listener: approval[:listener],
    on_event: listener
  )
end