Method Tools

go/engine/node/functioncall.go:92–141

Tools exposes this function as an LLM-callable tool.

()

// Tools exposes this function as an LLM-callable tool.
func (n *FunctionCall) Tools() ([]llmproxy.FunctionTool, error) {
	properties := make(map[string]any, len(n.fn.Info.Arguments))
	argByName := make(map[string]workflowapi.Variable, len(n.fn.Info.Arguments))
	for _, a := range n.fn.Info.Arguments {
		properties[a.Name] = map[string]any{"type": JSONTypeFor(a.DataType)}
		argByName[a.Name] = a
	}
	returnByUid := make(map[string]workflowapi.Variable, len(n.fn.Info.Returns))
	for _, r := range n.fn.Info.Returns {
		returnByUid[r.Uid] = r
	}

	ft := llmproxy.FunctionTool{
		ExternalToolBase: llmproxy.ExternalToolBase{
			Name:        n.fn.Info.Name,
			Description: n.toolDescription,
			Parameters:  schemautil.StrictObject(properties),
		},
		ToolCall: func(ctx context.Context, arguments json.RawMessage) (any, error) {
			var in map[string]any
			if len(arguments) > 0 {
				if err := json.Unmarshal(arguments, &in); err != nil {
					return nil, fmt.Errorf("function_call %s: parse arguments: %w", n.ID(), err)
				}
			}
			args := make(map[string]expr.Value, len(argByName))
			for argName, meta := range argByName {
				raw, ok := in[argName]
				if !ok {
					return nil, fmt.Errorf("function_call %s: missing argument %q", n.ID(), argName)
				}
				v, err := expr.Coerce(meta.DataType, raw)
				if err != nil {
					return nil, fmt.Errorf("function_call %s: argument %q: %w", n.ID(), argName, err)
				}
				args[meta.Uid] = v
			}
			results, err := n.fn.Call(ctx, args)
			if err != nil {
				return nil, fmt.Errorf("function_call %s: %w", n.ID(), err)
			}
			out := make(map[string]any, len(results))
			for uid, v := range results {
				out[returnByUid[uid].Name] = v.Raw
			}
			return out, nil
		},
	}
	return []llmproxy.FunctionTool{ft}, nil
}