chore: promote dev to main — agent v0.28.0 (Mantis #1216, audit COMPLIANT)

go.work

@@ -7,10 +7,10 @@ use (
 	./go
 	./external/go
 	./external/mcp
-	./external/process
+	./external/process/go
 	./external/store
 	./external/ws
 	./external/io
 	./external/log
-	./external/rag
+	./external/rag/go
 )

go/cmd/core-agent/commands.go

@@ -18,7 +18,7 @@ var applicationPrint = func(format string, args ...any) {
 }
 
 // args := startupArgs()
-// _ = c.Cli().Run("version")
+// result := c.Cli().Run("version")
 func startupArgs() []string {
 	return applyLogLevel(core.FilterArgs(startupArgv()[1:]))
 }

go/cmd/core-agent/main.go

@@ -79,13 +79,13 @@
 }
 
 // app := newCoreAgent()
-// _ = runApp(app, []string{"version"})
+// result := runApp(app, []string{"version"})
 var runApp = func(coreApp *core.Core, cliArgs []string) error {
 	if coreApp == nil {
 		return core.E("main.runApp", "core is required", nil)
 	}
 
 	defer coreApp.ServiceShutdown(context.Background())
 
 	result := coreApp.ServiceStartup(coreApp.Context(), nil)
 	if !result.OK {

go/pkg/agentcompat/agentcompat.go

@@ -15,15 +15,15 @@
 	Models map[string]int
 }
 
-func (c *ConcurrencyLimit) UnmarshalYAML(value *yaml.Node) error {
+func (c *ConcurrencyLimit) UnmarshalYAMLResult(value *yaml.Node) core.Result {
 	var n int
 	if err := value.Decode(&n); err == nil {
 		c.Total = n
-		return nil
+		return core.Ok(nil)
 	}
 	var m map[string]int
 	if err := value.Decode(&m); err != nil {
-		return err
+		return core.Fail(err)
 	}
 	c.Total = m["total"]
 	c.Models = make(map[string]int)
@@ -32,7 +32,18 @@
 			c.Models[key] = entry
 		}
 	}
-	return nil
+	return core.Ok(nil)
+}
+
+func (c *ConcurrencyLimit) UnmarshalYAML(value *yaml.Node) error { // yaml contract
+	result := c.UnmarshalYAMLResult(value)
+	if result.OK {
+		return nil
+	}
+	if err, ok := result.Value.(error); ok {
+		return err
+	}
+	return core.E("ConcurrencyLimit.UnmarshalYAML", "decode failed", nil)
 }
 
 type HTTPStream struct {
@@ -43,11 +54,18 @@
 	Response []byte
 }
 
