update

src/api.jl

@@ -0,0 +1,329 @@
+module api
+
+export prompt
+
+using JSON, DataStructures, Dates, UUIDs, HTTP, Random, PrettyPrinting, Serialization,
+      DataFrames, Serde
+using GeneralUtils
+using ..type, ..util, ..llmfunction
+
+# ---------------------------------------------- 100 --------------------------------------------- #
+
+
+
+"""
+Send a message to the agent's input channel.
+Blocks if the input channel buffer is full (capacity 16 by default).
+"""
+function run_agent(agent::yiemAgent, msg)
+  put!(agent.input_ch, msg)
+  return agent
+end
+
+"""
+Take a response from the agent's output channel.
+Blocks until the agent sends a response.
+"""
+function take_response(agent::yiemAgent)
+  return take!(agent.output_ch)
+end
+
+"""
+Send a follow-up message while the agent is still processing.
+Follow-up messages are processed after all input_ch messages
+and before any tool call results are sent.
+"""
+function follow_up(agent::yiemAgent, msg)
+  put!(agent.followUpQueue, msg)
+  return agent
+end
+
+"""
+Gracefully stop the agent.
+Sends a :shutdown signal, waits for the task to finish, then closes all channels.
+"""
+function stop_agent(agent::yiemAgent)
+  put!(agent.input_ch, :shutdown)
+  try
+    fetch(agent._task)
+  catch e
+    if e isa TaskFailedException
+      rethrow(e)
+    end
+  end
+  close(agent.input_ch)
+  close(agent.output_ch)
+  close(agent.followUpQueue)
+  return nothing
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+""" Recursively convert dictionary-like variable (e.g. JSON.Object) into an OrderedDict.
+
+The function walks any nested structure composed of `AbstractDict` (e.g., `JSON.Object`,
+`Dict`, `OrderedDict`) and `AbstractArray` and produces a new tree where
+every dictionary-like node is an `OrderedDict` and every array-like node is a `Vector{Any}`.
+Scalar values (numbers, strings, booleans, `nothing`, etc.) are returned unchanged.
+Does **not** mutate the input; it always allocates new containers.
+
+# Arguments
+- `x`
+  Any Julia value. If `x` is an `AbstractDict` it will be converted to an `OrderedDict`;
+  if it is an `AbstractArray` its elements will be processed recursively.
+
+# Keyword Arguments
+- `keytype::Type=Any`
+  The key type for the output OrderedDict. Use `String` for `OrderedDict{String,Any}`, 
+  `Symbol` for `OrderedDict{Symbol,Any}`, or `Any` to preserve original key types.
+- `sort_order::Union{Nothing, Vector}=nothing`
+  Vector of keys specifying the desired order. Keys are arranged in the specified order 
+  first, followed by any remaining keys.
+
+# Return
+- A newly allocated nested structure composed of `OrderedDict{keytype,Any}` and `Vector{Any}`
+  that mirrors the input shape but uses ordered Julia containers.
+
+# Notes
+- The function treats any `AbstractDict` as a mapping source, so it works with
+  `JSON.Object`, `Dict`, `OrderedDict`, etc.
+- Arrays are returned as `Vector{Any}` with their elements processed recursively.
+
+# Examples
+```jldoctest
+julia> using JSON, DataStructures
+julia> d = Dict(
+            "a" => 4,
+            "b" => 6,
+            "c" => Dict(
+                    "d"=>7, 
+                    :e=>Dict(
+                      "f"=>"hey", 
+                      "g"=>Dict(
+                        "world"=>[1, "2", 3, Dict(:dd=>4.7)]
+                        )
+                      )
+                    )
+          )
+
+julia> jsonstring = JSON.json(d)
+julia> A1 = JSON.parse(jsonstring)  # A1 type is JSON.Object
+julia> A2 = dictify(A1; keytype=String)
+OrderedDict{String,Any} with 3 entries:
+  "a" => 4
+  "b" => 6
+  "c" => OrderedDict("d"=>7, "e"=>Dict("f"=>"hey", "g"=>Dict("world"=>[1, "2", 3, 4.7])))
+
+julia> A3 = dictify(A1; keytype=Symbol)
+OrderedDict{Symbol,Any} with 3 entries:
+  :a => 4
+  :b => 6
+  :c => OrderedDict(:d=>7, :e=>Dict("f"=>"hey", "g"=>Dict("world"=>[1, "2", 3, 4.7])))
+
+julia> B1 = dictify(d; keytype=String)
+OrderedDict{String, Any} with 3 entries:
+```
+
+**With sort_order:**
+```jldoctest
+julia> d = Dict("a"=>1, "b"=>2, "c"=>3)
+julia> dictify(d; sort_order=["c", "a"])
+OrderedDict{String,Int} with 3 entries:
+  "c" => 3
+  "a" => 1
+  "b" => 2
+```
+"""
+function dictify(x::T; keytype::Type=Any, sort_order::Union{Nothing, Vector}=nothing
+  )::OrderedDict where {T<:AbstractDict}
+
+  # this function is example
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+end # module interface
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+