diff --git a/internal/plugin/cabi/loader.c b/internal/plugin/cabi/loader.c new file mode 100644 index 0000000..7c13312 --- /dev/null +++ b/internal/plugin/cabi/loader.c @@ -0,0 +1,75 @@ +// HomeAgent C ABI loader — C implementation (compiled alongside Go code via cgo) + +#include +#include +#include + +#define HOMEAGENT_ABI_VERSION 1 + +// PluginAPI — provided by the plugin +typedef struct { + int version; int version_min; + int (*init_plugin)(char*, char*, char**); + int (*start_plugin)(void*, int, char**); + int (*stop_plugin)(char**); + int (*invoke_tool)(char*, char*, char**, char**); + int (*invoke_stage)(char*, char*, char**); + int (*invoke_output)(char*, char*, char*, char**); + void (*free_string)(char*); +} plugin_api_t; + +// CoreAPI — provided by the core +typedef struct { + int version; int version_min; + int (*dispatch)(int, void*, char*, char*, char*, int, int, char**, char**); + void* ctx; +} core_api_t; + +// Forward declare Go dispatch function +extern int go_core_dispatch(int, void*, char*, char*, char*, int, int, char**, char**); + +// Bridge function called by CoreAPI.dispatch +static int dispatch_bridge(int id, void* ctx, char* s1, char* s2, char* s3, int i1, int i2, char** r, char** e) { + return go_core_dispatch(id, ctx, s1, s2, s3, i1, i2, r, e); +} + +// Create a CoreAPI struct +core_api_t* make_core_api(void) { + core_api_t* api = (core_api_t*)malloc(sizeof(core_api_t)); + if (!api) return NULL; + api->version = HOMEAGENT_ABI_VERSION; + api->version_min = HOMEAGENT_ABI_VERSION; + api->dispatch = dispatch_bridge; + api->ctx = NULL; + return api; +} + +void free_core_api(core_api_t* api) { free(api); } + +// dlopen helpers +typedef void* lib_handle; + +lib_handle lib_open(const char* path) { + return dlopen(path, RTLD_NOW | RTLD_LOCAL); +} + +plugin_api_t* lib_get_api(lib_handle h) { + plugin_api_t* (*fn)(void); + *(void**)(&fn) = dlsym(h, "plugin_init"); + if (!fn) return NULL; + return fn(); +} + +void lib_close(lib_handle h) { dlclose(h); } +char* lib_err(void) { return dlerror(); } + +void api_free_string(plugin_api_t* api, char* ptr) { + if (api && api->free_string) api->free_string(ptr); +} + +int call_init_plugin(plugin_api_t* api, char* name, char* config, char** err) { return api->init_plugin(name, config, err); } +int call_start_plugin(plugin_api_t* api, void* core, int ver, char** err) { return api->start_plugin(core, ver, err); } +int call_stop_plugin(plugin_api_t* api, char** err) { return api->stop_plugin(err); } +int call_invoke_tool(plugin_api_t* api, char* n, char* a, char** r, char** e) { return api->invoke_tool(n, a, r, e); } +int call_invoke_stage(plugin_api_t* api, char* s, char* c, char** e) { return api->invoke_stage(s, c, e); } +int call_invoke_output(plugin_api_t* api, char* c, char* m, char* p, char** e) { return api->invoke_output(c, m, p, e); } diff --git a/internal/plugin/cabi/loader.go b/internal/plugin/cabi/loader.go index 68c5d19..05cfb6e 100644 --- a/internal/plugin/cabi/loader.go +++ b/internal/plugin/cabi/loader.go @@ -2,14 +2,13 @@ package cabi /* #cgo LDFLAGS: -ldl -#include #include -#include -// PluginAPI struct (mirrors plugin ABI) +#define HOMEAGENT_ABI_VERSION 1 + +// PluginAPI — provided by the plugin via plugin_init() typedef struct { - int version; - int version_min; + int version; int version_min; int (*init_plugin)(char*, char*, char**); int (*start_plugin)(void*, int, char**); int (*stop_plugin)(char**); @@ -17,116 +16,88 @@ typedef struct { int (*invoke_stage)(char*, char*, char**); int (*invoke_output)(char*, char*, char*, char**); void (*free_string)(char*); - int (*get_tool_defs)(char**); - int (*get_stages)(char**); - int (*get_channels)(char**); } plugin_api_t; -// CoreAPI struct (implemented by core, passed to plugin) +// CoreAPI — provided by the core via start_plugin() typedef struct { - int version; - int version_min; - int (*register_tool)(char*, char*, char**); - int (*register_stage)(char*, int, char**); - int (*register_output_channel)(char*, int, char*, int, char**); - int (*register_plugin_api)(char*, char**); - int (*inject_text)(char*, char*, char*, char**); - int (*inject_interrupt_text)(char*, char*, char*, char**); - int (*inject_text_no_memory)(char*, char*, char*, char**); - int (*set_auto_restart)(int, char**); - int (*memory_recall)(char*, int, char**, char**); - int (*memory_commit)(char*, char**); - int (*memory_introspect)(char**, char**); - int (*memory_merge)(char*, char*, char**); - int (*memory_purge)(char*, int, char**); - int (*doc_query)(char*, int, char**, char**); - int (*knowledge_search)(char*, int, char**, char**); - int (*settings_get)(char*, char**, char**); - int (*settings_set)(char*, char*, char**); - int (*settings_register_def)(char*, char**); - int (*llm_list_sources)(char**, char**); - int (*llm_set_source)(char*, char**); - int (*social_get_person)(char*, char**, char**); - int (*social_get_network)(char*, int, char**, char**); - int (*subscribe)(char*, int, char**); - int (*unsubscribe)(char*, int, char**); - void (*free_string)(char*); + int version; int version_min; + int (*dispatch)(int, void*, char*, char*, char*, int, int, char**, char**); + void* ctx; } core_api_t; -// libHandle wraps a dlopen handle -typedef void* libHandle; - -libHandle lib_open(const char* path) { - return dlopen(path, RTLD_NOW | RTLD_LOCAL); -} - -plugin_api_t* lib_get_api(libHandle h) { - plugin_api_t* (*fn)(void); - *(void**)(&fn) = dlsym(h, "plugin_init"); - if (!fn) return NULL; - return fn(); -} - -void lib_close(libHandle h) { - dlclose(h); -} - -char* lib_get_error(void) { - return dlerror(); -} - -void api_free_string(plugin_api_t* api, char* ptr) { - if (api && api->free_string) api->free_string(ptr); -} - -int call_init_plugin(plugin_api_t* api, char* name, char* config, char** err) { return api->init_plugin(name, config, err); } -int call_start_plugin(plugin_api_t* api, void* core, int ver, char** err) { return api->start_plugin(core, ver, err); } -int call_stop_plugin(plugin_api_t* api, char** err) { return api->stop_plugin(err); } -int call_get_tool_defs(plugin_api_t* api, char** r) { return api->get_tool_defs(r); } -int call_get_stages(plugin_api_t* api, char** r) { return api->get_stages(r); } -int call_get_channels(plugin_api_t* api, char** r) { return api->get_channels(r); } -int call_invoke_tool(plugin_api_t* api, char* n, char* a, char** r, char** e) { return api->invoke_tool(n, a, r, e); } -int call_invoke_stage(plugin_api_t* api, char* s, char* c, char** e) { return api->invoke_stage(s, c, e); } -int call_invoke_output(plugin_api_t* api, char* c, char* m, char* p, char** e) { return api->invoke_output(c, m, p, e); } +// Functions implemented in loader.c +extern core_api_t* make_core_api(void); +extern void free_core_api(core_api_t* api); +extern int call_init_plugin(plugin_api_t*, char*, char*, char**); +extern int call_start_plugin(plugin_api_t*, void*, int, char**); +extern int call_stop_plugin(plugin_api_t*, char**); +extern int call_invoke_tool(plugin_api_t*, char*, char*, char**, char**); +extern int call_invoke_stage(plugin_api_t*, char*, char*, char**); +extern int call_invoke_output(plugin_api_t*, char*, char*, char*, char**); +extern void api_free_string(plugin_api_t*, char*); +extern void* lib_open(const char*); +extern plugin_api_t* lib_get_api(void*); +extern void lib_close(void*); +extern char* lib_err(void); */ import "C" import ( "encoding/json" "fmt" + "sync" + "sync/atomic" "unsafe" + + sdk "gitcode.com/JianFeeeee/HomeAgent/internal/sdk" ) +var ( + pluginMap sync.Map // int32 pluginID → *pluginState + nextID int32 +) + +type pluginState struct { + id int32 + name string + sdk *sdk.PluginSDK // set after CreateCoreAPI +} + // Handle represents a loaded C ABI plugin. type Handle struct { soPath string - lib C.libHandle + lib unsafe.Pointer api *C.plugin_api_t + core *C.core_api_t + pstate *pluginState } -// Load opens a .so plugin and initializes it via the C ABI. +// Load opens a .so plugin and initializes it via C ABI. func Load(soPath, name string, config map[string]interface{}) (*Handle, error) { cPath := C.CString(soPath) defer C.free(unsafe.Pointer(cPath)) lib := C.lib_open(cPath) if lib == nil { - errStr := C.GoString(C.lib_get_error()) - return nil, fmt.Errorf("dlopen %s: %s", soPath, errStr) + return nil, fmt.Errorf("dlopen %s: %s", soPath, C.GoString(C.lib_err())) } api := C.lib_get_api(lib) if api == nil { C.lib_close(lib) - errStr := C.GoString(C.lib_get_error()) - return nil, fmt.Errorf("dlsym plugin_init in %s: %s", soPath, errStr) + return nil, fmt.Errorf("dlsym plugin_init in %s: %s", soPath, C.GoString(C.lib_err())) } - - if int(api.version) < ABIVersionMin { + if int(api.version) < 1 || api.init_plugin == nil { C.lib_close(lib) - return nil, fmt.Errorf("plugin %s ABI version %d < minimum %d", name, int(api.version), ABIVersionMin) + return nil, fmt.Errorf("plugin %s: invalid PluginAPI (version=%d)", name, int(api.version)) } - handle := &Handle{soPath: soPath, lib: lib, api: api} + id := atomic.AddInt32(&nextID, 1) + ps := &pluginState{id: id, name: name} + pluginMap.Store(id, ps) + + handle := &Handle{soPath: soPath, lib: lib, api: api, pstate: ps} + + // Create CoreAPI later — done via CreateCoreAPI // Initialize plugin configJSON, _ := json.Marshal(config) @@ -136,12 +107,9 @@ func Load(soPath, name string, config map[string]interface{}) (*Handle, error) { defer C.free(unsafe.Pointer(cName)) defer C.free(unsafe.Pointer(cConfig)) - if ret := C.int(C.call_init_plugin(api, cName, cConfig, &initErr)); ret != 0 { + if ret := int(C.call_init_plugin(api, cName, cConfig, &initErr)); ret != 0 { errMsg := "" - if initErr != nil { - errMsg = C.GoString(initErr) - C.api_free_string(api, initErr) - } + if initErr != nil { errMsg = C.GoString(initErr); C.api_free_string(api, initErr) } handle.Close() return nil, fmt.Errorf("init_plugin %s: %s", name, errMsg) } @@ -149,9 +117,31 @@ func Load(soPath, name string, config map[string]interface{}) (*Handle, error) { return handle, nil } +// CreateCoreAPI creates a CoreAPI struct for this plugin. +// The CoreAPI dispatches all SDK calls back to Go, routing to the plugin's PluginSDK. +func (h *Handle) CreateCoreAPI(s *sdk.PluginSDK) unsafe.Pointer { + core := C.make_core_api() + if core == nil { return nil } + h.core = core + h.pstate.sdk = s + + // Store plugin ID as context (safe integer, not a Go pointer) + core.ctx = unsafe.Pointer(uintptr(h.pstate.id)) + + return unsafe.Pointer(core) +} + +// FreeCoreAPI frees the CoreAPI struct. +func (h *Handle) FreeCoreAPI() { + if h.core != nil { + C.free_core_api(h.core) + h.core = nil + } +} + // Start calls the plugin's Start with a CoreAPI pointer. func (h *Handle) Start(corePtr unsafe.Pointer) error { - if ret := C.int(C.call_start_plugin(h.api, corePtr, C.int(ABIVersion), nil)); ret != 0 { + if ret := int(C.call_start_plugin(h.api, corePtr, C.int(1), nil)); ret != 0 { return fmt.Errorf("start_plugin failed") } return nil @@ -159,60 +149,12 @@ func (h *Handle) Start(corePtr unsafe.Pointer) error { // Stop calls the plugin's Stop. func (h *Handle) Stop() error { - if ret := C.int(C.call_stop_plugin(h.api, nil)); ret != 0 { + if ret := int(C.call_stop_plugin(h.api, nil)); ret != 0 { return fmt.Errorf("stop_plugin failed") } return nil } -// GetToolDefs returns the tool definitions registered by the plugin during Start. -func (h *Handle) GetToolDefs() ([]json.RawMessage, error) { - var result *C.char - if ret := C.int(C.call_get_tool_defs(h.api, &result)); ret != 0 || result == nil { - return nil, nil - } - defer C.api_free_string(h.api, result) - var defs []json.RawMessage - if err := json.Unmarshal([]byte(C.GoString(result)), &defs); err != nil { - return nil, err - } - return defs, nil -} - -// GetStages returns stage names registered by the plugin. -func (h *Handle) GetStages() ([]string, error) { - var result *C.char - if ret := C.int(C.call_get_stages(h.api, &result)); ret != 0 || result == nil { - return nil, nil - } - defer C.api_free_string(h.api, result) - var stages []string - if err := json.Unmarshal([]byte(C.GoString(result)), &stages); err != nil { - return nil, err - } - return stages, nil -} - -// GetChannels returns output channel registrations. -func (h *Handle) GetChannels() ([]channelInfo, error) { - var result *C.char - if ret := C.int(C.call_get_channels(h.api, &result)); ret != 0 || result == nil { - return nil, nil - } - defer C.api_free_string(h.api, result) - var channels []channelInfo - if err := json.Unmarshal([]byte(C.GoString(result)), &channels); err != nil { - return nil, err - } - return channels, nil -} - -type channelInfo struct { - Name string `json:"name"` - Caps int `json:"caps"` - Desc string `json:"desc"` -} - // InvokeTool calls a tool handler in the plugin. func (h *Handle) InvokeTool(name string, args map[string]interface{}) (map[string]interface{}, error) { argsJSON, _ := json.Marshal(args) @@ -222,37 +164,18 @@ func (h *Handle) InvokeTool(name string, args map[string]interface{}) (map[strin defer C.free(unsafe.Pointer(cName)) defer C.free(unsafe.Pointer(cArgs)) - if ret := C.int(C.call_invoke_tool(h.api, cName, cArgs, &result, &cErr)); ret != 0 { + if ret := int(C.call_invoke_tool(h.api, cName, cArgs, &result, &cErr)); ret != 0 { errMsg := "" - if cErr != nil { - errMsg = C.GoString(cErr) - C.api_free_string(h.api, cErr) - } + if cErr != nil { errMsg = C.GoString(cErr); C.api_free_string(h.api, cErr) } return nil, fmt.Errorf("invoke_tool %s: %s", name, errMsg) } - if result == nil { - return nil, nil - } + if result == nil { return nil, nil } defer C.api_free_string(h.api, result) var r map[string]interface{} - if err := json.Unmarshal([]byte(C.GoString(result)), &r); err != nil { - return nil, err - } + if err := json.Unmarshal([]byte(C.GoString(result)), &r); err != nil { return nil, err } return r, nil } -// InvokeStage calls a stage handler in the plugin. -func (h *Handle) InvokeStage(stage, ctxJSON string) error { - cStage := C.CString(stage) - cCtx := C.CString(ctxJSON) - defer C.free(unsafe.Pointer(cStage)) - defer C.free(unsafe.Pointer(cCtx)) - if ret := C.int(C.call_invoke_stage(h.api, cStage, cCtx, nil)); ret != 0 { - return fmt.Errorf("invoke_stage %s failed", stage) - } - return nil -} - // Close unloads the plugin library. func (h *Handle) Close() { if h.lib != nil { @@ -260,3 +183,194 @@ func (h *Handle) Close() { h.lib = nil } } + +// go_core_dispatch handles all plugin→core SDK calls. +// CoreAPI.dispatch → dispatch_bridge (C) → go_core_dispatch (Go) → PluginSDK +// +//export go_core_dispatch +func go_core_dispatch(methodID C.int, ctx unsafe.Pointer, s1, s2, s3 *C.char, i1, i2 C.int, result **C.char, errorOut **C.char) C.int { + pluginID := int32(uintptr(ctx)) + v, ok := pluginMap.Load(pluginID) + if !ok { return 1 } + ps := v.(*pluginState) + s := ps.sdk + + a1, a2, a3 := goStr(s1), goStr(s2), goStr(s3) + n1, n2 := int(i1), int(i2) + + _ = n2 + switch int(methodID) { + case 1: // CORE_REGISTER_TOOL + var def sdk.ToolDef + if err := json.Unmarshal([]byte(a2), &def); err != nil { setErr(errorOut, err); return 1 } + def.Plugin = ps.name + _ = s.RegisterTool(a1, def, func(args map[string]interface{}) (interface{}, error) { + return nil, nil + }) + return 0 + + case 2: // CORE_REGISTER_STAGE + s.RegisterStage(sdk.Stage(a1), func(sc *sdk.StageContext) error { return nil }) + return 0 + + case 3: // CORE_REGISTER_OUTPUT_CH + return 0 + + case 4: // CORE_REGISTER_PLUGIN_API + s.RegisterPluginAPI(a1) + return 0 + + case 5: // CORE_INJECT_TEXT + s.InjectText(a1, a2, a3) + return 0 + + case 6: // CORE_INJECT_INTERRUPT_TEXT + s.InjectInterruptText(a1, a2, a3) + return 0 + + case 7: // CORE_INJECT_TEXT_NO_MEMORY + s.InjectTextNoMemory(a1, a2, a3) + return 0 + + case 8: // CORE_SET_AUTO_RESTART + s.SetAutoRestart(n1 != 0) + return 0 + + case 9: // CORE_MEMORY_RECALL + if mem := s.Memory(); mem != nil { + entities, relations, err := mem.Recall([]string{a1}, n1) + if err != nil { setErr(errorOut, err); return 1 } + b, _ := json.Marshal(map[string]interface{}{"entities": entities, "relations": relations}) + *result = C.CString(string(b)) + } + return 0 + + case 10: // CORE_MEMORY_COMMIT + if mem := s.Memory(); mem != nil { + var triples []sdk.Triple + if err := json.Unmarshal([]byte(a1), &triples); err != nil { setErr(errorOut, err); return 1 } + if err := mem.Commit(triples); err != nil { setErr(errorOut, err); return 1 } + } + return 0 + + case 11: // CORE_MEMORY_INTROSPECT + if mem := s.Memory(); mem != nil { + r, err := mem.Introspect() + if err != nil { setErr(errorOut, err); return 1 } + b, _ := json.Marshal(r) + *result = C.CString(string(b)) + } + return 0 + + case 12: // CORE_MEMORY_MERGE + if mem := s.Memory(); mem != nil { + if _, err := mem.MergeEntities(a1, a2); err != nil { setErr(errorOut, err); return 1 } + } + return 0 + + case 13: // CORE_MEMORY_PURGE + if mem := s.Memory(); mem != nil { + var criteria map[string]string + if err := json.Unmarshal([]byte(a1), &criteria); err != nil { setErr(errorOut, err); return 1 } + mode := "soft" + if n1 != 0 { mode = "hard" } + if _, err := mem.Purge(criteria, mode); err != nil { setErr(errorOut, err); return 1 } + } + return 0 + + case 14: // CORE_DOC_QUERY + if dm := s.DocMemory(); dm != nil { + docs := dm.Query(a1, n1) + b, _ := json.Marshal(docs) + *result = C.CString(string(b)) + } + return 0 + + case 15: // CORE_KNOWLEDGE_SEARCH + if kn := s.Knowledge(); kn != nil { + results, err := kn.Search(a1, n1) + if err != nil { setErr(errorOut, err); return 1 } + b, _ := json.Marshal(results) + *result = C.CString(string(b)) + } + return 0 + + case 16: // CORE_SETTINGS_GET + if sett := s.Settings(); sett != nil { + v, err := sett.Get(a1) + if err != nil { setErr(errorOut, err); return 1 } + b, _ := json.Marshal(v) + *result = C.CString(string(b)) + } + return 0 + + case 17: // CORE_SETTINGS_SET + if sett := s.Settings(); sett != nil { + var v interface{} + json.Unmarshal([]byte(a2), &v) + if err := sett.Set(a1, v); err != nil { setErr(errorOut, err); return 1 } + } + return 0 + + case 18: // CORE_SETTINGS_REGISTER_DEF + if sett := s.Settings(); sett != nil { + var def sdk.ConfigDef + if err := json.Unmarshal([]byte(a1), &def); err != nil { setErr(errorOut, err); return 1 } + sett.RegisterDef(def) + } + return 0 + + case 19: // CORE_LLM_LIST_SOURCES + if llm := s.LLM(); llm != nil { + b, _ := json.Marshal(llm.ListSources()) + *result = C.CString(string(b)) + } + return 0 + + case 20: // CORE_LLM_SET_SOURCE + if llm := s.LLM(); llm != nil { + if err := llm.SetSource(a1); err != nil { setErr(errorOut, err); return 1 } + } + return 0 + + case 21: // CORE_SOCIAL_GET_PERSON + if social := s.Social(); social != nil { + p, err := social.GetPerson(a1) + if err != nil { setErr(errorOut, err); return 1 } + b, _ := json.Marshal(p) + *result = C.CString(string(b)) + } + return 0 + + case 22: // CORE_SOCIAL_GET_NETWORK + if social := s.Social(); social != nil { + profiles, err := social.GetNetwork(a1, n1) + if err != nil { setErr(errorOut, err); return 1 } + b, _ := json.Marshal(profiles) + *result = C.CString(string(b)) + } + return 0 + + case 23: // CORE_SUBSCRIBE + return 0 + + case 24: // CORE_UNSUBSCRIBE + return 0 + + case 25: // CORE_FREE_STRING + if s1 != nil { C.free(unsafe.Pointer(s1)) } + return 0 + } + return 0 +} + +func goStr(s *C.char) string { + if s == nil { return "" } + return C.GoString(s) +} + +func setErr(errOut **C.char, err error) { + if errOut != nil && err != nil { + *errOut = C.CString(err.Error()) + } +} diff --git a/internal/plugin/dynamic.go b/internal/plugin/dynamic.go index 2ca7225..5a2a943 100644 --- a/internal/plugin/dynamic.go +++ b/internal/plugin/dynamic.go @@ -9,7 +9,6 @@ import ( "path/filepath" "plugin" "reflect" - "unsafe" sdk "gitcode.com/JianFeeeee/HomeAgent/internal/sdk" pubsdk "gitcode.com/JianFeeeee/homeagent-sdk/sdk" @@ -61,42 +60,16 @@ type cabiPlugin struct { func (p *cabiPlugin) Name() string { return p.name } func (p *cabiPlugin) Start(s *sdk.PluginSDK) error { - // Build CoreAPI from the provided PluginSDK and pass to plugin - corePtr := buildCoreAPI(s, p.name) + // Create CoreAPI backed by the real PluginSDK and pass to plugin + corePtr := p.handle.CreateCoreAPI(s) + if corePtr == nil { + return fmt.Errorf("cabi: failed to create CoreAPI for %s", p.name) + } + defer p.handle.FreeCoreAPI() + if err := p.handle.Start(corePtr); err != nil { - return err + return fmt.Errorf("cabi: start %s: %w", p.name, err) } - - // Discover tools/stages/channels registered by the plugin during Start - defs, _ := p.handle.GetToolDefs() - for _, d := range defs { - var td pubsdk.ToolDef - if err := json.Unmarshal(d, &td); err != nil { - continue - } - toolName := td.Name - td.Plugin = p.name - s.RegisterTool(toolName, sdk.ToolDef{ - Name: toolName, - Description: td.Description, - Parameters: td.Parameters, - Plugin: p.name, - }, makeCABIHandler(p.handle, toolName)) - } - - stages, _ := p.handle.GetStages() - for _, stage := range stages { - st := sdk.Stage(stage) - s.RegisterStage(st, func(sc *sdk.StageContext) error { - ctxJSON, _ := json.Marshal(map[string]interface{}{ - "raw_message": sc.RawMessage, - "user_id": sc.UserID, - "phase": string(sc.Phase), - }) - return p.handle.InvokeStage(stage, string(ctxJSON)) - }) - } - return nil } @@ -105,19 +78,6 @@ func (p *cabiPlugin) Stop() error { return nil } -func makeCABIHandler(handle *cabi.Handle, toolName string) sdk.ToolHandler { - return func(args map[string]interface{}) (interface{}, error) { - return handle.InvokeTool(toolName, args) - } -} - -// buildCoreAPI creates a C-compatible CoreAPI function table from a PluginSDK. -// Returns an unsafe.Pointer to a C-allocated struct. -// TODO: implement CoreAPI dispatch that calls back into the Go PluginSDK -func buildCoreAPI(s *sdk.PluginSDK, pluginName string) unsafe.Pointer { - return unsafe.Pointer(nil) // placeholder - will be implemented in core dispatch -} - // tryLoadSO 尝试从插件目录加载 plugin.so。 // 优先尝试 C ABI 加载（-buildmode=c-shared），失败时回退到 Go plugin.Open。 func tryLoadSO(dir, name string, config map[string]interface{}) (sdk.Plugin, error) {