-func (s *HTTPStream) Send(data []byte) error {
-	request, err := http.NewRequestWithContext(context.Background(), s.Method, s.URL, core.NewReader(string(data)))
-	if err != nil {
-		return err
+func (s *HTTPStream) SendResult(data []byte) core.Result {
+	if s == nil {
+		return core.Fail(core.E("HTTPStream.Send", "stream is required", nil))
+	}
+	if s.Client == nil {
+		return core.Fail(core.E("HTTPStream.Send", "client is required", nil))
+	}
+	requestResult := core.NewHTTPRequestContext(context.Background(), s.Method, s.URL, core.NewReader(string(data)))
+	if !requestResult.OK {
+		return requestResult
 	}
+	request := requestResult.Value.(*core.Request)
 	request.Header.Set("Content-Type", "application/json")
 	request.Header.Set("Accept", "application/json")
 	if s.Token != "" {
@@ -56,25 +74,64 @@
 
 	response, err := s.Client.Do(request)
 	if err != nil {
-		return err
+		return core.Fail(err)
 	}
-	defer func() {
-		_ = response.Body.Close()
-	}()
 
 	readResult := core.ReadAll(response.Body)
 	if !readResult.OK {
 		err, _ := readResult.Value.(error)
-		return core.E("httpStream.Send", "failed to read response", err)
+		return core.Fail(core.E("httpStream.Send", "failed to read response", err))
 	}
 	s.Response = []byte(readResult.Value.(string))
-	return nil
+	return core.Ok(nil)
+}
+
+func (s *HTTPStream) Send(data []byte) error { // core.Stream contract
+	if s == nil || s.Client == nil {
+		panic(core.E("HTTPStream.Send", "stream client is required", nil))
+	}
+	result := s.SendResult(data)
+	if result.OK {
+		return nil
+	}
+	if err, ok := result.Value.(error); ok {
+		return err
+	}
+	return core.E("HTTPStream.Send", "send failed", nil)
+}
+
+func (s *HTTPStream) ReceiveResult() core.Result {
+	if s == nil {
+		return core.Fail(core.E("HTTPStream.Receive", "stream is required", nil))
+	}
+	return core.Ok(s.Response)
+}
+
+func (s *HTTPStream) Receive() ([]byte, error) { // core.Stream contract
+	if s == nil {
+		panic(core.E("HTTPStream.Receive", "stream is required", nil))
+	}
+	result := s.ReceiveResult()
+	if result.OK {
+		return result.Value.([]byte), nil
+	}
+	if err, ok := result.Value.(error); ok {
+		return nil, err
+	}
+	return nil, core.E("HTTPStream.Receive", "receive failed", nil)
 }
 
-func (s *HTTPStream) Receive() ([]byte, error) {
-	return s.Response, nil
+func (s *HTTPStream) CloseResult() core.Result {
+	return core.Ok(nil)
 }
 
-func (s *HTTPStream) Close() error {
-	return nil
+func (s *HTTPStream) Close() error { // core.Stream contract
+	result := s.CloseResult()
+	if result.OK {
+		return nil
+	}
+	if err, ok := result.Value.(error); ok {
+		return err
+	}
+	return core.E("HTTPStream.Close", "close failed", nil)
 }

go/pkg/agentcompat/agentcompat_example_test.go

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: EUPL-1.2
+
+package agentcompat
+
+import (
+	core "dappco.re/go"
+	"gopkg.in/yaml.v3"
+)
+
+func ExampleConcurrencyLimit_UnmarshalYAMLResult() {
+	var node yaml.Node
+	yaml.Unmarshal([]byte("total: 2\ncodex: 1\n"), &node)
+	limit := ConcurrencyLimit{}
+	result := limit.UnmarshalYAMLResult(node.Content[0])
+	core.Println(result.OK, limit.Total, limit.Models["codex"])
+	// Output: true 2 1
+}
+
+func ExampleConcurrencyLimit_UnmarshalYAML() {
+	limit := ConcurrencyLimit{}
+	yaml.Unmarshal([]byte("3\n"), &limit)
+	core.Println(limit.Total)
+	// Output: 3
+}
+
+func ExampleHTTPStream_SendResult() {
+	stream := &HTTPStream{}
+	result := stream.SendResult([]byte(`{"ping":1}`))
+	core.Println(result.OK)
+	// Output: false
+}
+
+func ExampleHTTPStream_Send() {
+	server := core.NewHTTPTestServer(core.HandlerFunc(func(w core.ResponseWriter, r *core.Request) {
+		core.WriteString(w, "ok")
+	}))
+	defer server.Close()
+	stream := &HTTPStream{Client: server.Client(), URL: server.URL, Method: "POST"}
+	err := stream.Send([]byte(`{"ping":1}`))
+	core.Println(err == nil, string(stream.Response))
+	// Output: true ok
+}
+
+func ExampleHTTPStream_ReceiveResult() {
+	stream := &HTTPStream{Response: []byte("ok")}
+	result := stream.ReceiveResult()
+	core.Println(string(result.Value.([]byte)))
+	// Output: ok
+}
+
+func ExampleHTTPStream_Receive() {
+	stream := &HTTPStream{Response: []byte("ok")}
+	data, err := stream.Receive()
+	core.Println(string(data), err == nil)
+	// Output: ok true
+}
+
+func ExampleHTTPStream_CloseResult() {
+	stream := &HTTPStream{}
+	result := stream.CloseResult()
+	core.Println(result.OK)
+	// Output: true
+}
+
+func ExampleHTTPStream_Close() {
+	stream := &HTTPStream{}
+	err := stream.Close()
+	core.Println(err == nil)
+	// Output: true
+}